camunda-bpmn-js 0.11.3 → 0.12.1

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

@@ -0,0 +1,112 @@
+import {
+  is
+} from 'bpmn-js/lib/util/ModelUtil';
+
+import CommandInterceptor from 'diagram-js/lib/command/CommandInterceptor';
+
+const HIGH_PRIORITY = 5000;
+
+
+/**
+ * Zeebe BPMN behavior for ensuring that a BusinessRuleTask:
+ * 1) Either has a taskDefinition ExtensionElement OR
+ * 2) Or has a calledDecision ExtensionElement
+ * 2.1) If it has a calledDecision ExtensionElement, it shall not have taskHeaders
+ */
+export default class CleanUpBusinessRuleTaskBehavior extends CommandInterceptor {
+  constructor(eventBus, modeling) {
+    super(eventBus);
+
+    /**
+     * Remove zeebe:calledDecision when zeebe:taskDefinition is added
+     */
+    this.postExecute([
+      'properties-panel.update-businessobject-list',
+      'element.updateModdleProperties'
+    ] , HIGH_PRIORITY, function(context) {
+      const {
+        element,
+        currentObject,
+        objectsToAdd,
+        moddleElement,
+        properties
+      } = context;
+
+      // (1) map properties from both commands
+      const extensionElement = currentObject || moddleElement,
+            newValues = objectsToAdd || (properties && properties.values);
+
+      // (2) check conditions and potentially update
+      if (
+        is(element, 'bpmn:BusinessRuleTask')
+        && extensionElement
+        && is(extensionElement, 'bpmn:ExtensionElements')
+        && extensionElement.get('values').some((ele) => is(ele, 'zeebe:CalledDecision'))
+        && newValues
+        && newValues.some((ele) => is(ele, 'zeebe:TaskDefinition'))
+      ) {
+        removeCalledDecision(element, extensionElement, modeling);
+      }
+    }, true);
+
+    /**
+     * Remove zeebe:taskDefinition and zeebe:taskHeaders when zeebe:calledDecision
+     */
+    this.postExecute([
+      'properties-panel.update-businessobject-list',
+      'element.updateModdleProperties'
+    ] , HIGH_PRIORITY, function(context) {
+      const {
+        element,
+        currentObject,
+        objectsToAdd,
+        moddleElement,
+        properties
+      } = context;
+
+      // (1) map properties from both commands
+      const extensionElement = currentObject || moddleElement,
+            newValues = objectsToAdd || (properties && properties.values);
+
+      // (2) check conditions and potentially update
+      if (
+        is(element, 'bpmn:BusinessRuleTask')
+        && extensionElement
+        && is(extensionElement, 'bpmn:ExtensionElements')
+        && extensionElement.get('values').some(
+          (ele) => is(ele, 'zeebe:TaskDefinition') || is(ele, 'zeebe:TaskHeaders'))
+        && newValues
+        && newValues.some((ele) => is(ele, 'zeebe:CalledDecision'))
+      ) {
+        removeTaskDefintionAndHeaders(element, extensionElement, modeling);
+      }
+    }, true);
+
+  }
+}
+
+CleanUpBusinessRuleTaskBehavior.$inject = [
+  'eventBus',
+  'modeling'
+];
+
+
+// helper ////////////////////
+
+function removeFromExtensionElements(element, extensionElements, modeling, filterFun) {
+  const values = extensionElements.get('values').filter(filterFun);
+
+  modeling.updateModdleProperties(element, extensionElements, {
+    values
+  });
+}
+
+function removeCalledDecision(element, extensionElements, modeling) {
+  removeFromExtensionElements(element, extensionElements, modeling,
+    (ele) => !is(ele, 'zeebe:CalledDecision'));
+}
+
+function removeTaskDefintionAndHeaders(element, extensionElements, modeling) {
+  removeFromExtensionElements(element, extensionElements, modeling,
+    (ele) => !is(ele, 'zeebe:TaskDefinition') && !is(ele, 'zeebe:TaskHeaders'));
+}

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

