@processmaker/modeler 1.27.0 → 1.29.0

package/src/components/modeler/Modeler.vue

@@ -11,6 +11,7 @@
       @toggle-panels-compressed="panelsCompressed = !panelsCompressed"
       @toggle-mini-map-open="miniMapOpen = $event"
       @saveBpmn="saveBpmn"
+      @publishTemplate="publishTemplate"
       @close="close"
       @save-state="pushToUndoStack"
       @clearSelection="clearSelection"
@@ -63,7 +64,7 @@
         :parent-height="parentHeight"
         :canvas-drag-position="canvasDragPosition"
         :compressed="panelsCompressed && noElementsSelected"
-        @shape-resize="shapeResize"
+        @shape-resize="shapeResize(false)"
       />
 
       <component
@@ -105,8 +106,8 @@
         @copy-element="copyElement"
         @copy-selection="copyElement"
         @paste-element="pasteElements"
-        @duplicate-element="duplicateElement"
-        @duplicate-selection="duplicateSelection"
+        @clone-element="cloneElement"
+        @clone-selection="cloneSelection"
         @default-flow="toggleDefaultFlow"
         @shape-resize="shapeResize"
       />
@@ -116,7 +117,7 @@
         :graph="graph"
         :paperManager="paperManager"
         :useModelGeometry="false"
-        @duplicate-selection="duplicateSelection"
+        @clone-selection="cloneSelection"
         @remove-nodes="removeNodes"
         :processNode="processNode"
         @save-state="pushToUndoStack"
@@ -139,12 +140,13 @@ import InspectorPanel from '@/components/inspectors/InspectorPanel';
 import undoRedoStore from '@/undoRedoStore';
 import { Linter } from 'bpmnlint';
 import linterConfig from '../../../.bpmnlintrc';
-import NodeIdGenerator from '../../NodeIdGenerator';
+import { getNodeIdGenerator } from '../../NodeIdGenerator';
 import Process from '../inspectors/process';
 import runningInCypressTest from '@/runningInCypressTest';
 import getValidationProperties from '@/targetValidationUtils';
 import MiniPaper from '@/components/miniPaper/MiniPaper';
 import { id as laneId } from '@/components/nodes/poolLane/config';
+import { id as processId } from '@/components/inspectors/process';
 import { id as sequenceFlowId } from '../nodes/sequenceFlow';
 import { id as associationId } from '../nodes/association';
 import { id as messageFlowId } from '../nodes/messageFlow/config';
@@ -167,6 +169,7 @@ import { removeNodeFlows, removeNodeMessageFlows, removeNodeAssociations, remove
 import { getInvalidNodes } from '@/components/modeler/modelerUtils';
 import { NodeMigrator } from '@/components/modeler/NodeMigrator';
 import addLoopCharacteristics from '@/setup/addLoopCharacteristics';
+import cloneSelection from '../../mixins/cloneSelection';
 
 import ProcessmakerModelerGenericFlow from '@/components/nodes/genericFlow/genericFlow';
 
@@ -190,9 +193,11 @@ export default {
       },
     },
   },
