@processmaker/modeler 1.27.0 → 1.28.0

package/src/components/nodes/genericFlow/DataOutputAssociation.js

@@ -12,8 +12,60 @@ export default class DataOutputAssociation extends DataAssociation {
       return false;
     }
 
-    return DataAssociation.isADataNode(targetNode) &&
-      DataOutputAssociation.isValidSourceNode(sourceNode);
+    const dataStoreValidSources = [
+      'bpmn:Task',
+      'bpmn:SubProcess',
+      'bpmn:CallActivity',
+      'bpmn:ManualTask',
+      'bpmn:ScriptTask',
+      'bpmn:ServiceTask',
+    ];
+    const dataStoreValidTargets = [
+      'bpmn:Task',
+      'bpmn:SubProcess',
+      'bpmn:CallActivity',
+      'bpmn:ManualTask',
+      'bpmn:ScriptTask',
+      'bpmn:ServiceTask',
+    ];
+    const dataObjectValidSources = [
+      'bpmn:Task',
+      'bpmn:SubProcess',
+      'bpmn:CallActivity',
+      'bpmn:ManualTask',
+      'bpmn:ScriptTask',
+      'bpmn:ServiceTask',
+      'bpmn:IntermediateCatchEvent',
+      'bpmn:StartEvent',
+    ];
+    const dataObjectValidTargets = [
+      'bpmn:Task',
+      'bpmn:SubProcess',
+      'bpmn:CallActivity',
+      'bpmn:ManualTask',
+      'bpmn:ScriptTask',
+      'bpmn:ServiceTask',
+      'bpmn:IntermediateThrowEvent',
+      'bpmn:EndEvent',
+    ];
+
+    const sourceType = sourceNode.definition.$type;
+    const targetType = targetNode.definition.$type;
+    const sourceIsDataStore = sourceNode.definition.$type === 'bpmn:DataStoreReference';
+    const sourceIsDataObject = sourceNode.definition.$type === 'bpmn:DataObjectReference';
+    const targetIsDataStore = targetNode.definition.$type === 'bpmn:DataStoreReference';
+    const targetIsDataObject = targetNode.definition.$type === 'bpmn:DataObjectReference';
+    
+    if (sourceIsDataStore && dataStoreValidTargets.includes(targetType)) {
+      return true;
+    }
+    if (sourceIsDataObject && dataObjectValidTargets.includes(targetType)) {
+      return true;
+    }
+    if (targetIsDataStore && dataStoreValidSources.includes(sourceType)) {
+      return true;
+    }
+    return (targetIsDataObject && dataObjectValidSources.includes(sourceType));
   }
 
   makeFlowNode(sourceShape, targetShape, genericLink) {

package/src/components/nodes/genericFlow/genericFlow.vue

@@ -86,23 +86,6 @@ export default {
     },
   },
   watch: {
-    'node.definition': {
-      handler() {
-        const newNameLabel = this.shapeName;
-
-        if (newNameLabel !== this.nameLabel) {
-          this.nameLabel = newNameLabel;
-        }
-        this.setDefaultMarker(this.isDefaultFlow());
-      },
-      deep: true,
-    },
-    'node.definition.sourceRef': {
-      handler() {
-        this.setDefaultMarker(this.isDefaultFlow());
-      },
-      deep: true,
-    },
   },
   methods: {
     completeLink() {

package/src/components/nodes/node.js

@@ -10,7 +10,7 @@ import cloneDeep from 'lodash/cloneDeep';
 
 export default class Node {
   static diagramPropertiesToCopy = ['x', 'y', 'width', 'height'];
-  static definitionPropertiesToNotCopy = ['$type', 'id'];
+  static definitionPropertiesToNotCopy = ['$type', 'id', 'dataOutputAssociations'];
   static flowDefinitionPropertiesToNotCopy = ['$type', 'id', 'sourceRef', 'targetRef'];
   static eventDefinitionPropertiesToNotCopy = ['errorRef', 'messageRef'];
 
@@ -81,6 +81,70 @@ export default class Node {
       this.diagram.id = diagramId;
       this.diagram.bpmnElement = this.definition;
     }
+    if (this.definition.loopCharacteristics && this.definition.loopCharacteristics.$type === 'bpmn:StandardLoopCharacteristics') {
+      this.definition.loopCharacteristics.set('id', nodeIdGenerator.generate()[0]);
+      if (this.definition.loopCharacteristics.loopCondition) {
+        this.definition.loopCharacteristics.get('loopCondition').set('id', nodeIdGenerator.generate()[0]);
+      }
+    }
+    let dataInputRef, dataOutputRef;
+    if (this.definition.ioSpecification) {
+      this.definition.ioSpecification.set('id', nodeIdGenerator.generate()[0]);
+      const taskId = this.definition.id;
+      if (this.definition.ioSpecification.get('dataInputs')) {
+        this.definition.ioSpecification.get('dataInputs').forEach(dataInput => {
+          const id = dataInput.get('id');
+          if (id.substring(0, this.cloneOf.length) === this.cloneOf) {
+            dataInput.set('id', id.replace(this.cloneOf + '_', taskId + '_'));
+            dataInputRef = dataInput;
+          } else {
+            dataInput.set('id', nodeIdGenerator.generate()[0]);
+          }
+        });
+      }
+      if (this.definition.ioSpecification.get('dataOutputs')) {
+        this.definition.ioSpecification.get('dataOutputs').forEach(dataOutput => {
+          const id = dataOutput.get('id');
+          if (id.substring(0, this.cloneOf.length) === this.cloneOf) {
+            dataOutput.set('id', id.replace(this.cloneOf + '_', taskId + '_'));
+            dataOutputRef = dataOutput;
+          } else {
+            dataOutput.set('id', nodeIdGenerator.generate()[0]);
+          }
+        });
+      }
+      if (this.definition.ioSpecification.get('inputSets')) {
+        this.definition.ioSpecification.get('inputSets').forEach(inputSet => {
+          inputSet.set('id', nodeIdGenerator.generate()[0]);
+        });
+      }
+      if (this.definition.ioSpecification.get('outputSets')) {
+        this.definition.ioSpecification.get('outputSets').forEach(outputSet => {
+          outputSet.set('id', nodeIdGenerator.generate()[0]);
+        });
+      }
+    }
+    if (this.definition.loopCharacteristics && this.definition.loopCharacteristics.$type === 'bpmn:MultiInstanceLoopCharacteristics') {
+      this.definition.loopCharacteristics.set('id', nodeIdGenerator.generate()[0]);
+      if (this.definition.loopCharacteristics.loopCardinality) {
+        this.definition.loopCharacteristics.get('loopCardinality').set('id', nodeIdGenerator.generate()[0]);
+      }
+      if (this.definition.loopCharacteristics.loopDataInputRef && dataInputRef) {
+        this.definition.loopCharacteristics.set('loopDataInputRef', dataInputRef);
+      }
+      if (this.definition.loopCharacteristics.loopDataOutputRef && dataOutputRef) {
+        this.definition.loopCharacteristics.set('loopDataOutputRef', dataOutputRef);
+      }
+      if (this.definition.loopCharacteristics.inputDataItem) {
+        this.definition.loopCharacteristics.get('inputDataItem').set('id', nodeIdGenerator.generate()[0]);
+      }
+      if (this.definition.loopCharacteristics.outputDataItem) {
+        this.definition.loopCharacteristics.get('outputDataItem').set('id', nodeIdGenerator.generate()[0]);
+      }
+      if (this.definition.loopCharacteristics.completionCondition) {
+        this.definition.loopCharacteristics.get('completionCondition').set('id', nodeIdGenerator.generate()[0]);
+      }
+    }
   }
 
   clone(nodeRegistry, moddle, $t) {
@@ -90,7 +154,7 @@ export default class Node {
 
     clonedNode.id = null;
     clonedNode.pool = this.pool;
-    clonedNode.definition.cloneOf = this.id;
+    clonedNode.cloneOf = this.id;
 
     Node.diagramPropertiesToCopy.forEach(prop => clonedNode.diagram.bounds[prop] = this.diagram.bounds[prop]);
     Object.keys(this.definition).filter(key => !Node.definitionPropertiesToNotCopy.includes(key)).forEach(key => {
@@ -99,7 +163,7 @@ export default class Node {
       if (key === 'eventDefinitions') {
         for (var i in clonedDefinition) {
           if (definition[i].signalRef && !clonedDefinition[i].signalRef) {
-            clonedDefinition[i].signalRef = { ...definition[i].signalRef };
+            clonedDefinition[i].set('signalRef', { ...definition[i].signalRef });
           }
         }
       }
@@ -122,7 +186,7 @@ export default class Node {
 
     clonedFlow.id = null;
     clonedFlow.pool = this.pool;
-    clonedFlow.definition.cloneOf = this.id;
+    clonedFlow.cloneOf = this.id;
     clonedFlow.diagram.waypoint = [];
 
     this.diagram.waypoint.forEach(point => clonedFlow.diagram.waypoint.push(point));
@@ -133,12 +197,13 @@ export default class Node {
       if (key === 'eventDefinitions') {
         for (var i in clonedDefinition) {
           if (definition[i].signalRef && !clonedDefinition[i].signalRef) {
-            clonedDefinition[i].signalRef = { ...definition[i].signalRef };
+            clonedDefinition[i].set('signalRef', { ...definition[i].signalRef });
           }
         }
       }
       clonedFlow.definition.set(key, clonedDefinition);
-      clonedFlow.definition.sourceRef = clonedFlow.definition.targetRef  = null;
+      clonedFlow.definition.set('sourceRef', null);
+      clonedFlow.definition.set('targetRef', null);
     });
 
     Node.eventDefinitionPropertiesToNotCopy.forEach(

package/src/mixins/cloneSelection.js

@@ -0,0 +1,145 @@
+import { id as laneId } from '../components/nodes/poolLane/config';
+import { id as sequenceFlowId } from '../components/nodes/sequenceFlow';
+import { id as associationId } from '../components/nodes/association';
+import { id as messageFlowId } from '../components/nodes/messageFlow/config';
+import { id as dataOutputAssociationFlowId } from '../components/nodes/dataOutputAssociation/config';
+import { id as dataInputAssociationFlowId } from '../components/nodes/dataInputAssociation/config';
+import { id as genericFlowId } from '../components/nodes/genericFlow/config';
+import { getOrFindDataInput, findIOSpecificationOwner } from '../components/crown/utils';
+
+export default {
+  methods: {
+    cloneSelection() {
+      let clonedNodes = [], clonedFlows = [], clonedDataInputAssociations = [], clonedDataOutputAssociations = [];
+      const nodes = this.highlightedNodes;
+      const selector = this.$refs.selector.$el;
+      const flowNodeTypes = [
+        sequenceFlowId,
+        laneId,
+        associationId,
+        messageFlowId,
+        genericFlowId,
+      ];
+      const dataInputAssociationNodeTypes = [
+        dataInputAssociationFlowId,
+      ];
+      const dataOutputAssociationNodeTypes = [
+        dataOutputAssociationFlowId,
+      ];
+
+      if (typeof selector.getBoundingClientRect === 'function') {
+        nodes.forEach(node => {
+          if (flowNodeTypes.includes(node.type)) {
+            const clonedFlow = this.cloneFlowAndSetNewId(node);
+            clonedFlows.push(clonedFlow);
+            clonedNodes.push(clonedFlow);
+          } else if (dataInputAssociationNodeTypes.includes(node.type)) {
+            const clonedFlow = this.cloneFlowAndSetNewId(node);
+            clonedDataInputAssociations.push(clonedFlow);
+            clonedNodes.push(clonedFlow);
+          } else if (dataOutputAssociationNodeTypes.includes(node.type)) {
+            const clonedFlow = this.cloneFlowAndSetNewId(node);
+            clonedDataOutputAssociations.push(clonedFlow);
+            clonedNodes.push(clonedFlow);
+          } else {
+            const clonedElement = this.cloneElementAndCalculateOffset(node);
+            clonedNodes.push(clonedElement);
+          }
+        });
+      }
+
+      this.connectClonedFlows(clonedFlows, clonedNodes);
+      this.connectClonedDataInputAssociations(clonedDataInputAssociations, clonedNodes);
+      this.connectClonedDataOutputAssociations(clonedDataOutputAssociations, clonedNodes);
+
+      return clonedNodes;
+    },
+    // Returns the Flow Element (Task| DataStore| DataObject)  that is the target of the association
+    getDataInputOutputAssociationTargetRef(association) {
+      if (association.targetRef.$type === 'bpmn:DataInput') {
+        const ioSpec = association.targetRef.$parent;
+        return findIOSpecificationOwner(ioSpec, this);
+      }
+      if (association.targetRef.$type === 'bpmn:DataInputAssociation') {
+        const ioSpec = association.targetRef.$parent;
+        return findIOSpecificationOwner(ioSpec, this);
+      }
+      return association.targetRef;
+    },
+    cloneFlowAndSetNewId(node) {
+      const clonedFlow = node.cloneFlow(this.nodeRegistry, this.moddle, this.$t);
+      clonedFlow.setIds(this.nodeIdGenerator);
+      return clonedFlow;
+    },
+    cloneElementAndCalculateOffset(node) {
+      const clonedElement = node.clone(this.nodeRegistry, this.moddle, this.$t);
+      const { height: selectorHeight } = this.$refs.selector.$el.getBoundingClientRect();
+      const { sy } = this.paper.scale();
+      const yOffset = selectorHeight / sy;
+      clonedElement.diagram.bounds.y += yOffset;
+      clonedElement.setIds(this.nodeIdGenerator);
+      return clonedElement;
+    },
+    connectClonedFlows(clonedFlows, clonedNodes) {
+      clonedFlows.forEach(clonedFlow => {
+        const originalFlow = this.nodes.find(node => node.definition.id === clonedFlow.cloneOf);
+        const src = originalFlow.definition.sourceRef;
+        const target = originalFlow.definition.targetRef;
+        const srcClone = clonedNodes.find(node => node.cloneOf === src.id);
+        const targetClone = clonedNodes.find(node => node.cloneOf === target.id);
+        if (!srcClone || !targetClone) {
+          clonedNodes.splice(clonedNodes.indexOf(clonedFlow), 1);
+          return;
+        }
+        clonedFlow.definition.set('sourceRef', srcClone.definition);
+        clonedFlow.definition.set('targetRef', targetClone.definition);
+
+        if (srcClone.definition.outgoing) {
+          srcClone.definition.outgoing.push(clonedFlow.definition);
+        } else {
+          srcClone.definition.set('outgoing', [clonedFlow.definition]);
+        }
+
+        if (targetClone.definition.incoming) {
+          targetClone.definition.incoming.push(clonedFlow.definition);
+        } else {
+          targetClone.definition.set('incoming', [clonedFlow.definition]);
+        }
+
+        clonedFlow.diagram.waypoint.forEach(point => {
+          const { height: selectorHeight } = this.$refs.selector.$el.getBoundingClientRect();
+          point.y += selectorHeight;
+        });
+      });
+    },
+    connectClonedDataInputAssociations(clonedDataInputAssociations, clonedNodes) {
+      clonedDataInputAssociations.forEach(clonedAssociation => {
+        const originalAssociation = this.nodes.find(node => node.definition.id === clonedAssociation.cloneOf);
+        const src = originalAssociation.definition.sourceRef[0];
+        const srcClone = clonedNodes.find(node => node.cloneOf === src.id);
+        const originalTargetElement = this.getDataInputOutputAssociationTargetRef(originalAssociation.definition);
+        const clonedElement = clonedNodes.find(node => node.cloneOf === originalTargetElement.id);
+        const clonedDataInput = getOrFindDataInput(this.moddle, clonedElement, srcClone.definition);
+
+        clonedAssociation.definition.set('sourceRef', [srcClone.definition]);
+        clonedAssociation.definition.set('targetRef', clonedDataInput);
+        clonedElement.definition.set('dataInputAssociations', [clonedAssociation.definition]);
+      });
+    },
+    connectClonedDataOutputAssociations(clonedDataOutputAssociations, clonedNodes) {
+      clonedDataOutputAssociations.forEach(clonedAssociation => {
+        const originalAssociation = this.nodes.find(node => node.definition.id === clonedAssociation.cloneOf);
+        const src = originalAssociation.definition.sourceRef || originalAssociation.definition.$parent;
+        const target = originalAssociation.definition.targetRef;
+        const srcClone = clonedNodes.find(node => node.cloneOf === src.id);
+        const targetClone = clonedNodes.find(node => node.cloneOf === target.id);
+
+        clonedAssociation.definition.set('targetRef', targetClone.definition);
+        clonedAssociation.definition.set('sourceRef', srcClone.definition);
+
+        const existingOutputAssociations = srcClone.definition.get('dataOutputAssociations') || [];
+        srcClone.definition.set('dataOutputAssociations', [...existingOutputAssociations, clonedAssociation.definition]);
+      });
+    },
+  },
+};

package/src/mixins/linkConfig.js

@@ -78,7 +78,7 @@ export default {
       });
     },
     setEndpoint(shape, endpoint, connectionOffset) {
-      if (isPoint(shape)) {
+      if (shape && isPoint(shape)) {
         return this.shape[endpoint](shape, {
           anchor: {
             name: 'modelCenter',
@@ -253,6 +253,9 @@ export default {
       ? this.getTargetRef()
       : this.node.definition.get('targetRef');
 
+    // if flow doesn't have a targetRef such as incomplete node, return
+    if (!targetRef) return;
+
     if (targetRef.id) {
       const targetShape = this.graph.getElements().find(element => {
         return element.component && element.component.node.definition === targetRef;

package/src/store.js

@@ -36,8 +36,7 @@ export default new Vuex.Store({
     globalProcesses: [],
     allowSavingElementPosition: true,
     copiedElements: [],
-    clientX: null,
-    clientY: null,
+    clientLeftPaper: false,
   },
   getters: {
     nodes: state => state.nodes,
@@ -56,8 +55,7 @@ export default new Vuex.Store({
     globalProcessEvents: (state, getters) => flatten(getters.globalProcesses.map(process => process.events)),
     allowSavingElementPosition: state => state.allowSavingElementPosition,
     copiedElements: state => state.copiedElements,
-    clientX: state => state.clientX,
-    clientY: state => state.clientY,
+    clientLeftPaper: state => state.clientLeftPaper,
   },
   mutations: {
     preventSavingElementPosition(state) {
@@ -148,13 +146,8 @@ export default new Vuex.Store({
     setCopiedElements(state, elements) {
       state.copiedElements = elements;
     },
-    setClientMousePosition(state, position) {
-      const { clientX, clientY } = position;
-      state = { clientX, clientY };
-    },
-    clientLeftPaper(state) {
-      state.clientX = null;
-      state.clientY = null;
+    setClientLeftPaper(state, status) {
+      state.clientLeftPaper = status;
     },
   },
   actions: {