@@ -1,5 +1,3 @@
-import inherits from 'inherits';
-
 import CommandInterceptor from 'diagram-js/lib/command/CommandInterceptor';
 
 import {
@@ -7,74 +5,72 @@ import {
   is
 } from 'bpmn-js/lib/util/ModelUtil';
 
-const HIGH_PRIORITY = 15000;
+const HIGH_PRIORITY = 5000;
+
 
 /**
- * BPMN specific create zeebe boundary event behavior
+ * Zeebe BPMN specific behavior for creating boundary events.
  */
-export default function CreateZeebeBoundaryEventBehavior(
-    eventBus, elementFactory, bpmnFactory) {
-
-  CommandInterceptor.call(this, eventBus);
-
-  /**
-   * replace intermediate catch event with boundary event when
-   * attaching it to a shape
-   */
-  this.preExecute('shape.create', HIGH_PRIORITY, function(context) {
-    const {
-      shape,
-      host
-    } = context;
-
-    const businessObject = getBusinessObject(shape);
-
-    let attrs = {
-      cancelActivity: true
-    };
-
-    let newBusinessObject,
-        hostBusinessObject,
-        boundaryEvent,
-        eventDefinitions;
+export default class CreateZeebeBoundaryEventBehavior extends CommandInterceptor {
+  constructor(bpmnFactory, elementFactory, eventBus) {
+    super(eventBus);
+
+    /**
+     * Replace intermediate catch event with boundary event when attaching it to a shape.
+     */
+    this.preExecute('shape.create', HIGH_PRIORITY, function(context) {
+      const {
+        shape,
+        host
+      } = context;
+
+      const businessObject = getBusinessObject(shape);
+
+      let attrs = {
+        cancelActivity: true
+      };
 
-    if (!host || !is(shape, 'bpmn:IntermediateCatchEvent')) {
-      return;
-    }
+      let newBusinessObject,
+          hostBusinessObject,
+          boundaryEvent,
+          eventDefinitions;
 
-    hostBusinessObject = getBusinessObject(host);
+      if (!host || !is(shape, 'bpmn:IntermediateCatchEvent')) {
+        return;
+      }
 
-    attrs = {
-      attachedToRef: hostBusinessObject,
-      ...attrs
-    };
+      hostBusinessObject = getBusinessObject(host);
 
-    eventDefinitions = businessObject.eventDefinitions;
+      attrs = {
+        ...attrs,
+        attachedToRef: hostBusinessObject
+      };
 
-    newBusinessObject = bpmnFactory.create('bpmn:BoundaryEvent', attrs);
+      eventDefinitions = businessObject.eventDefinitions;
 
-    boundaryEvent = {
-      type: 'bpmn:BoundaryEvent',
-      businessObject: newBusinessObject,
-    };
+      newBusinessObject = bpmnFactory.create('bpmn:BoundaryEvent', attrs);
 
-    if (eventDefinitions && eventDefinitions[0]) {
       boundaryEvent = {
-        ...boundaryEvent,
-        eventDefinitionType: eventDefinitions[0].$type
+        type: 'bpmn:BoundaryEvent',
+        businessObject: newBusinessObject,
       };
-    }
 
-    context.shape = elementFactory.createShape(boundaryEvent);
+      if (eventDefinitions && eventDefinitions[0]) {
+        boundaryEvent = {
+          ...boundaryEvent,
+          eventDefinitionType: eventDefinitions[0].$type
+        };
+      }
 
-  }, true);
-}
+      context.shape = elementFactory.createShape(boundaryEvent);
 
+    }, true);
+
+  }
+}
 
 CreateZeebeBoundaryEventBehavior.$inject = [
-  'eventBus',
+  'bpmnFactory',
   'elementFactory',
-  'bpmnFactory'
-];
-
-inherits(CreateZeebeBoundaryEventBehavior, CommandInterceptor);
+  'eventBus'
+];

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

@@ -1,14 +1,8 @@
-import inherits from 'inherits';
-
-import {
-  has
-} from 'min-dash';
+import { has } from 'min-dash';
 
 import elementHelper from 'bpmn-js-properties-panel/lib/helper/ElementHelper';
 