-  mixins: [hotkeys],
+  mixins: [hotkeys, cloneSelection],
   data() {
     return {
+      pasteInProgress: false,
+      cloneInProgress: false,
       internalClipboard: [],
       tooltipTarget: null,
 
@@ -303,10 +308,10 @@ export default {
     isAppleOS() {
       return typeof navigator !== 'undefined' && /Mac|iPad|iPhone/.test(navigator.platform);
     },
-    async shapeResize() {
+    async shapeResize(clearIfEmpty=true) {
       await this.$nextTick();
       await this.paperManager.awaitScheduledUpdates();
-      this.$refs.selector.updateSelectionBox(true);
+      this.$refs.selector.updateSelectionBox(true, clearIfEmpty);
     },
     toggleDefaultFlow(flow) {
       const source = flow.definition.sourceRef;
@@ -315,7 +320,7 @@ export default {
       }
       source.set('default', flow);
     },
-    duplicateElement(node, copyCount) {
+    cloneElement(node, copyCount) {
       const clonedNode = node.clone(this.nodeRegistry, this.moddle, this.$t);
       const yOffset = (node.diagram.bounds.height + 30) * copyCount;
 
@@ -329,90 +334,61 @@ export default {
         dataOutputAssociationFlowId,
         dataInputAssociationFlowId,
         genericFlowId,
+        processId,
       ];
       if (this.highlightedNodes.length === 1 && flows.includes(this.highlightedNodes[0].type)) return;
-      store.commit('setCopiedElements', this.cloneSelection());
+      store.commit('setCopiedElements', this.cloneNodesSelection());
       this.$bvToast.toast(this.$t('Object(s) have been copied'), { noCloseButton:true, variant: 'success', solid: true, toaster: 'b-toaster-top-center' });
     },
+    publishTemplate() {
+      this.$emit('publishTemplate');
+    },
     async pasteElements() {
-      if (this.copiedElements) {
-        await this.addClonedNodes(this.copiedElements);
-        this.$refs.selector.selectElements(this.findViewElementsFromNodes(this.copiedElements));
-        store.commit('setCopiedElements', this.cloneSelection());
+      if (this.copiedElements.length > 0 && !this.pasteInProgress) {
+        this.pasteInProgress = true;
+        try {
+          await this.addClonedNodes(this.copiedElements);
+          await this.$nextTick();
+          await this.paperManager.awaitScheduledUpdates();
+          await this.$refs.selector.selectElements(this.findViewElementsFromNodes(this.copiedElements), true);
+          await this.$nextTick();
+          await store.commit('setCopiedElements', this.cloneNodesSelection());
+          this.scrollToSelection();
+        } finally {
+          this.pasteInProgress = false;
+          await this.pushToUndoStack();
+        }
       }
     },
-    cloneSelection() {
-      let clonedNodes = [], clonedFlows = [], originalFlows = [];
-      const nodes = this.highlightedNodes;
-      const selector = this.$refs.selector.$el;
-      const { height: sheight } = selector.getBoundingClientRect();
-      if (typeof selector.getBoundingClientRect === 'function') {
-        // get selector height
-        nodes.forEach(node => {
-          // Add flows described in the definitions property
-          if (node.definition.incoming || node.definition.outgoing) {
-            // Since both incoming and outgoing reference the same flow, any of them is copied
-            let flowsToCopy = [...(node.definition.incoming || node.definition.outgoing)];
-            // Check if flow is already in array before pushing
-            flowsToCopy.forEach(flow => {
-              if (!originalFlows.some(el => el.id === flow.id)) {
-                originalFlows.push(flow);
-              }
-            });
-          }
-
-          // Check node type to clone
-          if ([
-            sequenceFlowId,
-            laneId,
-            associationId,
-            messageFlowId,
-            dataOutputAssociationFlowId,
-            dataInputAssociationFlowId,
-            genericFlowId,
-          ].includes(node.type)) {
-            // Add offset for all waypoints on cloned flow
-            const clonedFlow = node.cloneFlow(this.nodeRegistry, this.moddle, this.$t);
-            clonedFlow.setIds(this.nodeIdGenerator);
-            clonedFlows.push(clonedFlow);
-            clonedNodes.push(clonedFlow);
-          } else {
-            // Clone node and calculate offset
-            const clonedNode = node.clone(this.nodeRegistry, this.moddle, this.$t);
-            const yOffset = sheight;
-            clonedNode.diagram.bounds.y += yOffset;
-            // Set cloned node id
-            clonedNode.setIds(this.nodeIdGenerator);
-            clonedNodes.push(clonedNode);
-          }
-        });
+    async cloneSelection() {
+      const clonedNodes = this.cloneNodesSelection();
+      if (clonedNodes && clonedNodes.length === 0) {
+        return;
+      }
+      try {
+        this.cloneInProgress = true;
+        this.$refs.selector.clearSelection();
+        await this.addClonedNodes(clonedNodes);
+        await this.$nextTick();
+        await this.paperManager.awaitScheduledUpdates();
+        await this.$refs.selector.selectElements(this.findViewElementsFromNodes(clonedNodes));
+        this.scrollToSelection();
+      } finally {
+        this.cloneInProgress = false;
+        await this.pushToUndoStack();
       }
-      // Connect flows
-      clonedFlows.forEach(flow => {
-        // Look up the original flow
-        const flowClonedFrom = { definition: originalFlows.find(el => el.id === flow.definition.cloneOf) };
-        // Get the id's of the sourceRef and targetRef of original flow
-        const src = flowClonedFrom.definition.sourceRef;
-        const target = flowClonedFrom.definition.targetRef;
-        const srcClone = clonedNodes.find(node => node.definition.cloneOf === src.id);
-        const targetClone = clonedNodes.find(node => node.definition.cloneOf === target.id);
-        // Reference the elements to the flow that connects them
-        flow.definition.sourceRef = srcClone.definition;
-        flow.definition.targetRef = targetClone.definition;
-        // Reference the flow to the elements that are connected by it
-        srcClone.definition.outgoing ? srcClone.definition.outgoing.push(flow.definition) : srcClone.definition.outgoing = [flow.definition];
-        targetClone.definition.incoming ? targetClone.definition.incoming.push(flow.definition) : targetClone.definition.incoming = [flow.definition];
-        // Translate flow waypoints to where they should be
-        flow.diagram.waypoint.forEach(point => {
-          point.y += sheight;
-        });
-      });
-      return clonedNodes;
     },
-    async duplicateSelection() {
-      const clonedNodes = this.cloneSelection();
-      await this.addClonedNodes(clonedNodes);
-      this.$refs.selector.selectElements(this.findViewElementsFromNodes(clonedNodes));
+    scrollToSelection() {
+      const containerRect = this.$refs['paper-container'].getBoundingClientRect();
+      const selector = this.$refs.selector;
+      const selectorRect = selector.$el.getBoundingClientRect();
+      // Scroll to the cloned elements only when they are not visible on the screen.
+      if (selectorRect.right > containerRect.right || selectorRect.bottom > containerRect.bottom || selectorRect.left < containerRect.left || selectorRect.top < containerRect.top) {
+        const currentPosition = this.paper.translate();
+        const newTy = currentPosition.ty - (selectorRect.top - containerRect.top - selectorRect.height);
+        this.paper.translate(currentPosition.tx, newTy);
+        selector.updateSelectionBox(true);
+      }
     },
     findViewElementsFromNodes(nodes) {
       return nodes.map(node => {
@@ -476,9 +452,12 @@ export default {
       }
     },
     async pushToUndoStack() {
+      if (this.pasteInProgress || this.cloneInProgress) {
+        return;
+      }
       try {
         const xml = await this.getXmlFromDiagram();
-        undoRedoStore.dispatch('pushState', xml);
+        await undoRedoStore.dispatch('pushState', xml);
         window.ProcessMaker.EventBus.$emit('modeler-change');
       } catch (invalidXml) {
         // eslint-disable-next-line no-console
@@ -829,12 +808,20 @@ export default {
       this.isRendering = false;
       this.$emit('parsed');
     },
-    async loadXML(xml = this.currentXML) {
+    async loadXML(xml = null) {
+      let emitChangeEvent = false;
+      if (xml === null) {
+        xml = this.currentXML;
+        emitChangeEvent = true;
+      }
       this.definitions = await this.xmlManager.getDefinitionsFromXml(xml);
       this.xmlManager.definitions = this.definitions;
-      this.nodeIdGenerator = new NodeIdGenerator(this.definitions);
+      this.nodeIdGenerator = getNodeIdGenerator(this.definitions);
       store.commit('clearNodes');
-      this.renderPaper();
+      await this.renderPaper();
+      if (emitChangeEvent) {
+        window.ProcessMaker.EventBus.$emit('modeler-change');
+      }
     },
     getBoundaryEvents(process) {
       return process.get('flowElements').filter(({ $type }) => $type === 'bpmn:BoundaryEvent');
@@ -970,11 +957,14 @@ export default {
         store.commit('addNode', node);
         this.poolTarget = null;
       });
-
-      await this.pushToUndoStack();
     },
     async removeNode(node, { removeRelationships = true } = {}) {
+      if (!node) {
+        // already removed
+        return;
+      }
       if (removeRelationships) {
+
         removeNodeFlows(node, this);
         removeNodeMessageFlows(node, this);
         removeNodeAssociations(node, this);
@@ -989,10 +979,10 @@ export default {
       store.commit('highlightNode', this.processNode);
       this.$refs.selector.clearSelection();
       await this.$nextTick();
-      this.pushToUndoStack();
+      await this.pushToUndoStack();
     },
     async removeNodes() {
-      this.performSingleUndoRedoTransaction(async() => {
+      await this.performSingleUndoRedoTransaction(async() => {
         await this.paperManager.performAtomicAction(async() => {
           const waitPromises = [];
           this.highlightedNodes.forEach((node) =>
@@ -1035,7 +1025,7 @@ export default {
       undoRedoStore.commit('disableSavingState');
       await cb();
       undoRedoStore.commit('enableSavingState');
-      this.pushToUndoStack();
+      await this.pushToUndoStack();
     },
     removeNodesFromLane(node) {
       const containingLane = node.pool && node.pool.component.laneSet &&
@@ -1274,14 +1264,17 @@ export default {
       this.pointerUpHandler(event, cellView);
     }, this);
 
+    this.$el.addEventListener('mouseenter', () => {
+      store.commit('setClientLeftPaper', false);
+    });
+
     this.$el.addEventListener('mousemove', event => {
-      const { clientX, clientY } = event;
       this.pointerMoveHandler(event);
-      store.commit('setClientMousePosition', { clientX, clientY });
     });
 
     this.$el.addEventListener('mouseleave', () => {
-      store.commit('clientLeftPaper');
+      this.paperManager.removeEventHandler('blank:pointermove');
+      store.commit('setClientLeftPaper', true);
     });
 
     this.paperManager.addEventHandler('cell:pointerclick', (cellView, evt, x, y) => {
@@ -1311,9 +1304,9 @@ export default {
 
     /* Register custom nodes */
     window.ProcessMaker.EventBus.$emit('modeler-start', {
-      loadXML: xml => {
-        this.loadXML(xml);
-        undoRedoStore.dispatch('pushState', xml);
+      loadXML: async(xml) => {
+        await this.loadXML(xml);
+        await undoRedoStore.dispatch('pushState', xml);
       },
       addWarnings: warnings => this.$emit('warnings', warnings),
       addBreadcrumbs: breadcrumbs => this.breadcrumbData.push(breadcrumbs),

package/src/components/modeler/Selection.vue

@@ -16,6 +16,7 @@
       :plane-elements="$parent.planeElements"
       :is-rendering="$parent.isRendering"
       :dropdown-data="[]"
+      :has-pools="hasPoolsOrLanesSelected"
       v-on="$listeners"
     />
   </div>
@@ -28,14 +29,13 @@ import CrownMultiselect from '@/components/crown/crownMultiselect/crownMultisele
 import { id as poolId } from '@/components/nodes/pool/config';
 import { id as laneId } from '@/components/nodes/poolLane/config';
 import { id as genericFlowId } from '@/components/nodes/genericFlow/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 { labelWidth, poolPadding } from '../nodes/pool/poolSizes';
-const boundaryElements = [
-  'processmaker-modeler-boundary-timer-event',
-  'processmaker-modeler-boundary-error-event',
-  'processmaker-modeler-boundary-signal-event',
-  'processmaker-modeler-boundary-conditional-event',
-  'processmaker-modeler-boundary-message-event',
-];
+
 export default {
   name: 'Selection',
   components: {
@@ -85,6 +85,14 @@ export default {
     this.paperManager.paper.on('scale:changed ', this.updateSelectionBox);
     this.paperManager.paper.on('translate:changed ', this.translateChanged);
   },
+  computed: {
+    hasPoolsOrLanesSelected() {
+      return this.selected.some((view) => {
+        return view.model.component.node.type === poolId ||
+        view.model.component.node.type === laneId;
+      });
+    },
+  },
   watch: {
     // whenever selected changes
     selected(newSelected) {
@@ -318,7 +326,7 @@ export default {
     /**
      * Update the selection Box
      */
-    updateSelectionBox(force=false) {
+    updateSelectionBox(force=false, clearIfEmpty=true) {
       if (force || this.isSelecting && this.style) {
         if (this.selected.length > 0) {
           const box = this.getSelectionVertex(this.selected, false, true);
@@ -330,7 +338,7 @@ export default {
           // Set the dimensions of the element
           this.style.width = `${box.maxX - box.minX}px`;
           this.style.height = `${box.maxY - box.minY}px`;
-        } else {
+        } else if (clearIfEmpty) {
           this.clearSelection();
         }
       }
@@ -339,6 +347,13 @@ export default {
      * Filter the selected elements
      */
     filterSelected() {
+      const flowTypes = [
+        sequenceFlowId,
+        dataOutputAssociationFlowId,
+        dataInputAssociationFlowId,
+        associationId,
+        messageFlowId,
+      ];
       // Get the selected pools IDs
       const selectedPoolsIds = this.selected
         .filter(shape => shape.model.component)
@@ -349,26 +364,15 @@ export default {
         if (shape.model.component && shape.model.component.node.pool) {
           return shape.model.component.node.pool && !selectedPoolsIds.includes(shape.model.component.node.pool.component.node.id);
         }
+        // remove from selection the selected flows that belongs to a selected pools
+        if (shape.model.component  && flowTypes.includes(shape.model.component.node.type)) {
+          const parent = shape.model.getParentCell();
+          if (parent.component && parent.component.node.pool) {
+            return !selectedPoolsIds.includes(parent.component.node.pool.component.node.id);
+          }
+        }
         return true;
       });
-      // A boundary event could only be selected alone
-      const firstSelectedBoundary = this.selected.find(shape => {
-        return shape.model.component &&
-          boundaryElements.includes(shape.model.component.node.type);
-      });
-      const firstSelectedElement = this.selected[0];
-      if (firstSelectedBoundary) {
-        this.selected = this.selected.filter(shape => {
-          if (firstSelectedElement === firstSelectedBoundary) {
-            // boundary event selected alone
-            return shape.model.component &&
-              shape === firstSelectedBoundary;
-          }
-          // do not allow to select a boundary event with another element
-          return shape.model.component &&
-            !boundaryElements.includes(shape.model.component.node.type);
-        });
-      }
     },
     /**
      * Pan paper handler
@@ -475,6 +479,9 @@ export default {
       this.$emit('save-state');
       this.dragging = false;
       this.stopForceMove = false;
+      // Readjusts the selection box, taking into consideration elements
+      // that are anchored and did not move, such as boundary events. 
+      this.updateSelectionBox();
     },
     /**
      * Translate the Selected shapes adding some custom validations
@@ -636,7 +643,7 @@ export default {
     /**
      * Rollback drag an element outside it's pool parent
      */
-    rollbackSelection(){
+    async rollbackSelection(){
       const deltaX = this.initialPosition.left  - this.left;
       const deltaY = this.initialPosition.top - this.top;
       this.style.left = `${this.initialPosition.left}px`;
@@ -645,14 +652,18 @@ export default {
       const shapesToNotTranslate = [
         'PoolLane',
         'standard.Link',
+        'processmaker.components.nodes.boundaryEvent.Shape',
       ];
       this.selected.filter(shape => !shapesToNotTranslate.includes(shape.model.get('type')))
         .forEach(shape => {
           shape.model.translate(deltaX/scale.sx, deltaY/scale.sy);
         });
       this.isOutOfThePool = false;
-      store.commit('allowSavingElementPosition');
+      await store.commit('allowSavingElementPosition');
       this.paperManager.setStateValid();
+      await this.$nextTick();
+      await this.paperManager.awaitScheduledUpdates();
+      this.updateSelectionBox(true);
     },
     /**
      * Expand and fit the pool container

package/src/components/nodes/association/index.js

@@ -14,6 +14,9 @@ export default {
       associationDirection: `${direction.none}`,
     });
   },
+  diagram(moddle) {
+    return moddle.create('bpmndi:BPMNEdge');
+  },
   inspectorConfig: [
     {
       name: 'Data Association',

package/src/components/nodes/dataInputAssociation/dataInputAssociation.vue

@@ -21,7 +21,7 @@ import linkConfig from '@/mixins/linkConfig';
 import get from 'lodash/get';
 import associationHead from '!!url-loader!@/assets/association-head.svg';
 import CrownConfig from '@/components/crown/crownConfig/crownConfig';
-import { getOrFindDataInput, removeDataInput } from '@/components/crown/utils';
+import { getOrFindDataInput, removeDataInput, findIOSpecificationOwner } from '@/components/crown/utils';
 import { pull } from 'lodash';
 
 export default {
@@ -50,20 +50,38 @@ export default {
   },
   computed: {
     isValidConnection() {
-      const targetType = get(this.target, 'component.node.type');
+      const targetType = get(this.target, 'component.node.definition.$type');
 
       if (!targetType) {
         return false;
       }
 
-      /* A data input association can be connected to anything that isn't a data store or object or a start event */
-      const invalidTarget = this.targetNode.isBpmnType('bpmn:DataObjectReference', 'bpmn:DataStoreReference', 'bpmn:StartEvent');
+      const dataStoreValidTargets = [
+        'bpmn:Task',
+        'bpmn:SubProcess',
+        'bpmn:CallActivity',
+        'bpmn:ManualTask',
+        'bpmn:ScriptTask',
+        'bpmn:ServiceTask',
+      ];
+      const dataObjectValidTargets = [
+        'bpmn:Task',
+        'bpmn:SubProcess',
+        'bpmn:CallActivity',
+        'bpmn:ManualTask',
+        'bpmn:ScriptTask',
+        'bpmn:ServiceTask',
+        'bpmn:IntermediateThrowEvent',
+        'bpmn:EndEvent',
+      ];
 
-      if (invalidTarget) {
-        return false;
-      }
+      const sourceIsDataStore = this.sourceNode.definition.$type === 'bpmn:DataStoreReference';
+      const sourceIsDataObject = this.sourceNode.definition.$type === 'bpmn:DataObjectReference';
 
-      return true;
+      if (sourceIsDataStore && dataStoreValidTargets.includes(targetType)) {
+        return true;
+      }
+      return (sourceIsDataObject && dataObjectValidTargets.includes(targetType));
     },
   },
   methods: {
@@ -71,29 +89,16 @@ export default {
       if (this.node.dataAssociationProps) {
         return this.node.dataAssociationProps.sourceShape;
       }
-
-      const taskWithInputAssociation = this.graph.getElements().find(element => {
-        return element.component && element.component.node.definition.get('dataInputAssociations') &&
-            element.component.node.definition.get('dataInputAssociations')[0] === this.node.definition;
-      });
-
-      const dataObjectDefinition = taskWithInputAssociation.component.node.definition.get('dataInputAssociations')[0].sourceRef[0];
-
-      return this.graph.getElements().find(element => {
-        return element.component && element.component.node.definition === dataObjectDefinition;
-      });
+      const source = this.node.definition.sourceRef[0];
+      // find shape
+      const shape = this.graph.getElements().find(e=>e.component.node.definition === source);
+      return shape;
     },
     getTargetRef() {
       if (this.node.dataAssociationProps) {
         return this.node.dataAssociationProps.targetCoords;
       }
-
-      const taskWithInputAssociation = this.graph.getElements().find(element => {
-        return element.component && element.component.node.definition.get('dataInputAssociations') &&
-            element.component.node.definition.get('dataInputAssociations')[0] === this.node.definition;
-      });
-
-      return taskWithInputAssociation.component.node.definition;
+      return findIOSpecificationOwner(this.node.definition.targetRef.$parent, this.$parent);
     },
     updateRouter() {
       this.shape.router('normal', { elementPadding: this.elementPadding });
@@ -102,6 +107,7 @@ export default {
       const targetShape = this.shape.getTargetElement();
       const dataInput = getOrFindDataInput(this.moddle, targetShape.component.node, this.sourceNode.definition);
       this.node.definition.set('targetRef', dataInput);
+      // @todo Review why this needs to be and array. When saving the BPMN, if this is not an array the sourceRef is not stored
       this.node.definition.set('sourceRef', [this.sourceNode.definition]);
       targetShape.component.node.definition.set('dataInputAssociations', [this.node.definition]);
     },
@@ -129,6 +135,10 @@ export default {
     this.shape.component = this;
   },
   destroyed() {
+    // when a association was not completed this.targetNode will be undefined
+    if (!this.targetNode) {
+      return;
+    }
     removeDataInput(this.targetNode, this.sourceNode.definition);
     pull(this.targetNode.definition.get('dataInputAssociations'), this.node.definition);
   },

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) {