import Node from '../components/flow/helpers/Node'
import Flow from '../components/flow/helpers/Flow'
import { createConditionNode } from '../components/flow/helpers/NodeUtils'
import {
getNodeType,
createFlowGraph,
convertParticipant
// convertTransfer,
} from '../utils/adapterHelpers'
import {
updateFieldsWhenCreate,
updateFieldsWithMerge
} from '../utils/fieldsHelpers'
import { deepCopy } from '../utils/index'
import { SPONSOR_PICKER_TYPE } from '../constants/CONDITION_ADDITION'
/**
* @typedef {import('../components/flow/helpers/FlowGraph').default} FlowGraph
* @typedef {{ id: string, type?: 'general'|'other_condition', name?: string|null, targetTaskId: string, sourceTaskId: string, conditions?: [] }} SequenceItem
*
* toModel 序列化服务端数据 ServeModel 到客户端数据 ClientModel
* @param {{taskList: TaskNode[], sequenceList: SequenceItem[]}} ServerDataModel 服务端返回的数据 model
* @param {{flowFields: [], conditionFields: []}} ClientDataModel 解析数据时需要的客户端本地数据
* @param {boolean} isBusinessFlow 是否是业务流程
* @returns {Node}
*/
export const toModel = (
{ taskList = [], sequenceList = [] } = {},
{ flowFields = [], conditionFields = [] } = {},
isBusinessFlow
) => {
if (taskList.length && sequenceList.length) {
/* 有数据/反填充的情况下,处理数据初始化 graph vertices & edges,返回第一个节点 */
const startNode = connectGraphEdges(
{ taskList, sequenceList },
{ flowFields, conditionFields },
isBusinessFlow
)
return startNode
} else {
/* 无数据/新建的情况下,返回默认的起始节点 */
return Flow.createNode({
type: Node.TYPE.SPONSOR_NODE,
nodeId: 'task-start',
formFieldList: flowFields
}).next(
Flow.createNode({
type: Node.TYPE.APPROVER_NODE,
formFieldList: updateFieldsWhenCreate(flowFields)(
Node.TYPE.APPROVER_NODE
)
})
)
}
}
/**
* connectGraphEdges
* @param {{taskList: TaskNode[], sequenceList: SequenceItem[]}} ServerDataModel 服务端返回的数据 model
* @param {{flowFields: [], conditionFields: []}} ClientDataModel 解析数据时需要的客户端本地数据
* @param {boolean} isBusinessFlow 是否是业务流程
* @returns {Node} startNode
*/
const connectGraphEdges = (
{ sequenceList, taskList },
{ flowFields, conditionFields },
isBusinessFlow
) => {
const graph = createFlowGraph()
const findTask = findTaskById(taskList)
let startNode = null
for (let i = 0; i < sequenceList.length; i++) {
const node = sequenceList[i]
const {
type: conditionType,
sourceTaskId,
targetTaskId,
conditionList
} = node
const sourceNode = Flow.createNode(
toNode(deepCopy(findTask(sourceTaskId)), { flowFields })
)
const targetNode = Flow.createNode(
toNode(deepCopy(findTask(targetTaskId)), { flowFields })
)
// fix: [审批流]条件字段不存在不能发布审批流程的(#1022122)
const conditions =
Array.isArray(conditionList) && conditionList.length
? filterConditions(conditionList, flowFields, isBusinessFlow)
: []
// 如果是条件分支,开始绘制各个条件
if (sourceNode.type === Node.TYPE.CONDITION_BRANCH) {
const conditionNode = createConditionNode({
conditions,
conditionType
})
conditionNode.read({
conditions,
fields: conditionFields
})
graph.addEdge(sourceNode, conditionNode)
graph.addEdge(conditionNode, targetNode)
} else {
if (sourceNode.type === Node.TYPE.PARALLEL_BRANCH) {
targetNode.alias = Node.TYPE.PARALLEL_NODE
}
graph.addEdge(sourceNode, targetNode)
}
if (!startNode) {
startNode = sourceNode
}
}
drawNodeLinesByGraph(graph)
return startNode
}
/**
* * drawNodeLinesByGraph BFS 绘制视图节点和连线
* @param {FlowGraph} graph
* @param {Node} startNode
* // @param {WeakMap<Node, Node>} conditionNodesMap
*/
export const drawNodeLinesByGraph = (graph) => {
if (process.env.NODE_ENV === 'development') {
console.log('graph: ', graph)
}
const commonNodeMap = {}
for (const [key, node] of graph.edges) {
// END_NODE or PARALLEL_BRANCH_END 无需连线
if (
node &&
node.type !== Node.TYPE.PARALLEL_BRANCH_END &&
node.type !== Node.TYPE.CONDITION_BRANCH_END &&
node.type !== Node.TYPE.END_NODE
) {
const prevNode = graph.getVertexByKey(key)
if (commonNodeMap[node.nodeId]) {
console.log('commonNodeMap: ', commonNodeMap)
continue
} else {
prevNode.next(node)
}
if (prevNode.oppositeTaskId && !commonNodeMap[prevNode.oppositeTaskId]) {
if (!prevNode.childNode) {
commonNodeMap[prevNode.oppositeTaskId] = prevNode.next(
graph.getVertexByKey(prevNode.oppositeTaskId)
)
}
}
}
}
}
/**
* @typedef ClientNodeModel
* @property {string} nodeId
* @property {string} type
* @property {{ title: string, content: string }} model
* @property {{ type: string, list: [], [fieldKey]: string }} [participant]
* @property {[]} [formFieldList]
*
* toNode 将 ServerTaskItem 转为 Node 构造函数参数
* @param {TaskNode} ServerTaskItem
* @param {{flowFields: [], conditionFields: []}} ClientDataModel 解析数据时需要的客户端本地数据
* @param {boolean} needConvert 是否转换数据结构到 ClientViewModel
* @returns {ClientNodeModel}
*/
export const toNode = (
{
taskNodeId = '',
taskNodeName = '',
taskType = '',
participant = {},
transfer,
formFieldList = [],
...props
} = {},
{ flowFields: fields = [] } = {},
needConvert = true
) => {
const nodeType = getNodeType(taskType)
let content = ''
if (needConvert) {
if (participant) {
content = convertParticipant(participant, fields)
}
// convertTransfer(transfer, nodeType)
}
return {
nodeId: taskNodeId,
type: nodeType,
model: {
title: taskNodeName,
content
},
participant,
transfer,
formFieldList: updateFieldsWithMerge(fields, formFieldList, nodeType),
...props
}
}
/**
* findTaskById
* @typedef {Object<string, any>} TaskNode
* @property {string} taskNodeId
* @property {string} taskNodeName
* @property {string} taskType
* @property {Object<string, any>} [participant]
*
* @param {TaskNode[]} tasks
* @callback FindTaskFn
* @param {string} id
* @returns {TaskNode}
* @returns {FindTaskFn}
*/
export const findTaskById = (tasks = []) => {
const cachedTasks = tasks.reduce((cache, task) => {
cache[task.taskNodeId] = task
return cache
}, {})
return (id) => {
return (
id &&
(cachedTasks[id]
? cachedTasks[id]
: (cachedTasks[id] = tasks.find((t) => t && t.taskNodeId === id)))
)
}
}
/**
* @param {field[]} flowFields
* @param {condition[]} conditionList
* @param {boolean} isBusinessFlow 是否是业务流程
*/
function filterConditions(conditionList, flowFields, isBusinessFlow) {
return conditionList.filter(Boolean).map((condition) => {
// 如果是默认的发起人类型
const isSponsor = SPONSOR_PICKER_TYPE[condition.fieldKey]
if (!isSponsor) {
const field = flowFields.find(
(item) => item.fieldKey === condition.fieldKey
)
if (!field) {
condition.fieldKey = ''
} else {
// fix: 如果是业务流程,且字段的 required 属性是 false,也需要清空该条件
if (isBusinessFlow && field.require !== undefined && !field.require) {
condition.fieldKey = ''
}
}
}
return condition
})
}