-import {
-  getCalledElement
-} from '../../../helper/CalledElementHelper';
+import { getCalledElement } from '../../../helper/CalledElementHelper';
 
 import {
   getBusinessObject,
@@ -17,61 +11,64 @@ import {
 
 import CommandInterceptor from 'diagram-js/lib/command/CommandInterceptor';
 
-const HIGH_PRIORITY = 15000;
+const HIGH_PRIORITY = 5000;
+
 
 /**
- * BPMN specific create zeebe call activity behavior
+ * Zeebe BPMN specific behavior for creating call activities.
  */
-export default function CreateZeebeCallActivityBehavior(
-    eventBus, bpmnFactory) {
-
-  CommandInterceptor.call(this, eventBus);
-
-  /**
-   * add a zeebe:calledElement extensionElement with
-   * propagateAllChildVariables attribute = false when creating
-   * a bpmn:callActivity
-   */
-  this.postExecuted('shape.create', HIGH_PRIORITY, function(context) {
-    const {
-      shape
-    } = context;
-
-    if (!is(shape, 'bpmn:CallActivity')) {
-      return;
-    }
-
-    const bo = getBusinessObject(shape);
-
-    // Reuse ExtensionElement if existing
-    const extensionElements = bo.get('extensionElements') ||
-      elementHelper.createElement('bpmn:ExtensionElements', { values: [] }, bo, bpmnFactory);
-
-    // Ensure we have a calledElement
-    let calledElement = getCalledElement(bo);
-
-    if (!calledElement) {
-      calledElement = bpmnFactory.create('zeebe:CalledElement', {});
-      calledElement.propagateAllChildVariables = false;
-
-      extensionElements.get('values').push(
-        calledElement
-      );
-
-      bo.extensionElements = extensionElements;
-
-      // Handle existing callActivities
-    } else if (!has(calledElement, 'propagateAllChildVariables')) {
-      calledElement.propagateAllChildVariables = false;
-    }
-
-  }, true);
+export default class CreateZeebeCallActivityBehavior extends CommandInterceptor {
+  constructor(bpmnFactory, eventBus, modeling) {
+    super(eventBus);
+
+    /**
+     * Add zeebe:CalledElement extension element with zeebe:propagateAllChildVariables attribute = false
+     * when creating bpmn:CallActivity.
+     */
+    this.postExecuted('shape.create', HIGH_PRIORITY, function(context) {
+      const { shape } = context;
+
+      if (!is(shape, 'bpmn:CallActivity')) {
+        return;
+      }
+
+      const businessObject = getBusinessObject(shape);
+
+      let calledElement = getCalledElement(businessObject);
+
+      if (!calledElement) {
+        calledElement = bpmnFactory.create('zeebe:CalledElement', {
+          propagateAllChildVariables: false
+        });
+
+        let extensionElements = businessObject.get('extensionElements');
+
+        if (!extensionElements) {
+          extensionElements = elementHelper.createElement('bpmn:ExtensionElements', { values: [] }, businessObject, bpmnFactory);
+
+          modeling.updateProperties(shape, { extensionElements });
+        }
+
+        modeling.updateModdleProperties(shape, extensionElements, {
+          values: [
+            ...(extensionElements.values || []),
+            calledElement
+          ]
+        });
+      } else if (!has(calledElement, 'propagateAllChildVariables')) {
+
+        // if zeebe:CalledElement exist set zeebe:propagateAllChildVariables to false
+        modeling.updateModdleProperties(shape, calledElement, {
+          propagateAllChildVariables: false
+        });
+      }
+    }, true);
+
+  }
 }
 
-
 CreateZeebeCallActivityBehavior.$inject = [
+  'bpmnFactory',
   'eventBus',
-  'bpmnFactory'
-];
-
-inherits(CreateZeebeCallActivityBehavior, CommandInterceptor);
+  'modeling'
+];

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

@@ -1,6 +1,4 @@
 
-import inherits from 'inherits';
-
 import CommandInterceptor from 'diagram-js/lib/command/CommandInterceptor';
 
 import elementHelper from 'bpmn-js-properties-panel/lib/helper/ElementHelper';
@@ -10,11 +8,6 @@ import {
   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 = elementHelper.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 //////////////