camunda-bpmn-js 0.11.5 → 0.12.0

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

@@ -1,132 +1,135 @@
 import {
-  getBusinessObject
+  getBusinessObject,
+  is
 } from 'bpmn-js/lib/util/ModelUtil';
 
-import {
-  isAny
-} from 'bpmn-js/lib/features/modeling/util/ModelingUtil';
+import { isAny } from 'bpmn-js/lib/features/modeling/util/ModelingUtil';
 
-import {
-  isZeebeServiceTask
-} from './ZeebeServiceTaskHelper';
+import elementHelper from 'bpmn-js-properties-panel/lib/helper/ElementHelper';
 
-import extensionElementsHelper from 'bpmn-js-properties-panel/lib/helper/ExtensionElementsHelper';
+import { isZeebeServiceTask } from './ZeebeServiceTaskHelper';
 
-import elementHelper from 'bpmn-js-properties-panel/lib/helper/ElementHelper';
 
+/**
+ * Get zeebe:IoMapping from an element.
+ *
+ * @param {djs.model.Base|ModdleElement} element
+ *
+ * @return {ModdleElement}
+ */
+export function getIoMapping(element) {
+  const businessObject = getBusinessObject(element);
 
-function getElements(bo, type, prop) {
-  const elems = extensionElementsHelper.getExtensionElements(bo, type);
-  return !prop ? elems : (elems[0] || {})[prop] || [];
-}
+  const extensionElements = businessObject.get('extensionElements');
 
-function getParameters(element, prop) {
-  const inputOutput = getInputOutput(element);
-  return (inputOutput && inputOutput.get(prop)) || [];
-}
+  if (!extensionElements) {
+    return;
+  }
 
-/**
-   * Get a inputOutput from the business object
-   *
-   * @param {djs.model.Base} element
-   *
-   * @return {ModdleElement} the inputOutput object
-   */
-export function getInputOutput(element) {
-  const bo = getBusinessObject(element);
-  return (getElements(bo, 'zeebe:IoMapping') || [])[0];
+  return extensionElements.get('values').find((value) => {
+    return is(value, 'zeebe:IoMapping');
+  });
 }
 
-
 /**
-   * Return all input parameters existing in the business object, and
-   * an empty array if none exist.
-   *
-   * @param  {djs.model.Base} element
-   *
-   * @return {Array} a list of input parameter objects
-   */
+ * Get zeebe:InputParameters from an element.
+ *
+ * @param  {djs.model.Base|ModdleElement} element
+ *
+ * @return {Array<ModdleElement>}
+ */
 export function getInputParameters(element) {
-  return getParameters.apply(this, [ element, 'inputParameters' ]);
+  const ioMapping = getIoMapping(element);
+
+  if (ioMapping) {
+    return ioMapping.get('zeebe:inputParameters');
+  }
+
+  return [];
 }
 
 /**
-   * Return all output parameters existing in the business object, and
-   * an empty array if none exist.
-   *
-   * @param  {djs.model.Base} element
-   *
-   * @return {Array} a list of output parameter objects
-   */
+ * Get zeebe:OutputParameters from an element.
+ *
+ * @param  {djs.model.Base|ModdleElement} element
+ *
+ * @return {Array<ModdleElement>}
+ */
 export function getOutputParameters(element) {
-  return getParameters.apply(this, [ element, 'outputParameters' ]);
+  const ioMapping = getIoMapping(element);
+
+  if (ioMapping) {
+    return ioMapping.get('zeebe:outputParameters');
+  }
+
+  return [];
 }
 
 /**
-   * Get a input parameter from the business object at given index
-   *
-   * @param {djs.model.Base} element
-   * @param {number} idx
-   *
-   * @return {ModdleElement} input parameter
-   */
-export function getInputParameter(element, idx) {
-  return getInputParameters(element)[idx];
+ * Get zeebe:Input at index.
+ *
+ * @param {djs.model.Base|ModdleElement} element
+ * @param {number} index
+ *
+ * @return {ModdleElement}
+ */
+export function getInputParameter(element, index) {
+  return getInputParameters(element)[ index ];
 }
 
 /**
-   * Get a output parameter from the business object at given index
-   *
-   * @param {djs.model.Base} element
-   * @param {number} idx
-   *
-   * @return {ModdleElement} output parameter
-   */
-export function getOutputParameter(element, idx) {
-  return getOutputParameters(element)[idx];
+ * Get zeebe:Output at index.
+ *
+ * @param {djs.model.Base|ModdleElement} element
+ * @param {number} index
+ *
+ * @return {ModdleElement}
+ */
+export function getOutputParameter(element, index) {
+  return getOutputParameters(element)[ index ];
 }
 
 /**
-   * Returns 'true' if the given element supports inputOutput
-   *
-   * @param {djs.model.Base} element
-   *
-   * @return {boolean} a boolean value
-   */
+ * Check whether element supports zeebe:Input or zeebe:Output.
+ *
+ * @param {djs.model.Base|ModdleElement} element
+ *
+ * @return {boolean}
+ */
 export function isInputOutputSupported(element) {
-  return areOutputParametersSupported(element) || areInputParametersSupported(element);
+  return areInputParametersSupported(element) || areOutputParametersSupported(element);
 }
 
 /**
-   * Returns 'true' if the given element supports input parameters
-   *
-   * @param {djs.model.Base} element
-   *
-   * @return {boolean} a boolean value
-   */
+ * Check whether element supports zeebe:Input.
+ *
+ * @param {djs.model.Base|ModdleElement} element
+ *
+ * @return {boolean}
+ */
 export function areInputParametersSupported(element) {
   return isAny(element, [
-    'bpmn:UserTask',
+    'bpmn:CallActivity',
     'bpmn:SubProcess',
-    'bpmn:CallActivity'
+    'bpmn:UserTask'
   ]) || isZeebeServiceTask(element);
 }
 
 /**
-   * Returns 'true' if the given element supports output parameters
-   *
-   * @param {djs.model.Base} element
-   *
-   * @return {boolean} a boolean value
-   */
+ * Check whether element supports zeebe:Output.
+ *
+ * @param {djs.model.Base|ModdleElement} element
+ *
+ * @return {boolean}
+ */
 export function areOutputParametersSupported(element) {
   return isAny(element, [
-    'zeebe:ZeebeServiceTask',
-    'bpmn:UserTask',
-    'bpmn:SubProcess',
-    'bpmn:ReceiveTask',
     'bpmn:CallActivity',
-    'bpmn:Event'
+    'bpmn:Event',
+    'bpmn:ReceiveTask',
+    'bpmn:SubProcess',
+    'bpmn:UserTask',
+    'zeebe:ZeebeServiceTask'
   ]);
 }
 
@@ -134,23 +137,6 @@ export function createElement(type, parent, factory, properties) {
   return elementHelper.createElement(type, properties, parent, factory);
 }
 
-export function createIOMapping(parent, bpmnFactory, properties) {
+export function createIoMapping(parent, bpmnFactory, properties) {
   return createElement('zeebe:IoMapping', parent, bpmnFactory, properties);
 }
-
-/**
- * Get getter function for IOMapping parameters according to provided property name
- *
- * @param {string} property
- *
- * @returns {Function} Getter function for the IOMapping parameters according to provided property name
- */
-export function determineParamGetFunc(property) {
-  if (property == 'inputParameters') {
-    return getInputParameters;
-  }
-
-  if (property == 'outputParameters') {
-    return getOutputParameters;
-  }
-}

package/lib/camunda-platform/features/modeling/behavior/DeleteErrorEventDefinitionBehavior.js

@@ -1,5 +1,3 @@
-import inherits from 'inherits';
-
 import {
   getBusinessObject,
   is
@@ -11,18 +9,19 @@ const HIGH_PRIORITY = 5000;
 
 
 /**
- * Camunda BPMN specific `camunda:errorEventDefinition` behavior.
- *
- * When `camunda:type` is set to something different than `external`
- * on an element, then `camunda:errorEventDefinition` extension elements
- * shall be removed.
+ * Camunda BPMN specific camunda:ErrorEventDefinition behavior.
  */
-export default function DeleteErrorEventDefinitionBehavior(eventBus) {
-
-  CommandInterceptor.call(this, eventBus);
-
-  this.executed([ 'properties-panel.update-businessobject', 'element.updateProperties' ],
-    HIGH_PRIORITY, function(context) {
+export default class DeleteErrorEventDefinitionBehavior extends CommandInterceptor {
+  constructor(eventBus, modeling) {
+    super(eventBus);
+
+    /**
+     * Remove camunda:ErrorEventDefinitions on camunda:type set to external.
+     */
+    this.postExecute([
+      'element.updateProperties',
+      'properties-panel.update-businessobject'
+    ], HIGH_PRIORITY, function(context) {
       const {
         element,
         oldProperties,
@@ -30,52 +29,30 @@ export default function DeleteErrorEventDefinitionBehavior(eventBus) {
       } = context;
 
       const businessObject = getBusinessObject(element),
-            extensionElements = businessObject.extensionElements;
+            extensionElements = businessObject.get('extensionElements');
 
-      // (1) Check whether behavior is suitable
-      if (
-        is(element, 'camunda:ExternalCapable') &&
-        extensionElements &&
-        externalTypeChanged(oldProperties, properties)
-      ) {
+      if (is(element, 'camunda:ExternalCapable')
+        && extensionElements
+        && externalTypeChanged(oldProperties, properties)) {
 
-        // (2) Delete camunda:ErrorEventDefinition elements and save them for revert
-        context.deletedErrorEventDefinitions = extensionElements.values;
+        const values = extensionElements.get('values').filter((element) => {
+          return !is(element, 'camunda:ErrorEventDefinition');
+        });
 
-        extensionElements.values = extensionElements.values.filter(
-          element => !is(element, 'camunda:ErrorEventDefinition')
-        );
+        modeling.updateModdleProperties(element, extensionElements, { values });
       }
-
     }, true);
 
-  this.reverted([ 'properties-panel.update-businessobject', 'element.updateProperties' ],
-    HIGH_PRIORITY, function({ context }) {
-      const {
-        element,
-        deletedErrorEventDefinitions: oldExtensionElements
-      } = context;
-
-      const businessObject = getBusinessObject(element);
-
-      // Only intercept the revert, if the behavior became active
-      if (oldExtensionElements) {
-        const extensionElements = businessObject.extensionElements;
-
-        extensionElements.values = oldExtensionElements;
-      }
-    });
+  }
 }
 
-
 DeleteErrorEventDefinitionBehavior.$inject = [
-  'eventBus'
+  'eventBus',
+  'modeling'
 ];
 
-inherits(DeleteErrorEventDefinitionBehavior, CommandInterceptor);
-
 
-// helper //////////////////
+// helpers //////////
 
 function externalTypeChanged(oldProperties, updatesProperties) {
   const {

package/lib/camunda-platform/features/modeling/behavior/DeleteRetryTimeCycleBehavior.js

@@ -1,32 +1,27 @@
-import inherits from 'inherits';
-
 import {
   getBusinessObject,
   is
 } from 'bpmn-js/lib/util/ModelUtil';
 
-import {
-  find
-} from 'min-dash';
-
 import CommandInterceptor from 'diagram-js/lib/command/CommandInterceptor';
 
-const HIGH_PRIORITY = 15000;
+const HIGH_PRIORITY = 5000;
 
 
 /**
- * Camunda BPMN specific `camunda:FailedJobRetryTimeCycle` behavior.
- *
- * When `camunda:asyncAfter` or `camunda:asyncBefore` are set to false
- * on an element, then `camunda:FailedJobRetryTimeCycle` shall be removed. This ensures
- * that the BPMN diagram XML reflects the behavior of Camunda Platform engine.
+ * Camunda BPMN specific camunda:FailedJobRetryTimeCycle behavior.
  */
-export default function DeleteRetryTimeCycleBehavior(eventBus) {
-
-  CommandInterceptor.call(this, eventBus);
-
-  this.executed([ 'properties-panel.update-businessobject', 'element.updateProperties' ],
-    HIGH_PRIORITY, function(context) {
+export default class DeleteRetryTimeCycleBehavior extends CommandInterceptor {
+  constructor(eventBus, modeling) {
+    super(eventBus);
+
+    /**
+     * Remove camunda:FailedJobRetryTimeCycle if camunda:asyncAfter or camunda:asyncBefore is set to false.
+     */
+    this.postExecute([
+      'element.updateProperties',
+      'properties-panel.update-businessobject'
+    ], HIGH_PRIORITY, function(context) {
       const {
         element,
         properties
@@ -35,92 +30,55 @@ export default function DeleteRetryTimeCycleBehavior(eventBus) {
       const businessObject = getBusinessObject(element),
             extensionElements = businessObject.extensionElements;
 
-      // (1.1) Execute if...
-      if (is(element, 'camunda:AsyncCapable') && // ...asyncCapable
-        properties && // ...properties updated
-        (properties['camunda:asyncBefore'] === false || // ...update async (1)
-          properties['camunda:asyncAfter'] === false) && // ...update async (2)
-        (extensionElements && extensionElements.values.length) && // ...we have extensionElements
-        (extensionElements.values.find(ele => is(ele, 'camunda:FailedJobRetryTimeCycle'))) && // ...we have retryTimeCycle
-        !getTimerEventDefinition(element) // ...we don't have a TimerEventDefinition
+      if (
+        !is(element, 'camunda:AsyncCapable')
+        || (properties[ 'camunda:asyncBefore' ] !== false && properties[ 'camunda:asyncAfter' ] !== false)
+        || !extensionElements
+        || !extensionElements.get('values').length
+        || !extensionElements.get('values').find((value) => is(value, 'camunda:FailedJobRetryTimeCycle'))
+        || getTimerEventDefinition(element)
+        || isAsyncBefore(businessObject)
+        || isAsyncAfter(businessObject)
       ) {
-
-        // (1.2) ... but don't execute if one async is still true
-        if (isAsyncBefore(businessObject) || isAsyncAfter(businessObject)) {
-          return;
-        }
-
-        // (2) Delete the camunda:FailedJobRetryTimeCycle and save them for revert
-        context.deleteRetryCycleOldExtElements = extensionElements.values;
-
-        extensionElements.values = extensionElements.values.filter(
-          ele => !is(ele, 'camunda:FailedJobRetryTimeCycle'));
+        return;
       }
 
-    }, true);
-
-  this.reverted([ 'properties-panel.update-businessobject', 'element.updateProperties' ],
-    HIGH_PRIORITY, function({ context }) {
-      const {
-        element,
-        deleteRetryCycleOldExtElements: oldExtensionElements
-      } = context;
-
-      const businessObject = getBusinessObject(element);
+      const values = extensionElements.get('values').filter((element) => {
+        return !is(element, 'camunda:FailedJobRetryTimeCycle');
+      });
 
-      // Only intercept the revert, if the behavior became active
-      if (oldExtensionElements) {
-        const extensionElements = businessObject.extensionElements;
+      modeling.updateModdleProperties(element, extensionElements, { values });
+    }, true);
 
-        extensionElements.values = oldExtensionElements;
-      }
-    });
+  }
 }
 
-
 DeleteRetryTimeCycleBehavior.$inject = [
-  'eventBus'
+  'eventBus',
+  'modeling'
 ];
 
-inherits(DeleteRetryTimeCycleBehavior, CommandInterceptor);
 
+// helpers //////////
 
-// helper //////////////////
-
-/**
- * Returns true if the attribute 'camunda:asyncBefore' is set
- * to true.
- *
- * @param  {ModdleElement} bo
- *
- * @return {boolean} a boolean value
- */
-function isAsyncBefore(bo) {
-  return !!(bo.get('camunda:asyncBefore') || bo.get('camunda:async'));
+function isAsyncBefore(businessObject) {
+  return !!(businessObject.get('camunda:asyncBefore') || businessObject.get('camunda:async'));
 }
 
-/**
- * Returns true if the attribute 'camunda:asyncAfter' is set
- * to true.
- *
- * @param  {ModdleElement} bo
- *
- * @return {boolean} a boolean value
- */
-function isAsyncAfter(bo) {
-  return !!bo.get('camunda:asyncAfter');
+function isAsyncAfter(businessObject) {
+  return !!businessObject.get('camunda:asyncAfter');
 }
 
 function getTimerEventDefinition(element) {
   return getEventDefinition(element, 'bpmn:TimerEventDefinition');
 }
 
-function getEventDefinition(element, eventType) {
+function getEventDefinition(element, type) {
   const businessObject = getBusinessObject(element);
 
   const eventDefinitions = businessObject.get('eventDefinitions') || [];
 
-  return find(eventDefinitions, function(definition) {
-    return is(definition, eventType);
+  return eventDefinitions.find((eventDefinition) => {
+    return is(eventDefinition, type);
   });
 }

package/lib/camunda-platform/features/modeling/behavior/UpdateCamundaExclusiveBehavior.js

@@ -1,5 +1,3 @@
-import inherits from 'inherits';
-
 import {
   getBusinessObject,
   is
@@ -7,22 +5,23 @@ import {
 
 import CommandInterceptor from 'diagram-js/lib/command/CommandInterceptor';
 
-const HIGH_PRIORITY = 15000;
+const HIGH_PRIORITY = 5000;
 
 
 /**
- * Camunda BPMN specific `camunda:exclusive` behavior.
- *
- * When `camunda:asyncAfter` or `camunda:asyncBefore` are set to false
- * on an element, then `camunda:exclusive` shall be set to true. This ensures
- * that the BPMN diagram XML reflects the behavior of Camunda Platform engine.
+ * Camunda BPMN specific camunda:exclusive behavior.
  */
-export default function UpdateCamundaExclusiveBehavior(eventBus) {
-
-  CommandInterceptor.call(this, eventBus);
-
-  this.preExecute([ 'properties-panel.update-businessobject', 'element.updateProperties' ],
-    HIGH_PRIORITY, function(context) {
+export default class UpdateCamundaExclusiveBehavior extends CommandInterceptor {
+  constructor(eventBus) {
+    super(eventBus);
+
+    /**
+     * Set camunda:exclusive to true on camunda:asyncBefore or camunda:asyncAfter set to false.
+     */
+    this.preExecute([
+      'element.updateProperties',
+      'properties-panel.update-businessobject'
+    ], HIGH_PRIORITY, function(context) {
       const {
         element,
         properties
@@ -30,70 +29,37 @@ export default function UpdateCamundaExclusiveBehavior(eventBus) {
 
       const businessObject = getBusinessObject(element);
 
-      // (1.1) Execute if...
-      if (is(element, 'camunda:AsyncCapable') && // ...asyncCapable
-          properties && // ...properties updated
-          (properties['camunda:asyncBefore'] === false || // ...update async before or (1)
-            properties['camunda:asyncAfter'] === false) && // ...update async after (2)
-          !isExclusive(businessObject) // ...is currently not exclusive
+      if (!is(element, 'camunda:AsyncCapable')
+        || (properties[ 'camunda:asyncBefore' ] !== false && properties[ 'camunda:asyncAfter' ] !== false)
+        || isExclusive(businessObject)
+        || (isAsyncAfter(businessObject) && properties[ 'camunda:asyncAfter' ] !== false)
+        || (isAsyncBefore(businessObject) && properties[ 'camunda:asyncBefore' ] !== false)
+        || (properties[ 'camunda:asyncBefore' ] === true || properties[ 'camunda:asyncAfter' ] === true)
       ) {
-
-        // (1.2) ...but don't execute if...
-        if ((isAsyncAfter(businessObject) && properties['camunda:asyncAfter'] !== false) || // ...asyncAfter will stay
-            (isAsyncBefore(businessObject) && properties['camunda:asyncBefore'] !== false) || // ...asyncBefore will stay
-            (properties['camunda:asyncBefore'] || properties['camunda:asyncAfter']) // one is set to true
-        ) {
-          return;
-        }
-
-        // (2) Update the context
-        properties['camunda:exclusive'] = true;
+        return;
       }
+
+      properties[ 'camunda:exclusive' ] = true;
     }, true);
-}
 
+  }
+}
 
 UpdateCamundaExclusiveBehavior.$inject = [
   'eventBus'
 ];
 
-inherits(UpdateCamundaExclusiveBehavior, CommandInterceptor);
-
 
-// helper //////////////////
+// helpers //////////
 
-/**
- * Returns true if the attribute 'camunda:asyncBefore' is set
- * to true.
- *
- * @param  {ModdleElement} bo
- *
- * @return {boolean} a boolean value
- */
-function isAsyncBefore(bo) {
-  return !!(bo.get('camunda:asyncBefore') || bo.get('camunda:async'));
+function isAsyncBefore(businessObject) {
+  return !!(businessObject.get('camunda:asyncBefore') || businessObject.get('camunda:async'));
 }
 
-/**
- * Returns true if the attribute 'camunda:asyncAfter' is set
- * to true.
- *
- * @param  {ModdleElement} bo
- *
- * @return {boolean} a boolean value
- */
-function isAsyncAfter(bo) {
-  return !!bo.get('camunda:asyncAfter');
+function isAsyncAfter(businessObject) {
+  return !!businessObject.get('camunda:asyncAfter');
 }
 
-/**
-* Returns true if the attribute 'camunda:exclusive' is set
-* to true.
-*
-* @param  {ModdleElement} bo
-*
-* @return {boolean} a boolean value
-*/
-function isExclusive(bo) {
-  return !!bo.get('camunda:exclusive');
+function isExclusive(businessObject) {
+  return !!businessObject.get('camunda:exclusive');
 }