@processmaker/modeler 1.18.6 → 1.21.0

package/src/components/crown/utils.js

@@ -99,3 +99,125 @@ export function removeSourceDefault(node) {
     node.definition.sourceRef.set('default', null);
   }
 }
+
+export function getOrFindDataInput(moddle, task, sourceNode) {
+  if (sourceNode.$type !== 'bpmn:DataObjectReference' && sourceNode.$type !== 'bpmn:DataStoreReference') {
+    throw 'Source node must be a DataObjectReference or bpmn:DataStoreReference, got ' + sourceNode.$type;
+  }
+  const sourceNodeId = sourceNode.id;
+  const dataInputId = `data_input_${sourceNodeId}`;
+  // Check if ioSpecification exists
+  if (!task.definition.ioSpecification) {
+    task.definition.ioSpecification = moddle.create('bpmn:InputOutputSpecification', {
+      dataInputs: [],
+      dataOutputs: [],
+      inputSets: [],
+      outputSets: [],
+    });
+  }
+  // Check if dataInput exists
+  if (!task.definition.ioSpecification.dataInputs) {
+    task.definition.ioSpecification.set('dataInputs', []);
+  }
+  let dataInput = task.definition.ioSpecification.dataInputs.find(input => input.id === dataInputId);
+  if (!dataInput) {
+    task.definition.ioSpecification.dataInputs.push(moddle.create('bpmn:DataInput', {
+      id: dataInputId,
+      isCollection: 'false',
+      name: sourceNode.name,
+    }));
+    task.definition.ioSpecification.set('dataInputs', task.definition.ioSpecification.dataInputs);
+  }
+  dataInput = task.definition.ioSpecification.dataInputs.find(input => input.id === dataInputId);
+  // Check if outputSet exists
+  if (!task.definition.ioSpecification.outputSets) {
+    task.definition.ioSpecification.set('outputSets', [
+      moddle.create('bpmn:OutputSet', {
+        dataOutputRefs: [],
+      }),
+    ]);
+  }
+  let outputSet = task.definition.ioSpecification.outputSets[0];
+  if (!outputSet) {
+    task.definition.ioSpecification.set('outputSets', [
+      moddle.create('bpmn:OutputSet', {
+        dataOutputRefs: [],
+      }),
+    ]);
+  }
+  outputSet = task.definition.ioSpecification.outputSets[0];
+  // Check if inputSet exists
+  if (!task.definition.ioSpecification.inputSets) {
+    task.definition.ioSpecification.set('inputSets', [
+      moddle.create('bpmn:InputSet', {
+        dataInputRefs: [],
+      }),
+    ]);
+  }
+  let inputSet = task.definition.ioSpecification.inputSets[0];
+  if (!inputSet) {
+    task.definition.ioSpecification.set('inputSets', [
+      moddle.create('bpmn:InputSet', {
+        dataInputRefs: [],
+      }),
+    ]);
+  }
+  inputSet = task.definition.ioSpecification.inputSets[0];
+  // Check if dataInputRef exists
+  const dataInputRef = inputSet.dataInputRefs.find(ref => ref.id === dataInputId);
+  if (!dataInputRef) {
+    inputSet.dataInputRefs.push(dataInput);
+  }
+  return dataInput;
+}
+
+
+export function removeDataInput(task, sourceNode) {
+  if (sourceNode.$type !== 'bpmn:DataObjectReference' && sourceNode.$type !== 'bpmn:DataStoreReference') {
+    throw 'Source node must be a DataObjectReference or bpmn:DataStoreReference, got ' + sourceNode.$type;
+  }
+  const sourceNodeId = sourceNode.id;
+  const dataInputId = `data_input_${sourceNodeId}`;
+  // Check if ioSpecification exists
+  if (!task.definition.ioSpecification) {
+    return;
+  }
+  // Check if dataInput exists
+  if (!task.definition.ioSpecification.dataInputs) {
+    return;
+  }
+  let dataInput = task.definition.ioSpecification.dataInputs.find(input => input.id === dataInputId);
+  if (!dataInput) {
+    return;
+  }
+  // remove dataInput from dataInputs
+  pull(task.definition.ioSpecification.dataInputs, dataInput);
+  // Check if inputSet exists
+  if (!task.definition.ioSpecification.inputSets) {
+    return;
+  }
+  let inputSet = task.definition.ioSpecification.inputSets[0];
+  if (!inputSet) {
+    return;
+  }
+  // Check if dataInputRef exists
+  const dataInputRef = inputSet.dataInputRefs.find(ref => ref.id === dataInputId);
+  if (dataInputRef) {
+    pull(inputSet.dataInputRefs, dataInputRef);
+  }
+  // Remove inputSets if it is empty (without any dataInputRefs)
+  if (inputSet.dataInputRefs.length === 0) {
+    delete task.definition.ioSpecification.inputSets;
+  }
+  // Remove outputSets if it is empty (without any dataOutputRefs)
+  if (task.definition.ioSpecification.outputSets) {
+    let outputSet = task.definition.ioSpecification.outputSets[0];
+    if (outputSet && (!outputSet.dataOutputRefs || outputSet.dataOutputRefs.length === 0)) {
+      delete task.definition.ioSpecification.outputSets;
+    }
+  }
+  // Remove ioSpecification if it is empty (without outputSets and inputSets)
+  if (!task.definition.ioSpecification.inputSets && !task.definition.ioSpecification.outputSets) {
+    delete task.definition.ioSpecification;
+  }
+}

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

