camunda-bpmn-js 0.11.5 → 0.13.0-alpha.0

package/lib/camunda-cloud/features/modeling/behavior/FormDefinitionBehavior.js

@@ -1,20 +1,13 @@
 
-import inherits from 'inherits';
-
 import CommandInterceptor from 'diagram-js/lib/command/CommandInterceptor';
 
-import elementHelper from 'bpmn-js-properties-panel/lib/helper/ElementHelper';
+import { createElement } from '../../../helper/ElementHelper';
 
 import {
   getBusinessObject,
   is
 } from 'bpmn-js/lib/util/ModelUtil';
 
-import {
-  remove as collectionRemove,
-  add as collectionAdd
-} from 'diagram-js/lib/util/Collections';
-
 import {
   createFormDefinition,
   createFormId,
@@ -26,161 +19,110 @@ import {
 
 
 /**
- * Zeebe specific form definition behavior.
+ * Zeebe BPMN specific form definition behavior.
  */
-export default function FormDefinitionBehavior(
-    eventBus, bpmnFactory) {
-
-  CommandInterceptor.call(this, eventBus);
-
-  /**
-   * ensures a zeebe:userTaskForm is cleaned up when user task got removed
-   */
-  this.executed('shape.delete', function(context) {
-    const {
-      shape,
-      oldParent
-    } = context;
-
-    const rootElement = getRootElement(oldParent);
+export default class FormDefinitionBehavior extends CommandInterceptor {
+  constructor(bpmnFactory, eventBus, modeling) {
+    super(eventBus);
 
-    const userTaskForm = getUserTaskForm(shape, rootElement);
+    /**
+     * Remove zeebe:UserTaskForm on user task removed.
+     */
+    this.postExecute('shape.delete', function(context) {
+      const {
+        oldParent,
+        shape
+      } = context;
 
-    const rootExtensionElements = rootElement.get('extensionElements');
+      const rootElement = getRootElement(oldParent);
 
-    if (!is(shape, 'bpmn:UserTask') || !userTaskForm) {
-      return;
-    }
+      const userTaskForm = getUserTaskForm(shape, rootElement);
 
-    collectionRemove(rootExtensionElements.get('values'), userTaskForm);
+      if (!is(shape, 'bpmn:UserTask') || !userTaskForm) {
+        return;
+      }
 
-    context.removedUserTaskForm = userTaskForm;
-  }, true);
+      const rootExtensionElements = rootElement.get('extensionElements');
 
-  this.revert('shape.delete', function(context) {
-    const {
-      removedUserTaskForm,
-      oldParent
-    } = context;
+      const values = rootExtensionElements.get('values').filter((element) => {
+        return element !== userTaskForm;
+      });
 
-    const rootElement = getRootElement(oldParent);
+      modeling.updateModdleProperties(shape, rootExtensionElements, { values });
+    }, true);
 
-    const rootExtensionElements = rootElement.get('extensionElements');
 
-    if (!removedUserTaskForm) {
-      return;
-    }
+    /**
+     * Create new zeebe:FormDefinition and zeebe:UserTaskForm on user task created.
+     */
+    this.postExecute('shape.create', function(context) {
+      const { shape } = context;
 
-    collectionAdd(rootExtensionElements.get('values'), removedUserTaskForm);
-  }, true);
+      const oldFormDefinition = getFormDefinition(shape);
 
+      if (!is(shape, 'bpmn:UserTask') || !oldFormDefinition) {
+        return;
+      }
 
-  /**
-   * create fresh new copied form definition + user task form
-   */
-  this.executed('shape.create', function(context) {
-    const {
-      shape,
-    } = context;
+      const oldUserTaskForm = getUserTaskForm(shape);
 
-    const oldFormDefinition = getFormDefinition(shape);
+      const rootElement = getRootElement(shape);
 
-    if (!is(shape, 'bpmn:UserTask') || !oldFormDefinition) {
-      return;
-    }
+      const businessObject = getBusinessObject(shape);
 
-    const oldUserTaskForm = getUserTaskForm(shape);
+      const extensionElements = businessObject.get('extensionElements');
 
-    const rootElement = getRootElement(shape);
+      let rootExtensionElements = rootElement.get('extensionElements');
 
-    const businessObject = getBusinessObject(shape);
+      // (1) ensure extension elements exists
+      if (!rootExtensionElements) {
+        rootExtensionElements = createElement('bpmn:ExtensionElements', { values: [] }, rootElement, bpmnFactory);
 
-    const extensionElements = businessObject.get('extensionElements');
+        modeling.updateModdleProperties(shape, rootElement, { extensionElements: rootExtensionElements });
+      }
 
-    let rootExtensionElements = rootElement.get('extensionElements');
+      // (2) remove existing form definition
+      let values = extensionElements.get('values').filter((element) => {
+        return element !== oldFormDefinition;
+      });
 
-    // (1) ensure extension elements in root
-    if (!rootExtensionElements) {
+      // (3) create new form definition
+      const formId = createFormId();
 
-      rootExtensionElements = elementHelper.createElement(
-        'bpmn:ExtensionElements',
-        { values: [] },
-        rootElement,
-        bpmnFactory
-      );
+      const newFormDefinition = createFormDefinition({ formKey: createFormKey(formId) }, extensionElements, bpmnFactory);
 
-      rootElement.set('extensionElements', rootExtensionElements);
-    }
+      values = [
+        ...values,
+        newFormDefinition
+      ];
 
-    // (2) remove existing form definition
-    context.oldFormDefinition = oldFormDefinition;
+      modeling.updateModdleProperties(shape, extensionElements, {
+        values
+      });
 
-    collectionRemove(extensionElements.get('values'), oldFormDefinition);
-
-    const formId = createFormId();
-
-    // (3) create new form definition
-    const formDefinition = createFormDefinition(
-      {
-        formKey: createFormKey(formId)
-      },
-      extensionElements,
-      bpmnFactory
-    );
-
-    collectionAdd(extensionElements.get('values'), formDefinition);
-
-    // (4) create new user task form
-    const userTaskForm = createUserTaskForm(
-      {
+      // (4) create new user task form
+      const userTaskForm = createUserTaskForm({
         id: formId,
         body: oldUserTaskForm ? oldUserTaskForm.get('body') : ''
-      },
-      rootExtensionElements,
-      bpmnFactory
-    );
-
-    collectionAdd(rootExtensionElements.get('values'), userTaskForm);
-  }, true);
+      }, rootExtensionElements, bpmnFactory);
 
-  this.revert('shape.create', function(context) {
-    const {
-      shape,
-      oldFormDefinition
-    } = context;
-
-    const businessObject = getBusinessObject(shape);
-
-    const extensionElements = businessObject.get('extensionElements');
-
-    const formDefinition = getFormDefinition(shape);
-
-    const userTaskForm = getUserTaskForm(shape);
-
-    const rootElement = getRootElement(shape);
-
-    const rootExtensionElements = rootElement.get('extensionElements');
-
-    if (!is(shape, 'bpmn:UserTask') || !userTaskForm) {
-      return;
-    }
-
-    // we need to cover the old form definition to make <redo> possible
-    collectionRemove(extensionElements.get('values'), formDefinition);
-    collectionAdd(extensionElements.get('values'), oldFormDefinition);
-
-    collectionRemove(rootExtensionElements.get('values'), userTaskForm);
-  }, true);
+      modeling.updateModdleProperties(shape, rootExtensionElements, {
+        values: [
+          ...(rootExtensionElements.get('values') || []),
+          userTaskForm
+        ]
+      });
+    }, true);
 
+  }
 }
 
 FormDefinitionBehavior.$inject = [
+  'bpmnFactory',
   'eventBus',
-  'bpmnFactory'
+  'modeling'
 ];
 
-inherits(FormDefinitionBehavior, CommandInterceptor);
-
 
 // helpers //////////////
 

package/lib/camunda-cloud/features/modeling/behavior/UpdatePropagateAllChildVariablesBehavior.js

@@ -1,11 +1,8 @@
 import {
-  getBusinessObject
+  getBusinessObject,
+  is
 } from 'bpmn-js/lib/util/ModelUtil';
 
-import inherits from 'inherits';
-
-import { is } from 'bpmn-js/lib/util/ModelUtil';
-
 import {
   getCalledElement,
   isPropagateAllChildVariables
@@ -14,148 +11,99 @@ import {
 import {
   getInputParameters,
   getOutputParameters,
-  getInputOutput
+  getIoMapping
 } from '../../../helper/InputOutputHelper';
 
 import CommandInterceptor from 'diagram-js/lib/command/CommandInterceptor';
 
-const HIGH_PRIORITY = 15000;
+const HIGH_PRIORITY = 5000;
 
 
 /**
- * UpdatePropagateAllChildVariablesBehavior reacts to either (1) toggling on propagateAllChildVariables
- * when there are outputParameters present or (2) to adding outputParameters when
- * propagateAllChildVariables is set to true.
- * It will ensure that the propagateAllChildVariables attribute on calledElement
- * extensionElements for callActivities is always consistent with outputParameter mappings
+ * Zeebe BPMN behavior for updating zeebe:propagateAllChildVariables.
  */
-export default function UpdatePropagateAllChildVariablesBehavior(
-    eventBus) {
-
-  CommandInterceptor.call(this, eventBus);
-
-  // Behavior when toggling propagateAllChildVariables /////////////////////////
-  /**
-   * remove outputParameters from zeebe:IoMapping when setting propgateAlLChildVariables
-   * to true in the proeprties panel
-   */
-  this.executed('properties-panel.update-businessobject' , HIGH_PRIORITY, function(context) {
-    const {
-      element,
-      properties
-    } = context;
-
-    // (1) Don't execute this behavior if we are not in a call activity or not
-    // have properties to update or not update the propagateAllChildVariables
-    // to false
-    if (!is(element, 'bpmn:CallActivity') ||
-        !properties ||
-        !!properties.propagateAllChildVariables === false) {
-      return;
-    }
-
-    // (2) Check whether we have outputParameters
-    const outputParameters = getOutputParameters(element),
-          inputParameters = getInputParameters(element);
-
-    if (!outputParameters ||
-      outputParameters.length === 0) {
-      return;
-    }
-
-    // (3) Store old outputParameters and remove them
-    context.oldOutputParameters = outputParameters;
-
-    const inputOutput = getInputOutput(element);
-    inputOutput.outputParameters = [];
-
-    // (4) if we also have no inputParameters, store IOMapping and remove it
-    if (!inputParameters || inputParameters.length === 0) {
-      const extensionElements = getBusinessObject(element).extensionElements;
-      context.oldExtensionElements = extensionElements.values;
-
-      extensionElements.values = extensionElements.values.filter(ele => ele.$type !== 'zeebe:IoMapping');
-    }
-  }, true);
-
-  // Revert behavior when toggling propagateAllChildVariables //////////////////
-  this.reverted('properties-panel.update-businessobject', HIGH_PRIORITY, function(context) {
-    const {
-      element,
-      oldOutputParameters,
-      oldExtensionElements
-    } = context;
-
-    // (1) Only intercept the revert, if the behavior became active
-    if (oldOutputParameters) {
-
-      // (2) If we removed the IOMapping, bring it back first
-      if (oldExtensionElements) {
-        const extensionElements = getBusinessObject(element).extensionElements;
-
-        extensionElements.values = oldExtensionElements;
+export default class UpdatePropagateAllChildVariablesBehavior extends CommandInterceptor {
+  constructor(eventBus, modeling) {
+    super(eventBus);
+
+    /**
+     * Remove zeebe:OutputParameters when zeebe:propagateAllChildVariables is set to true.
+     */
+    this.postExecute('properties-panel.update-businessobject' , HIGH_PRIORITY, function(context) {
+      const {
+        element,
+        properties
+      } = context;
+
+      if (
+        !is(element, 'bpmn:CallActivity')
+        || !properties
+        || !!properties.propagateAllChildVariables === false
+      ) {
+        return;
       }
 
-      // (3) Bring back the outputParameters
-      const inputOutput = getInputOutput(element);
-      inputOutput.outputParameters = oldOutputParameters;
-    }
-  }, true);
-
+      const inputParameters = getInputParameters(element),
+            outputParameters = getOutputParameters(element);
 
-  // Behavior when adding outputParameters ////////////////////////////////////
-  /**
-   * un-toggle propgateAlLChildVariables when adding output parameters
-   */
-  this.executed('properties-panel.update-businessobject-list' , HIGH_PRIORITY, function(context) {
-    const {
-      element,
-      objectsToAdd
-    } = context;
-
-
-    // (1) Exit if we are not in a CallActivity, not adding an OutputParameter or not
-    // having set propagateAllChildVariables to false
-    if (!is(element, 'bpmn:CallActivity') ||
-     !objectsToAdd ||
-     objectsToAdd.length === 0 ||
-     objectsToAdd.filter(obj => is(obj, 'zeebe:Output')).length === 0 ||
-    isPropagateAllChildVariables(element) === false) {
-      return;
-    }
+      if (!outputParameters || !outputParameters.length) {
+        return;
+      }
 
-    // (2) Store the old propAllChildVariables value and update it then
-    const bo = getBusinessObject(element),
-          calledElement = getCalledElement(bo);
+      const ioMapping = getIoMapping(element);
 
-    context.oldPropagateAllChildVariables = true;
+      modeling.updateModdleProperties(element, ioMapping, {
+        'zeebe:outputParameters': []
+      });
 
-    calledElement.propagateAllChildVariables = false;
-  }, true);
+      if (!inputParameters || !inputParameters.length) {
+        const businessObject = getBusinessObject(element),
+              extensionElements = businessObject.get('extensionElements');
 
-  // Revert behavior when adding outputParmaeters ////////////////////////////////////
-  this.reverted('properties-panel.update-businessobject-list' , HIGH_PRIORITY, function(context) {
-    const {
-      element,
-      oldPropagateAllChildVariables
-    } = context;
+        const values = extensionElements.get('values').filter((element) => {
+          return !is(element, 'zeebe:IoMapping');
+        });
 
-    // (1) Only intercept the revert, if the behavior became active
-    if (oldPropagateAllChildVariables) {
-      const bo = getBusinessObject(element),
-            calledElement = getCalledElement(bo);
+        modeling.updateModdleProperties(element, extensionElements, {
+          values
+        });
+      }
+    }, true);
+
+
+    /**
+     * Set zeebe:propagateAllChildVariables to false on zeebe:Output added.
+     */
+    this.postExecute('properties-panel.update-businessobject-list' , HIGH_PRIORITY, function(context) {
+      const {
+        currentObject,
+        element,
+        objectsToAdd,
+        propertyName
+      } = context;
+
+      if (!is(element, 'bpmn:CallActivity')
+        || !is(currentObject, 'zeebe:IoMapping')
+        || (propertyName !== 'outputParameters' && propertyName !== 'zeebe:outputParameters')
+        || !objectsToAdd
+        || !objectsToAdd.length
+        || !objectsToAdd.find((object) => is(object, 'zeebe:Output'))
+        || !isPropagateAllChildVariables(element)) {
+        return;
+      }
 
-      calledElement.propagateAllChildVariables = oldPropagateAllChildVariables;
-    }
-  }, true);
+      const businessObject = getBusinessObject(element),
+            calledElement = getCalledElement(businessObject);
 
+      modeling.updateModdleProperties(element, calledElement, {
+        'zeebe:propagateAllChildVariables': false
+      });
+    }, true);
 
+  }
 }
 
-
 UpdatePropagateAllChildVariablesBehavior.$inject = [
-  'eventBus'
-];
-
-
-inherits(UpdatePropagateAllChildVariablesBehavior, CommandInterceptor);
+  'eventBus',
+  'modeling'
+];

package/lib/camunda-cloud/features/modeling/behavior/index.js

@@ -1,3 +1,5 @@
+import CleanUpAssignmentDefinitionBehavior from './CleanUpAssignmentDefinitionBehavior';
+import CleanUpBusinessRuleTaskBehavior from './CleanUpBusinessRuleTaskBehavior';
 import CreateZeebeBoundaryEventBehavior from './CreateZeebeBoundaryEventBehavior';
 import CreateZeebeCallActivityBehavior from './CreateZeebeCallActivityBehavior';
 import UpdatePropagateAllChildVariablesBehavior from './UpdatePropagateAllChildVariablesBehavior';
@@ -6,11 +8,15 @@ import FormDefinitionBehavior from './FormDefinitionBehavior';
 
 export default {
   __init__: [
+    'cleanUpAssignmentDefinitionBehavior',
+    'cleanUpBusinessRuleTaskBehavior',
     'createZeebeBoundaryEventBehavior',
     'createZeebeCallActivityBehavior',
     'updatePropagateAllChildVariablesBehavior',
     'formDefinitionBehavior'
   ],
+  cleanUpAssignmentDefinitionBehavior: [ 'type', CleanUpAssignmentDefinitionBehavior ],
+  cleanUpBusinessRuleTaskBehavior: [ 'type', CleanUpBusinessRuleTaskBehavior ],
   createZeebeBoundaryEventBehavior: [ 'type', CreateZeebeBoundaryEventBehavior ],
   createZeebeCallActivityBehavior: [ 'type', CreateZeebeCallActivityBehavior ],
   updatePropagateAllChildVariablesBehavior: [ 'type', UpdatePropagateAllChildVariablesBehavior ],

package/lib/camunda-cloud/features/rules/BpmnRules.js

@@ -22,7 +22,7 @@ import {
   getBoundaryAttachment as isBoundaryAttachment
 } from 'bpmn-js/lib/features/snapping/BpmnSnappingUtil';
 
-const HIGH_PRIORITY = 15000;
+const HIGH_PRIORITY = 5000;
 
 /**
  * Zeebe rule provider that allows to create boundary events with catch events

package/lib/camunda-cloud/helper/CalledElementHelper.js

@@ -1,70 +1,72 @@
-import {
-  has
-} from 'min-dash';
+import { has } from 'min-dash';
 
-import {
-  getOutputParameters
-} from './InputOutputHelper';
+import { getOutputParameters } from './InputOutputHelper';
 
-import {
-  getExtensionElements
-} from 'bpmn-js-properties-panel/lib/helper/ExtensionElementsHelper';
-
-import {
-  getBusinessObject
-} from 'bpmn-js/lib/util/ModelUtil';
+import { getExtensionElements } from './ExtensionElementsHelper';
 
 import {
+  getBusinessObject,
   is
 } from 'bpmn-js/lib/util/ModelUtil';
 
+
 /**
-  * Determine default value for propagateAllChildVariables attribute
-  * @param {Object} element representing a bpmn:CallActivity
-  *
-  * @returns {boolean}
-  */
-function determinePropAllChildVariablesDefault(element) {
+ * Get default value for zeebe:propagateAllChildVariables.
+ *
+ * @param {djs.model.Base|ModdleElement} element
+ *
+ * @returns {boolean}
+ */
+function getPropagateAllChildVariablesDefault(element) {
+  if (!is(element, 'bpmn:CallActivity')) {
+    return;
+  }
+
   const outputParameters = getOutputParameters(element);
 
   if (outputParameters) {
-    return (outputParameters.length > 0) ? false : true;
+    return !outputParameters.length;
   }
 }
 
 /**
-  * Get the 'zeebe:CalledElement' extension element for a given business Object
-  * @param {Object} bo businessObject
-  *
-  * @returns {Object} the calledElement Moddle Object or undefined if zeebe:CalledElement does not exist
-  */
+ * Get zeebe:CalledElement of an element.
+ *
+ * @param {djs.model.Base|ModdleElement} element
+ *
+ * @returns {ModdleElement}
+ */
 export function getCalledElement(element) {
   const calledElements = getCalledElements(element);
-  return calledElements[0];
+
+  return calledElements[ 0 ];
 }
 
 export function getCalledElements(element) {
-  const bo = getBusinessObject(element);
-  const extElements = getExtensionElements(bo, 'zeebe:CalledElement');
-  return extElements;
+  const businessObject = getBusinessObject(element);
+
+  return getExtensionElements(businessObject, 'zeebe:CalledElement');
 }
 
 /**
-  * Check whether the propagateAllChildVariables attribute is set on an element.
-  * Note that a default logic will be determine if it is not explicitly set.
-  * @param {Object} element
-  *
-  * @returns {boolean}
-  */
+ * Check whether zeebe:propagateAllChildVariables is set on an element.
+ * Fall back to default if zeebe:propagateAllChildVariables not set.
+ *
+ * @param {djs.model.Base|ModdleElement} element
+ *
+ * @returns {boolean}
+ */
 export function isPropagateAllChildVariables(element) {
   if (!is(element, 'bpmn:CallActivity')) {
-    return undefined;
+    return;
   }
 
-  const bo = getBusinessObject(element),
-        calledElement = getCalledElement(bo);
+  const businessObject = getBusinessObject(element),
+        calledElement = getCalledElement(businessObject);
 
-  return calledElement && has(calledElement, 'propagateAllChildVariables') ?
-    calledElement.get('propagateAllChildVariables') :
-    determinePropAllChildVariablesDefault(element);
+  if (calledElement && has(calledElement, 'propagateAllChildVariables')) {
+    return calledElement.get('propagateAllChildVariables');
+  } else {
+    return getPropagateAllChildVariablesDefault(element);
+  }
 }

package/lib/camunda-cloud/helper/ElementHelper.js

@@ -0,0 +1,18 @@
+/**
+ * Creates a new element and set the parent to it
+ *
+ * @method ElementHelper#createElement
+ *
+ * @param {String} elementType of the new element
+ * @param {Object} properties of the new element in key-value pairs
+ * @param {moddle.object} parent of the new element
+ * @param {BpmnFactory} factory which creates the new element
+ *
+ * @returns {djs.model.Base} element which is created
+ */
+export function createElement(elementType, properties, parent, factory) {
+  var element = factory.create(elementType, properties);
+  element.$parent = parent;
+
+  return element;
+}

package/lib/camunda-cloud/helper/ExtensionElementsHelper.js

@@ -0,0 +1,17 @@
+import { is } from 'bpmn-js/lib/util/ModelUtil';
+
+export function getExtensionElements(bo, type) {
+  let elements = [];
+  const extensionElements = bo.get('extensionElements');
+
+  if (typeof extensionElements !== 'undefined') {
+    const extensionValues = extensionElements.get('values');
+    if (typeof extensionValues !== 'undefined') {
+      elements = extensionValues.filter(function(value) {
+        return is(value, type);
+      });
+    }
+  }
+
+  return elements;
+}