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

package/lib/base/Modeler.js

@@ -13,8 +13,10 @@ import signavioCompatModule from 'bpmn-js-signavio-compat';
 
 import disableCollapsedSubprocessModule from 'bpmn-js-disable-collapsed-subprocess';
 
-import propertiesPanelModule from 'bpmn-js-properties-panel';
-import propertiesProviderModule from 'bpmn-js-properties-panel/lib/provider/bpmn';
+import {
+  BpmnPropertiesPanelModule as propertiesPanelModule,
+  BpmnPropertiesProviderModule as bpmnPropertiesProviderModule
+} from 'bpmn-js-properties-panel';
 
 /**
  *
@@ -42,7 +44,7 @@ Modeler.prototype._extensionModules = [
   signavioCompatModule,
   disableCollapsedSubprocessModule,
   propertiesPanelModule,
-  propertiesProviderModule
+  bpmnPropertiesProviderModule
 ];
 
 Modeler.prototype._modules = [].concat(

package/lib/camunda-cloud/Modeler.js

@@ -12,7 +12,9 @@ import popupMenuModule from './features/popup-menu';
 
 import rulesModule from './features/rules';
 
-import propertiesProviderModule from './features/properties-provider';
+import {
+  ZeebePropertiesProviderModule as zeebePropertiesProviderModule
+} from 'bpmn-js-properties-panel';
 
 import zeebeModdle from 'zeebe-bpmn-moddle/resources/zeebe.json';
 
@@ -44,11 +46,11 @@ Modeler.prototype._camundaCloudModules = [
   paletteModule,
   popupMenuModule,
   rulesModule,
-  propertiesProviderModule,
+  zeebePropertiesProviderModule,
   zeebeModdleExtension
 ];
 
 Modeler.prototype._modules = [].concat(
   BaseModeler.prototype._modules,
   Modeler.prototype._camundaCloudModules
-);
+);

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

@@ -0,0 +1,78 @@
+import {
+  is
+} from 'bpmn-js/lib/util/ModelUtil';
+
+import {
+  getBusinessObject
+} from 'bpmn-js/lib/util/ModelUtil';
+
+import CommandInterceptor from 'diagram-js/lib/command/CommandInterceptor';
+
+const HIGH_PRIORITY = 5000;
+
+
+/**
+ * Zeebe BPMN behavior for ensuring that there are not empty (ie. without properties)
+ * zeebe:assignmentDefinitions after modeling operations. Will also remove related
+ * extensionElements, if they remain empty afterwards (could be a seperate
+ * behavior in the future, if needed)
+ */
+export default class CleanUpBusinessRuleTaskBehavior extends CommandInterceptor {
+  constructor(eventBus, modeling) {
+    super(eventBus);
+
+    /**
+     * Remove zeebe:assignmentDefinition when it has no defined properties left after the operation
+     */
+    this.postExecuted([
+      'properties-panel.update-businessobject',
+      'element.updateModdleProperties'
+    ] , HIGH_PRIORITY, function(context) {
+      const {
+        element,
+        businessObject,
+        moddleElement
+      } = context;
+
+      // (1) harmonize property names from commands
+      const assignmentDefintion = businessObject || moddleElement;
+
+      if (
+        is(element, 'bpmn:UserTask')
+        && assignmentDefintion
+        && is(assignmentDefintion, 'zeebe:AssignmentDefinition')
+        && assignmentDefintion.assignee === undefined
+        && assignmentDefintion.candidateGroups === undefined
+      ) {
+        const extensionElements = getBusinessObject(element).extensionElements;
+
+        // (2) remove zeebe:assignmentDefintion
+        removeFromExtensionElements(element, extensionElements, modeling,
+          (ele) => !is(ele, 'zeebe:AssignmentDefinition'));
+
+        // (3) if extensionElements are empty afterwards, remove them as well
+        if (extensionElements.values.length === 0) {
+          modeling.updateModdleProperties(element, getBusinessObject(element),
+            { extensionElements: undefined });
+        }
+      }
+    }, true);
+
+  }
+}
+
+CleanUpBusinessRuleTaskBehavior.$inject = [
+  'eventBus',
+  'modeling'
+];
+
+
+// helper ////////////////////
+
+function removeFromExtensionElements(element, extensionElements, modeling, filterFun) {
+  const values = extensionElements.get('values').filter(filterFun);
+
+  modeling.updateModdleProperties(element, extensionElements, {
+    values
+  });
+}

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 { createElement } from '../../../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 = 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'
+];