import { changeTypeByTaskShape, changeTypeByTrigger, hasGatewayType, typeConfig } from '../../../config'; import { jnpfConfigBpmnContextPad } from '../../../config/contextPad'; import { bpmnEnd, bpmnTask, typeTask, typeSubFlow, typeLabel, bpmnInclusive, typeConfluence, bpmnStart, typeTrigger, bpmnTrigger, typeExecute, bpmnLabel, typeStart, typeCopy, bpmnCopy, bpmnPaste, typePaste, bpmnChoose, typeProcessing, typeOutside, typeEnd, typeChoose, typeCondition, } from '../../../config/variableName'; import { BPMNTreeBuilder } from '../../../utils/constructTreeUtil'; import { DEFAULT_DISTANCE } from '../../../config/constants'; import { buildBitUUID } from '../../../utils/uuidUtil'; import { NodeUtils } from '../../../utils/nodeUtil'; import bpmnType from '../../../palette/bpmnType'; const CustomizeContextPad = (contextPadProvider: any, element: any) => { let type = element.type; let isAction = true; if (typeConfig[type]) { const { _autoPlace: autoPlace, _create: create, _elementFactory: elementFactory, _modeling: modeling, _connect: connects, _injector: injector, _rules: rules, _eventBus: eventBus, } = contextPadProvider; let wnType = element.wnType; if (wnType === bpmnTrigger) type = bpmnTrigger; if (changeTypeByTaskShape[wnType]) type = changeTypeByTaskShape[wnType]; const { contextPad, shapeType } = typeConfig[type]; const { del, copy, paste } = jnpfConfigBpmnContextPad; let customization = contextPad?.customization; if (type === bpmnLabel) { let connect = element?.labelTarget; let target = connect.target; // 执行节点的线label使用groupCustomization if (changeTypeByTaskShape[target.wnType]) { customization = contextPad?.groupCustomization; } } if (type === shapeType) { if (contextPad) { let jnpfData = injector.get('jnpfData'); let copyElement = jnpfData.getValue('copyType'); if (element.wnType === typeTrigger && changeTypeByTaskShape[copyElement.type]) customization = contextPad?.otherCustomization; if (changeTypeByTaskShape[element.wnType] && changeTypeByTaskShape[copyElement.type]) customization = contextPad?.otherCustomization; if (contextPad.default) return defaultContextPad; else if (customization) { let result: any = {}; for (let key of Object.keys(customization)) { let data = customization[key]; if (data.group === 'model') { let options: any = { wnName: typeConfig[key]?.renderer.rendererName, }; if (element.type === bpmnStart && hasGatewayType.has(key)) { // 开始节点只有分类节点 因为网关的分流节点和合流节点类型一致 多增加一个字段来表示 options = { wnName: typeConfig[key]?.renderer.rendererName, wnGatewayType: key, wnType: key, icon: data.icon, }; } result[data.name] = appendAction(data.type, data.elementName, data.className, data.title, data.wnType, options); } else if (data.group === 'connect') { result[data.name] = { group: data.group, className: data.className, title: data.title, action: { click: isAction && startConnect, }, }; } else if (data.group === 'edit') { result[data.name] = { group: data.group, className: data.className, title: data.title, action: { click: removeElement, }, }; } } return Object.assign(result); } else return defaultContextPad(); } // 单个节点删除功能 function removeElement() { rules.allowed('elements.delete', { elements: [element] }); } // 开始连线（拖拽） function startConnect(event: any, element: any) { connects.start(event, element); } // 添加事件 function appendAction(type: any, name: any, className: any, title: any, wnType: any, options?: any) { const appendStart = (event: any, element: any) => { let bpmnFactory = elementFactory._bpmnFactory; if ([typeSubFlow, typeProcessing, typeOutside].includes(type)) type = bpmnTask; let businessObject = bpmnFactory.create(type); let shape = elementFactory.createShape(Object.assign({ type, name, wnType, ...options }, businessObject)); create.start(event, shape, { source: element }); }; const autoPlaceAppend = async (_event: any, element: any) => { let isPaste = false; if (wnType === typeCopy) { copyElement(element.wnType); return; } if (wnType === typePaste) { let jnpfData = injector.get('jnpfData'); let data = jnpfData.getValue(bpmnCopy); let copyElement = jnpfData.getValue('copyType'); isPaste = true; if ([typeOutside, typeTrigger, 'default'].includes(copyElement.type)) { type = data.type; wnType = data.wnType; className = data.className; title = data.title; options = data.options; if (element.outgoing.length > 1) { let connect = element.outgoing.find(connect => connect.target.wnType != typeTrigger); element = connect.label; } else { element = element.outgoing[0]?.label; } } if (copyElement.type === typeTrigger || changeTypeByTaskShape[copyElement.type]) { type = data.type; wnType = data.wnType; className = data.className; title = data.title; options = data.options; name = data.name; } } let hasTaskType = new Set([typeSubFlow, typeProcessing, typeTrigger, typeOutside]); if (hasTaskType.has(type) || changeTypeByTaskShape[wnType]) type = bpmnTask; let bpmnFactory = elementFactory._bpmnFactory; let isChoose = false; if (type === bpmnChoose) { type = bpmnInclusive; isChoose = true; } let businessObject = type === bpmnType ? bpmnFactory.create(element.type) : bpmnFactory.create(type); let shape = elementFactory.createShape(Object.assign({ type, name: name, businessObject, wnType: wnType }, options)); if (element.type === typeLabel) { let businessTaskObject = bpmnFactory.create(bpmnTask); let businessTask2Object = bpmnFactory.create(bpmnTask); let businessInclusiveObject = bpmnFactory.create(bpmnInclusive); let shape: any; if (hasGatewayType.has(wnType)) { let id = `Gateway_${buildBitUUID()}_isSimple`; businessObject.id = id; shape = elementFactory.createShape(Object.assign({ type, id: id, name: name, businessObject, wnType: wnType }, options)); } else { shape = elementFactory.createShape(Object.assign({ type, name: name, businessObject, wnType: wnType }, options)); } updateShapePosition(shape, element, businessTaskObject, businessInclusiveObject, businessTask2Object); if (isChoose) { modeling.updateProperties(shape, { type: bpmnChoose, }); } } else { autoPlace.append(element, shape); // 自研 if (hasGatewayType.has(element.wnType)) { // 获取对应的合流网关 const gateway = injector.get('elementRegistry').get(element.id + '_confluence'); modeling.connect(shape, gateway); } // 处理执行节点的美化 (获取到最近的合流节点 判断分组与合流坐标距离计算是否需要进行偏移) if (changeTypeByTaskShape[shape.wnType]) { modeling.updateProperties(shape, { customGroupId: element.businessObject.$attrs.customGroupId, }); let groupShape = injector.get('elementRegistry').get(element.businessObject.$attrs.customGroupId); let shapeRight = shape.x + shape.width; let shapeBottom = shape.y + shape.height; let groupRight = groupShape.x + groupShape.width; let groupBottom = groupShape.y + groupShape.height; var newBounds: any = { x: groupShape.x, // 保持 x 位置不变 y: groupShape.y, // 保持 y 位置不变 width: groupShape.width, height: groupShape.height, }; if (shapeRight >= groupRight) newBounds.width = shapeRight + 25 - groupShape.x; if (shapeBottom >= groupBottom) newBounds.height = shapeBottom + 15 - groupShape.y; modeling.resizeShape(groupShape, newBounds); autoExecute(groupShape); } } // 计算需要横向偏移的元素(只有出现分流的情况下需要用到) if (element?.type === typeLabel || hasGatewayType.has(element.wnType) || element.wnType === typeTrigger || changeTypeByTaskShape[element.wnType]) onAutoPosition(); // 粘贴节点属性(需modeling.create后才能使用modeling.updatePropertie()生效) if (isPaste) { let jnpfData = injector.get('jnpfData'); let copyElement = jnpfData.getValue('copyType'); let newData = copyElement.data; let newShape = injector.get('elementRegistry').get(shape.id); let customGroupId = ""; if (changeTypeByTrigger[newShape.wnType] || newShape.wnType === typeTrigger) customGroupId = newShape?.businessObject?.$attrs?.customGroupId else if (changeTypeByTaskShape[newShape.wnType]) customGroupId = element?.businessObject?.$attrs?.customGroupId jnpfData.setValue(shape.id, { ...newData, nodeId: shape.id, groupId: customGroupId }); if (newShape) { newShape['elementBodyName'] = newData?.content || ''; newShape['nodeName'] = newData?.nodeName || ''; modeling.updateProperties(newShape, { customGroupId: customGroupId, }); } } }; var append = autoPlace ? autoPlaceAppend : appendStart; let disable = isAction; let lastsource = element?.labelTarget?.source; let nextTarget = element?.labelTarget?.target; let targetType = nextTarget?.wnType let sourceType = lastsource?.wnType if ([typeConfluence].includes(sourceType) && (hasGatewayType.has(wnType) || wnType === typeTrigger)) disable = false; if (sourceType === typeSubFlow && ([typeChoose].includes(wnType))) disable = false; if (sourceType === typeOutside && ([typeChoose, typeTrigger, typeOutside, typeSubFlow].includes(wnType))) disable = false; if (hasGatewayType.has(nextTarget?.wnType) && hasGatewayType.has(wnType)) disable = false; if (nextTarget?.wnType === typeTrigger && ([typeSubFlow, typeSubFlow, typeExecute, typeTask].includes(wnType) || hasGatewayType.has(wnType))) if (changeTypeByTaskShape[nextTarget?.wnType] && hasGatewayType.has(wnType)) disable = false; if ([typeStart, typeSubFlow].includes(sourceType) && wnType === typeTrigger) disable = false; if (([typeOutside].includes(wnType) && [typeOutside, typeSubFlow, typeChoose, typeEnd].includes(targetType))) disable = false; if (([typeSubFlow].includes(wnType) && [typeChoose].includes(targetType))) disable = false; if (([typeOutside].includes(wnType) && hasGatewayType.has(targetType))) { if (nextTarget.outgoing.some(o => [typeOutside, typeSubFlow].includes(o.target.wnType))) disable = false; let jnpfData = injector.get('jnpfData'); if (nextTarget.outgoing.some(o => jnpfData.getValue(o.id)?.conditions?.length > 0)) disable = false; // 线条如果有条件也无法添加外部节点 } if ([typeOutside].includes(wnType)) { // 如果外部节点的下一个节点是合流节点，则继续检查合流节点的下一个节点是否为结束节点，如果是则不可添加外部节点 while (nextTarget && targetType === typeConfluence) { let nextOutgoing = nextTarget.outgoing || []; // 合流网关后面如果是子流程，外部节点，结束节点，则禁用当前的外部节点 if (nextOutgoing.some(out => out.target && [typeEnd, typeSubFlow, typeOutside].includes(out.target.wnType))) { disable = false; break; } // 如果有多个分支，取第一个不是合流节点的分支继续判断，否则继续循环 let nextConfluence = nextOutgoing.find(out => out.target && out.target.wnType === typeConfluence); if (nextConfluence) nextTarget = nextConfluence.target; else break; } while (lastsource && sourceType === typeConfluence) { let lastIncoming = lastsource.incoming || []; // 合流网关后面如果是子流程，外部节点，结束节点，则禁用当前的外部节点 if (lastIncoming.some(incoming => incoming.source && [typeOutside].includes(incoming.source.wnType))) { disable = false; break; } // 如果有多个分支，取第一个不是合流节点的分支继续判断，否则继续循环 let lastConfluence = lastIncoming.find(incoming => incoming.source?.wnType === typeConfluence); if (lastConfluence) lastsource = lastConfluence.source; else break; } } return { group: 'model', className: className, title: title, disable: disable, action: { click: disable && append }, }; } // 默认contextPad function defaultContextPad() { let obj = Object.assign({ [del.name]: { group: del.group, className: del.className, title: del.title, action: { click: removeElement, }, }, [copy.name]: { group: copy.group, className: copy.className, title: copy.title, action: { click: () => copyElement(wnType === typeOutside ? typeOutside : "default"), }, }, }); let jnpfData = injector.get('jnpfData'); let data = jnpfData.getValue('copyType'); let copyNode = jnpfData.getValue('copy'); let outgoing = element.outgoing?.filter(o => o.target.wnType != typeTrigger) if (data.type === typeOutside) { if ([typeTask, typeProcessing, typeSubFlow, typeStart].includes(wnType)) { if (![typeOutside, typeSubFlow].includes(outgoing[0]?.target?.wnType)) { obj[paste.name] = appendAction(bpmnPaste, typePaste, paste.className, paste.title, typePaste, { wnName: null }); } } } else if (wnType === typeOutside) { if (([typeTask, typeProcessing, typeSubFlow, typeEnd].includes(outgoing[0]?.target?.wnType) && [typeTask, typeProcessing].includes(copyNode?.wnType)) || data.type === bpmnTrigger) { obj[paste.name] = appendAction(bpmnPaste, typePaste, paste.className, paste.title, typePaste, { wnName: null }); } } else { if (data.type === 'default' || data.type === bpmnTrigger) { if (!(data.type === bpmnTrigger && wnType === typeSubFlow)) { if (!(outgoing[0]?.target?.wnType === typeOutside && [typeSubFlow].includes(copyNode.wnType))) obj[paste.name] = appendAction(bpmnPaste, typePaste, paste.className, paste.title, typePaste, { wnName: null }); } } } return obj; } // 判断元素与网关之间的垂直距离是否小于某个阈值 function isWithinThreshold(target, source, threshold, processedElements: any) { // 这里假设网关在上方，即网关的 y 坐标小于当前元素的 y 坐标 let gatewayY = target.y; let sourceElementY = source.y; // let elementObj: any; let map = new Map( Array.from(processedElements, (item: any) => [item.id, item]), // 使用 id 作为键 ); // 如果当前元素是合流网关 获取分流到合流内所有元素 并且获取y最大值的元素与 当前分流坐标做对比 if (target.wnType === typeConfluence) { let allElements = injector.get('elementRegistry').getAll(); let treeBuilder = new BPMNTreeBuilder(allElements); let gatewayElement = injector.get('elementRegistry').get(target.id.replace('_confluence', '')); treeBuilder.onComputerMaxElementH(injector, target, gatewayElement, [], null, false, map, threshold); } if (map.has(source.id)) { sourceElementY = sourceElementY + threshold; } return gatewayY - sourceElementY > threshold && gatewayY > sourceElementY; } function moveConnectedElements(connection: any, height: any, useWithinThreshold: boolean = true) { const stack: any = []; // 用于存储待处理的连接线 const processedElements = new Set(); // 记录已经处理过的目标元素 stack.push(connection); // 从给定的连接线开始 while (stack.length > 0) { const currentConnection: any = stack.pop(); const target = currentConnection.target; if (!target) continue; // 如果没有目标元素，跳过 if (processedElements.has(target)) continue; // 如果目标元素已经处理过，跳过 if (useWithinThreshold && isWithinThreshold(target, currentConnection.source, height, processedElements)) continue; processedElements.add(target); // 标记该元素已经被处理 // 遍历目标元素的所有出线连接，并将它们压入栈 const outgoingConnections: any = target.outgoing || []; for (const outgoingConnection of outgoingConnections) { stack.push(outgoingConnection); // 将所有关联的连接线压入栈中 } } return Array.from(processedElements); } function autoExecute(groupShape: any) { // 判断groupBottom 和该触发节点对应的任务节点元素与合流节点间的距离 // 1. 获取到触发节点对应的任务节点 后续获取到该元素在哪个合流元素内部 获取到合流网关 判断合流网关和当前的判断groupBottom坐标 如果小于则需要对合流后的所有元素进行统一偏移 let triggerSourceShape: any; injector.get('elementRegistry').forEach(e => { if (e.businessObject.$attrs.customGroupId === groupShape.id && e.wnType === typeTrigger) triggerSourceShape = e.incoming[0].source; }); // 迭代获取最近的合流节点 如果下一个节点时分流节点 则获取到对应的合流节点继续获取下一个节点 function getConfluence(shape: any) { let targetList = NodeUtils.getNextElementList(shape, injector.get('elementRegistry').getAll()); let confluence: any; targetList.map((element: any) => { if (element.wnType === typeConfluence) { confluence = element; return; } if (element.wnType != typeTrigger) confluence = getConfluence(element); if (hasGatewayType.has(element.wnType)) confluence = getConfluence(injector.get('elementRegistry').get(element.id + '_confluence')); }); return confluence; } let confluenceShape = getConfluence(triggerSourceShape); if (confluenceShape) { if (groupShape && groupShape.y + groupShape.height + 50 >= confluenceShape.y) { modeling.moveElements(moveConnectedElements(confluenceShape.incoming[0], 0, false), { x: 0, y: groupShape.y + groupShape.height + DEFAULT_DISTANCE - 15 - confluenceShape.y, }); } } } async function updateShapePosition(shape: any, element: any, businessTaskObject, businessInclusiveObject, businessTask2Object) { let connectElement: any = element?.labelTarget; let targetElement = connectElement?.target; let sourceElement = connectElement?.source; let promises: any = []; if (shape.wnType === typeTrigger) { // 生成一个触发节点 let labelTargetY = (DEFAULT_DISTANCE + typeConfig[bpmnTask].renderer.attr.height) * 2; let y = labelTargetY - (targetElement.y - sourceElement.y); if (targetElement.wnType === typeConfluence) { modeling.moveElements(moveConnectedElements(element.labelTarget, labelTargetY), { x: 0, y: y, }); } autoPlace.append(sourceElement, shape); let groupShapes = modeling.createShape( { type: 'bpmn:Group', }, { x: shape.x - 25, y: shape.y - 15, width: 250, height: 118 }, shape.parent, ); modeling.updateProperties(shape, { customGroupId: groupShapes.id, }); } else if (hasGatewayType.has(shape.wnType)) { // 生成两个分支 包含分支 → 条件节点*2 → 任务节点*2 → 合流节点*1 最后融入到旧元素内 let shape1 = elementFactory.createShape( Object.assign({ type: bpmnTask, name: typeTask, businessObject: businessTaskObject, wnType: typeTask }, { wnName: '审批节点' }), ); businessInclusiveObject.id = shape.id + '_confluence'; let gateway = elementFactory.createShape( Object.assign( { id: shape.id + '_confluence', type: bpmnInclusive, name: typeConfluence, businessObject: businessInclusiveObject, wnType: typeConfluence, }, { wnName: '合流' }, ), ); let shape2 = elementFactory.createShape( Object.assign({ type: bpmnTask, name: typeTask, businessObject: businessTask2Object, wnType: typeTask }, { wnName: '审批节点' }), ); let labelTargetY = DEFAULT_DISTANCE * 4 + typeConfig[bpmnTask].renderer.attr.height + typeConfig[sourceElement.type].renderer.attr.height + typeConfig[bpmnInclusive].renderer.attr.height; promises.push( modeling.moveElements(moveConnectedElements(element.labelTarget, labelTargetY), { x: 0, y: labelTargetY - (targetElement.y - sourceElement.y), }), ); promises.push(modeling.removeConnection(connectElement)); promises.push(autoPlace.append(sourceElement, shape)); promises.push(autoPlace.append(shape, shape1)); promises.push(autoPlace.append(shape, shape2)); promises.push(autoPlace.append(shape1, gateway)); promises.push(modeling.connect(shape2, gateway)); promises.push(modeling.connect(gateway, targetElement)); } else if (targetElement) { let labelTargetY = (DEFAULT_DISTANCE + typeConfig[bpmnTask].renderer.attr.height) * 2; let y = labelTargetY - (targetElement.y - sourceElement.y); if (targetElement.type === bpmnEnd) y = DEFAULT_DISTANCE + typeConfig[bpmnTask].renderer.attr.height; if (sourceElement.type === bpmnStart) y = DEFAULT_DISTANCE + typeConfig[bpmnTask].renderer.attr.height; if (sourceElement.wnType === typeConfluence) { y = DEFAULT_DISTANCE + typeConfig[bpmnTask].renderer.attr.height; if (targetElement.y - sourceElement.y - DEFAULT_DISTANCE * 2 - typeConfig[bpmnTask].renderer.attr.height > 0) y = 0; if (targetElement.y - sourceElement.y - DEFAULT_DISTANCE * 2 - typeConfig[bpmnTask].renderer.attr.height < 0) y = (sourceElement.y + DEFAULT_DISTANCE * 2 + typeConfig[bpmnTask].renderer.attr.height) - targetElement.y; } if (sourceElement?.wnType === typeConfluence && targetElement?.wnType === typeConfluence) { let maxY = -Infinity; let id; targetElement = injector.get('elementRegistry').get(targetElement.id); targetElement.incoming?.length > 0 && targetElement.incoming.map(item => { let currentElement: any = injector.get('elementRegistry').get(item.id); if (currentElement.source?.y > maxY) { id = currentElement.source.id; maxY = currentElement.source.y; } }); if (targetElement.y - maxY <= DEFAULT_DISTANCE && sourceElement.id != id) { y = DEFAULT_DISTANCE - (targetElement.y - maxY); } } if (changeTypeByTaskShape[shape.wnType]) { let source = contextPadProvider._injector.get('elementRegistry').get(connectElement.id).source; // 需要增加customGroupId modeling.updateProperties(shape, { customGroupId: source.businessObject.$attrs.customGroupId, }); } promises.push( modeling.moveElements(moveConnectedElements(element.labelTarget, labelTargetY), { x: 0, y: y, }), ); promises.push(modeling.removeConnection(connectElement)); autoPlace.append(sourceElement, shape); promises.push(modeling.connect(shape, targetElement)); } Promise.all(promises); let elementRegistry = injector.get('elementRegistry'); let treeBuilder = new BPMNTreeBuilder(elementRegistry.getAll()); // 实例化工具类 treeBuilder.resizeGroupShape(elementRegistry.getAll(), injector); if (changeTypeByTaskShape[shape.wnType]) { let groupShape = injector.get('elementRegistry').get(targetElement.businessObject.$attrs.customGroupId); autoExecute(groupShape); } } async function onAutoPosition() { let elementRegistry: any = await contextPadProvider._injector.get('elementRegistry'); let allElements = elementRegistry.getAll(); let treeBuilder = new BPMNTreeBuilder(allElements); // 实例化工具类 let bpmnTree = treeBuilder.constructTree(1); // 构建树状数据结构 let visited: any = new Map(); // 用于防止重复访问 let shapeList: any = []; // 修改触发节点旁的连接线坐标 let confluenceMap: any = new Map(); treeBuilder.calculateVirtualWidth(bpmnTree, elementRegistry); // 计算虚拟宽度 treeBuilder.traverseTreeBFS(bpmnTree, node => { node?.offset && node.x != node.offset.x && visited.set(node.id, node); if (node?.children?.length > 0) { let hasTrigger = node.children.some(o => o.wnType === typeTrigger); let hasConfluence = node.children.some(o => o.wnType === typeConfluence); let shape = elementRegistry.get(node.id); let confluence: any; if (shape.outgoing?.length) { shape.outgoing.map((connect: any) => { if (connect.target.wnType === typeTrigger) hasTrigger = true; if (connect.target.wnType === typeConfluence) { confluence = connect.target; hasConfluence = true; } }); } if (hasTrigger && hasConfluence) shapeList.push({ shape: elementRegistry.get(node.id), treeShape: node, treeConfluence: node.children[0], confluence: confluence }); if (node.wnType === typeConfluence) confluenceMap.set(node.id, node); } }); treeBuilder.formatCanvas(Array.from(visited.values()), modeling, elementRegistry); // 如果某个节点的出线包含合流及触发节点元素 则将连接合流节点的线进行进行重新绘制（根据当前节点的虚拟宽度计算出偏移的xy轴坐标中点） // 虚拟宽度的最左侧坐标为 当前元素的x + width/2 - 虚拟宽度/2 shapeList.map(({ shape, treeShape, treeConfluence, confluence }) => { let confluenceElement = confluenceMap.get(treeConfluence.id); let x = shape.x + shape.width / 2 - treeShape.virtualWidth / 2 + shape.width / 2; let newWaypoints: any = []; if (!confluenceElement) { confluenceElement = confluenceMap.get(confluence.id); let childrenShape = treeShape.children[treeShape.children.length - 1]; if (childrenShape.wnType === typeConfluence) { childrenShape = treeShape.children[treeShape.children.length - 2]; } x = (childrenShape.offset?.x ? childrenShape.offset.x : childrenShape.x) + childrenShape.virtualWidth / 2 + childrenShape.width / 2 + 120; newWaypoints = [ { x: shape.x + shape.width, y: shape.y + shape.height / 2 }, { x: x, y: shape.y + shape.height / 2 }, { x: x, y: confluenceElement.y }, { x: confluenceElement.x, y: confluenceElement.y }, ]; } else { newWaypoints = [ { x: shape.x, y: shape.y + shape.height / 2 }, { x: x, y: shape.y + shape.height / 2 }, { x: x, y: confluenceElement.y }, { x: confluenceElement.x, y: confluenceElement.y }, ]; } let connect = shape.outgoing[0]; if (shape.outgoing?.length) { connect = shape.outgoing.find(connect => connect.target.wnType != typeTrigger); } modeling.updateWaypoints(connect, newWaypoints); }); treeBuilder.resizeGroupShape(elementRegistry.getAll(), injector); } // 复制节点 function copyElement(type) { let jnpfData = injector.get('jnpfData'); let selection = injector.get('selection'); let copyData = jnpfData.getValue(element.id); jnpfData.setValue(bpmnCopy, element); jnpfData.setValue('copyType', { type: type, data: copyData }); eventBus.fire('custom.message', { context: '复制成功', messageType: 'success', }); selection.select(null); } } return undefined; } return undefined; }; export default CustomizeContextPad;