@@ -21,6 +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 { pull } from 'lodash';
 
 export default {
@@ -99,8 +100,9 @@ export default {
     },
     updateDefinitionLinks() {
       const targetShape = this.shape.getTargetElement();
+      const dataInput = getOrFindDataInput(this.moddle, targetShape.component.node, this.sourceNode.definition);
+      this.node.definition.set('targetRef', dataInput);
       this.node.definition.set('sourceRef', [this.sourceNode.definition]);
-      this.node.definition.set('targetRef', null);
       targetShape.component.node.definition.set('dataInputAssociations', [this.node.definition]);
     },
   },
@@ -127,6 +129,7 @@ export default {
     this.shape.component = this;
   },
   destroyed() {
+    removeDataInput(this.targetNode, this.sourceNode.definition);
     pull(this.targetNode.definition.get('dataInputAssociations'), this.node.definition);
   },
 };

package/src/components/nodes/subProcess/SubProcessFormSelect.vue

@@ -12,7 +12,11 @@
       optionContent="name"
       class="p-0 mb-2"
       validation="required"
-      @open="loadProcesses"
+      @search-change="searchChange"
+      :searchable="true"
+      :internal-search="false"
+      :preserve-search="true"
+      :clear-on-select="false"
     />
 
     <form-multi-select
@@ -41,7 +45,6 @@
 </template>
 
 <script>
-import store from '@/store';
 import uniqBy from 'lodash/uniqBy';
 
 export default {
@@ -52,18 +55,31 @@ export default {
       config: {},
       name: '',
       loading: false ,
+      processes: [],
+      selectedProcessInfo: null,
     };
   },
   inheritAttrs: false,
   props: ['value'],
   computed: {
     processList() {
-      return this.filterValidProcesses(store.getters.globalProcesses) || [];
+      const list = this.filterValidProcesses(this.processes) || [];
+      if (this.selectedProcessInfo && !list.find(p => p.id === this.selectedProcessInfo.id)) {
+        list.push(this.selectedProcessInfo);
+      }
+      return list;
     },
     startEventList() {
       if (!this.selectedProcess) { return []; }
       return this.filterValidStartEvents(this.selectedProcess.events);
     },
+    currentProcessId() {
+      const match = window.location.href.match(/modeler\/(\d+)/);
+      if (match && match[1]) {
+        return parseInt(match[1]);
+      }
+      return null;
+    },
   },
   watch: {
     selectedProcess() {
@@ -84,16 +100,19 @@ export default {
     value: {
       handler() {
         this.config = JSON.parse(this.value);
+        this.loadSelectedProcessInfo();
       },
       immediate: true,
     },
   },
   methods: {
+    searchChange(filter) {
+      this.loadProcesses(filter);
+    },
     filterValidProcesses(processes) {
       return processes.filter(process => {
-        return process.category.is_system == false
-            && this.filterValidStartEvents(process.events).length > 0;
-      });
+        return this.filterValidStartEvents(process.events).length > 0;
+      }).filter(process => process.id !== this.currentProcessId);
     },
     filterValidStartEvents(events) {
       return events.filter(event => {
@@ -151,8 +170,38 @@ export default {
     containsMultipleProcesses(process) {
       return uniqBy(process.events, 'ownerProcessId').length > 1;
     },
-    loadProcesses() {
-      store.dispatch('fetchGlobalProcesses');
+    loadProcesses(filter) {
+      this.loading = true;
+
+      const params = {
+        order_direction: 'asc',
+        per_page: 20,
+        status: 'all',
+        include: 'events,category',
+      };
+
+      if (filter) {
+        params.filter = filter;
+      }
+
+      window.ProcessMaker.apiClient.get('processes', {
+        params,
+      }).then(response => {
+        this.loading = false;
+        this.processes = response.data.data;
+      })
+        .catch(() => {
+          this.loading = false;
+        });
+    },
+    loadSelectedProcessInfo() {
+      if (this.config.processId) {
+        window.ProcessMaker.apiClient.get('processes/' + this.config.processId, { params: {
+          include: 'events,category',
+        } }).then(response => {
+          this.selectedProcessInfo = response.data;
+        });
+      }
     },
   },
   created() {

package/src/mixins/linkConfig.js

@@ -214,9 +214,8 @@ export default {
 
       const sourceAnchorTool = new linkTools.SourceAnchor({ snap: this.getAnchorPointFunction('source') });
       const targetAnchorTool = new linkTools.TargetAnchor({ snap: this.getAnchorPointFunction('target') });
-      const segmentsTool = new linkTools.Segments();
       const toolsView = new dia.ToolsView({
-        tools: [verticesTool, segmentsTool, sourceAnchorTool, targetAnchorTool],
+        tools: [verticesTool, sourceAnchorTool, targetAnchorTool],
       });
 
       this.shapeView.addTools(toolsView);
@@ -245,7 +244,9 @@ export default {
     this.setSource(this.sourceShape);
 
     this.$once('click', () => {
-      this.setupLinkTools();
+      this.$nextTick(() => {
+        this.setupLinkTools();
+      });
     });
 
     const targetRef = this.getTargetRef

package/src/setup/globals.js

@@ -19,8 +19,13 @@ mock.onGet(/\/processes\/\d+/).reply((config) => {
     });
   }
 
+  const regex = /processes\/(\d+)/g;
+  const matches = regex.exec(config.url);
+  const requestedId = matches[1];
+  const process = mockProcesses.data.find(p => p.id === parseInt(requestedId));
+
   return new Promise((resolve) => {
-    setTimeout(() => resolve([200, { svg: mockProcessSvg }]), 1000);
+    setTimeout(() => resolve([200, { svg: mockProcessSvg, ...process }]), 1000);
   });
 });