camunda-bpmn-js 0.12.1 → 0.13.0-alpha.2

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

@@ -5,7 +5,7 @@ import {
 
 import { isAny } from 'bpmn-js/lib/features/modeling/util/ModelingUtil';
 
-import elementHelper from 'bpmn-js-properties-panel/lib/helper/ElementHelper';
+import { createElement } from './ElementHelper';
 
 import { isZeebeServiceTask } from './ZeebeServiceTaskHelper';
 
@@ -133,10 +133,6 @@ export function areOutputParametersSupported(element) {
   ]);
 }
 
-export function createElement(type, parent, factory, properties) {
-  return elementHelper.createElement(type, properties, parent, factory);
-}
-
 export function createIoMapping(parent, bpmnFactory, properties) {
-  return createElement('zeebe:IoMapping', parent, bpmnFactory, properties);
+  return createElement('zeebe:IoMapping', properties, parent, bpmnFactory);
 }

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

@@ -0,0 +1,10 @@
+import Ids from 'ids';
+
+/**
+ * generate a semantic id with given prefix
+ */
+export function nextId(prefix) {
+  const ids = new Ids([ 32,32,1 ]);
+
+  return ids.nextPrefixed(prefix);
+}

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

@@ -1,24 +1,41 @@
 import {
+  getBusinessObject,
   is
 } from 'bpmn-js/lib/util/ModelUtil';
 
-import eventDefinitionHelper from 'bpmn-js-properties-panel/lib/helper/EventDefinitionHelper';
+import { forEach } from 'min-dash';
 
 
 export function isZeebeServiceTask(element) {
   if (!is(element, 'zeebe:ZeebeServiceTask')) return false;
 
   if (is(element, 'bpmn:EndEvent') || is(element, 'bpmn:IntermediateThrowEvent')) {
-    return !!eventDefinitionHelper.getMessageEventDefinition(element);
+    return !!getMessageEventDefinition(element);
   }
 
   return true;
 }
 
 export function isMessageEndEvent(element) {
-  return is(element, 'bpmn:EndEvent') && !!eventDefinitionHelper.getMessageEventDefinition(element);
+  return is(element, 'bpmn:EndEvent') && !!getMessageEventDefinition(element);
 }
 
 export function isMessageThrowEvent(element) {
-  return is(element, 'bpmn:IntermediateThrowEvent') && !!eventDefinitionHelper.getMessageEventDefinition(element);
-}
+  return is(element, 'bpmn:IntermediateThrowEvent') && !!getMessageEventDefinition(element);
+}
+
+function getMessageEventDefinition(element) {
+
+  var bo = getBusinessObject(element),
+      eventDefinition = null;
+
+  if (bo.eventDefinitions) {
+    forEach(bo.eventDefinitions, function(event) {
+      if (is(event, 'bpmn:MessageEventDefinition')) {
+        eventDefinition = event;
+      }
+    });
+  }
+
+  return eventDefinition;
+}

package/lib/camunda-platform/Modeler.js

@@ -4,12 +4,15 @@ import BaseModeler from '../base/Modeler';
 
 import modelingModule from './features/modeling';
 
-import propertiesProviderModule from 'bpmn-js-properties-panel/lib/provider/camunda';
-
 import camundaModdle from 'camunda-bpmn-moddle/resources/camunda.json';
 
 import camundaModdleExtension from 'camunda-bpmn-moddle/lib';
 
+import {
+  CamundaPlatformPropertiesProviderModule,
+  ElementTemplatesPropertiesProviderModule
+} from 'bpmn-js-properties-panel';
+
 
 /**
  *
@@ -33,7 +36,8 @@ inherits(Modeler, BaseModeler);
 Modeler.prototype._camundaPlatformModules = [
   camundaModdleExtension,
   modelingModule,
-  propertiesProviderModule
+  CamundaPlatformPropertiesProviderModule,
+  ElementTemplatesPropertiesProviderModule
 ];
 
 Modeler.prototype._modules = [].concat(

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

@@ -1,45 +1,47 @@
+import CommandInterceptor from 'diagram-js/lib/command/CommandInterceptor';
+
 import {
   getBusinessObject,
   is
 } from 'bpmn-js/lib/util/ModelUtil';
 
-import CommandInterceptor from 'diagram-js/lib/command/CommandInterceptor';
+import {
+  getExtensionElementsList,
+  removeExtensionElements
+} from '../../../../util/ExtensionElementsUtil';
 
 const HIGH_PRIORITY = 5000;
 
 
 /**
- * Camunda BPMN specific camunda:ErrorEventDefinition behavior.
+ * Camunda BPMN specific behavior ensuring camunda:ErrorEventDefinition extension elements are removed
+ * if type of e.g. bpmn:ServiceTask is set to something other than external.
  */
 export default class DeleteErrorEventDefinitionBehavior extends CommandInterceptor {
-  constructor(eventBus, modeling) {
+  constructor(commandStack, eventBus) {
     super(eventBus);
 
-    /**
-     * Remove camunda:ErrorEventDefinitions on camunda:type set to external.
-     */
     this.postExecute([
       'element.updateProperties',
-      'properties-panel.update-businessobject'
+      'element.updateModdleProperties'
     ], HIGH_PRIORITY, function(context) {
       const {
         element,
-        oldProperties,
+        moddleElement,
         properties
       } = context;
 
-      const businessObject = getBusinessObject(element),
-            extensionElements = businessObject.get('extensionElements');
+      const businessObject = moddleElement || getBusinessObject(element);
 
       if (is(element, 'camunda:ExternalCapable')
-        && extensionElements
-        && externalTypeChanged(oldProperties, properties)) {
-
-        const values = extensionElements.get('values').filter((element) => {
-          return !is(element, 'camunda:ErrorEventDefinition');
-        });
-
-        modeling.updateModdleProperties(element, extensionElements, { values });
+        && is(businessObject, 'camunda:ExternalCapable')
+        && properties[ 'camunda:type' ] !== 'external'
+      ) {
+        const errorEventDefinitions = getExtensionElementsList(businessObject, 'camunda:ErrorEventDefinition');
+
+        if (errorEventDefinitions.length) {
+          removeExtensionElements(element, businessObject, errorEventDefinitions, commandStack);
+        }
       }
     }, true);
 
@@ -47,21 +49,6 @@ export default class DeleteErrorEventDefinitionBehavior extends CommandIntercept
 }
 
 DeleteErrorEventDefinitionBehavior.$inject = [
-  'eventBus',
-  'modeling'
-];
-
-
-// helpers //////////
-
-function externalTypeChanged(oldProperties, updatesProperties) {
-  const {
-    'camunda:type': oldType
-  } = oldProperties;
-
-  const {
-    'camunda:type': newType
-  } = updatesProperties;
-
-  return oldType === 'external' && newType !== 'external';
-}
+  'commandStack',
+  'eventBus'
+];

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

@@ -5,37 +5,45 @@ import {
 
 import CommandInterceptor from 'diagram-js/lib/command/CommandInterceptor';
 
+import {
+  getExtensionElementsList,
+  removeExtensionElements
+} from '../../../../util/ExtensionElementsUtil';
+
 const HIGH_PRIORITY = 5000;
 
 
 /**
- * Camunda BPMN specific camunda:FailedJobRetryTimeCycle behavior.
+ * Camunda BPMN specific behavior ensuring camunda:FailedJobRetryTimeCycle is
+ * removed when both camunda:asyncAfter and camunda:asyncBefore set to false.
+ * Doesn't apply if element has bpmn:TimerEventDefinition.
  */
 export default class DeleteRetryTimeCycleBehavior extends CommandInterceptor {
-  constructor(eventBus, modeling) {
+  constructor(commandStack, eventBus) {
     super(eventBus);
 
-    /**
-     * Remove camunda:FailedJobRetryTimeCycle if camunda:asyncAfter or camunda:asyncBefore is set to false.
-     */
     this.postExecute([
       'element.updateProperties',
-      'properties-panel.update-businessobject'
+      'element.updateModdleProperties'
     ], HIGH_PRIORITY, function(context) {
       const {
         element,
-        properties
+        moddleElement,
+        properties = {}
       } = context;
 
-      const businessObject = getBusinessObject(element),
-            extensionElements = businessObject.extensionElements;
+      const asyncAfter = properties[ 'camunda:asyncAfter' ],
+            asyncBefore = properties[ 'camunda:asyncBefore' ];
+
+      const businessObject = moddleElement || getBusinessObject(element);
+
+      const failedJobRetryTimeCycle = getFailedJobRetryTimeCycle(element);
 
       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'))
+        || !is(businessObject, 'camunda:AsyncCapable')
+        || (asyncAfter !== false && asyncBefore !== false)
+        || !failedJobRetryTimeCycle
         || getTimerEventDefinition(element)
         || isAsyncBefore(businessObject)
         || isAsyncAfter(businessObject)
@@ -43,19 +51,15 @@ export default class DeleteRetryTimeCycleBehavior extends CommandInterceptor {
         return;
       }
 
-      const values = extensionElements.get('values').filter((element) => {
-        return !is(element, 'camunda:FailedJobRetryTimeCycle');
-      });
-
-      modeling.updateModdleProperties(element, extensionElements, { values });
+      removeExtensionElements(element, businessObject, failedJobRetryTimeCycle, commandStack);
     }, true);
 
   }
 }
 
 DeleteRetryTimeCycleBehavior.$inject = [
-  'eventBus',
-  'modeling'
+  'commandStack',
+  'eventBus'
 ];
 
 
@@ -69,6 +73,10 @@ function isAsyncAfter(businessObject) {
   return !!businessObject.get('camunda:asyncAfter');
 }
 
+function getFailedJobRetryTimeCycle(element) {
+  return getExtensionElementsList(element, 'camunda:FailedJobRetryTimeCycle')[ 0 ];
+}
+
 function getTimerEventDefinition(element) {
   return getEventDefinition(element, 'bpmn:TimerEventDefinition');
 }
@@ -76,7 +84,11 @@ function getTimerEventDefinition(element) {
 function getEventDefinition(element, type) {
   const businessObject = getBusinessObject(element);
 
-  const eventDefinitions = businessObject.get('eventDefinitions') || [];
+  const eventDefinitions = businessObject.get('eventDefinitions');
+
+  if (!eventDefinitions || !eventDefinitions.length) {
+    return;
+  }
 
   return eventDefinitions.find((eventDefinition) => {
     return is(eventDefinition, type);

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

@@ -9,32 +9,35 @@ const HIGH_PRIORITY = 5000;
 
 
 /**
- * Camunda BPMN specific camunda:exclusive behavior.
+ * Camunda BPMN specific behavior ensuring camunda:exclusive is set to true if
+ * camunda:asyncBefore or camunda:asyncAfter is set to false.
  */
 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'
+      'element.updateModdleProperties',
     ], HIGH_PRIORITY, function(context) {
       const {
         element,
-        properties
+        moddleElement,
+        properties = {}
       } = context;
 
-      const businessObject = getBusinessObject(element);
+      const businessObject = moddleElement || getBusinessObject(element);
+
+      const asyncAfter = properties[ 'camunda:asyncAfter' ],
+            asyncBefore = properties[ 'camunda:asyncBefore' ];
 
       if (!is(element, 'camunda:AsyncCapable')
-        || (properties[ 'camunda:asyncBefore' ] !== false && properties[ 'camunda:asyncAfter' ] !== false)
+        || !is(businessObject, 'camunda:AsyncCapable')
+        || (asyncAfter !== false && asyncBefore !== false)
         || isExclusive(businessObject)
-        || (isAsyncAfter(businessObject) && properties[ 'camunda:asyncAfter' ] !== false)
-        || (isAsyncBefore(businessObject) && properties[ 'camunda:asyncBefore' ] !== false)
-        || (properties[ 'camunda:asyncBefore' ] === true || properties[ 'camunda:asyncAfter' ] === true)
+        || (isAsyncAfter(businessObject) && asyncAfter !== false)
+        || (isAsyncBefore(businessObject) && asyncBefore !== false)
+        || (asyncAfter === true || asyncBefore === true)
       ) {
         return;
       }

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

@@ -1,54 +1,44 @@
-import { getBusinessObject } from 'bpmn-js/lib/util/ModelUtil';
+import {
+  getBusinessObject,
+  is
+} from 'bpmn-js/lib/util/ModelUtil';
+
+import { isInputOutputEmpty } from '../../../helper/InputOutputHelper';
 
 import {
-  getInputOutput,
-  isInputOutputEmpty
-} from '../../../helper/InputOutputHelper';
+  removeExtensionElements
+} from '../../../../util/ExtensionElementsUtil';
 
 import CommandInterceptor from 'diagram-js/lib/command/CommandInterceptor';
 
+const LOW_PRIORITY = 250;
+
+
 /**
- * Camunda BPMN specific camunda:InputOutput behavior.
+ * Camunda BPMN specific behavior ensuring empty camunda:InputOutput is removed.
  */
 export default class UpdateInputOutputBehavior extends CommandInterceptor {
-  constructor(eventBus, modeling) {
+  constructor(commandStack, eventBus) {
     super(eventBus);
 
-    /**
-     * Remove empty camunda:InputOutput on update.
-     */
-    this.postExecute([
-      'element.updateProperties',
-      'element.updateModdleProperties',
-      'properties-panel.update-businessobject-list'
-    ], function(context) {
+    this.postExecuted('element.updateModdleProperties', LOW_PRIORITY, function(context) {
       const {
         element,
-        oldProperties,
-        propertyName
+        moddleElement
       } = context;
 
-      const businessObject = getBusinessObject(element),
-            inputOutput = getInputOutput(businessObject),
-            extensionElements = businessObject.get('extensionElements');
-
-      // do not remove newly added camunda:InputOutput
-      if (!oldProperties && propertyName === 'values') {
+      if (!is(moddleElement, 'camunda:InputOutput')) {
         return;
       }
 
-      if (inputOutput && isInputOutputEmpty(inputOutput)) {
-        const values = extensionElements.get('values').filter(function(element) {
-          return element !== inputOutput;
-        });
-
-        modeling.updateModdleProperties(element, extensionElements, { values });
+      if (isInputOutputEmpty(moddleElement)) {
+        removeExtensionElements(element, getBusinessObject(element), moddleElement, commandStack);
       }
     }, true);
   }
 }
 
 UpdateInputOutputBehavior.$inject = [
-  'eventBus',
-  'modeling'
+  'commandStack',
+  'eventBus'
 ];

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

@@ -1,37 +1,42 @@
-import { is } from 'bpmn-js/lib/util/ModelUtil';
-
-import { has } from 'min-dash';
+import {
+  getBusinessObject,
+  is
+} from 'bpmn-js/lib/util/ModelUtil';
 
 import CommandInterceptor from 'diagram-js/lib/command/CommandInterceptor';
 
+import { has } from 'min-dash';
+
 const HIGH_PRIORITY = 5000;
 
 
 /**
- * Camunda BPMN specific camunda:resultVariable behavior.
+ * Camunda BPMN specific camunda:resultVariable behavior ensuring
+ * camunda:mapDecisionResult is removed when camunda:resultVariable is removed.
  */
 export default class UpdateResultVariableBehavior extends CommandInterceptor {
   constructor(eventBus) {
     super(eventBus);
 
-    /**
-     * Remove camunda:mapDecisionResult on camunda:resultVariable removed.
-     */
     this.preExecute([
       'element.updateProperties',
-      'properties-panel.update-businessobject'
+      'element.updateModdleProperties'
     ], HIGH_PRIORITY, function(context) {
       const {
         element,
+        moddleElement,
         properties
       } = context;
 
+      const businessObject = moddleElement || getBusinessObject(element);
+
       if (
         is(element, 'camunda:DmnCapable')
+        && is(businessObject, 'camunda:DmnCapable')
         && has(properties, 'camunda:resultVariable')
         && isEmpty(properties[ 'camunda:resultVariable' ])
       ) {
-        properties[ 'camunda:mapDecisionResult' ] = null;
+        properties[ 'camunda:mapDecisionResult' ] = undefined;
       }
     }, true);
 
@@ -42,10 +47,8 @@ UpdateResultVariableBehavior.$inject = [
   'eventBus'
 ];
 
-
 // helpers //////////
 
 function isEmpty(value) {
   return value == undefined || value === '';
-}
-
+}

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

@@ -1,3 +1,5 @@
+import { getBusinessObject } from 'bpmn-js/lib/util/ModelUtil';
+
 import CommandInterceptor from 'diagram-js/lib/command/CommandInterceptor';
 
 import {
@@ -21,16 +23,15 @@ export default class UserTaskFormsBehavior extends CommandInterceptor {
      */
     this.preExecute([
       'element.updateProperties',
-      'element.updateModdleProperties',
-      'properties-panel.update-businessobject'
+      'element.updateModdleProperties'
     ], function(context) {
-      const { properties } = context;
+      const {
+        element,
+        moddleElement,
+        properties
+      } = context;
 
-      const businessObject = (
-        context.moddleElement ||
-        context.businessObject ||
-        context.element.businessObject
-      );
+      const businessObject = moddleElement || getBusinessObject(element);
 
       if (has(properties, 'camunda:formKey')) {
         Object.assign(properties, {

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

@@ -2,6 +2,8 @@ import CommandInterceptor from 'diagram-js/lib/command/CommandInterceptor';
 
 import { getBusinessObject, is } from 'bpmn-js/lib/util/ModelUtil';
 
+import { has } from 'min-dash';
+
 
 /**
  * Camunda BPMN specific user task generated forms behavior.
@@ -14,19 +16,17 @@ export default class UserTaskFormsBehavior extends CommandInterceptor {
   constructor(eventBus, modeling) {
     super(eventBus);
 
-    this.preExecute([
-      'element.updateModdleProperties',
-      'properties-panel.update-businessobject'
-    ], function(context) {
-      let {
-        businessObject,
+    /**
+     * Remove camunda:FormField#values if camunda:FormField#type is changed to
+     * something other than enum.
+     */
+    this.preExecute('element.updateModdleProperties', function(context) {
+      const {
         moddleElement,
         properties
       } = context;
 
-      businessObject = businessObject || moddleElement;
-
-      if (!is(businessObject, 'camunda:FormField')) {
+      if (!is(moddleElement, 'camunda:FormField')) {
         return;
       }
 
@@ -35,59 +35,58 @@ export default class UserTaskFormsBehavior extends CommandInterceptor {
       }
     }, true);
 
-    this.preExecute([
-      'element.updateModdleProperties',
-      'properties-panel.update-businessobject'
-    ], function(context) {
-      let {
-        businessObject,
+    /**
+     * Update camunda:FormData#businessKey if camunda:FormField#id is changed.
+     */
+    this.preExecute('element.updateModdleProperties', function(context) {
+      const {
         element,
         moddleElement,
         properties
       } = context;
 
-      businessObject = businessObject || moddleElement;
-
-      if (!is(businessObject, 'camunda:FormField')) {
+      if (!is(moddleElement, 'camunda:FormField') || !has(properties, 'camunda:id')) {
         return;
       }
 
       const formData = getFormData(element);
 
-      if ('camunda:id' in properties && isBusinessKey(businessObject, formData)) {
+      if (isBusinessKey(moddleElement, formData)) {
         modeling.updateModdleProperties(element, formData, {
           'camunda:businessKey': properties[ 'camunda:id' ]
         });
       }
     }, true);
 
-    this.postExecute('properties-panel.update-businessobject-list', function(context) {
+    /**
+     * Remove camunda:FormData#businessKey if camunda:FormField is removed.
+     */
+    this.postExecute('element.updateModdleProperties', function(context) {
       const {
-        currentObject: businessObject,
         element,
-        propertyName,
-        objectsToRemove = []
+        moddleElement,
+        properties
       } = context;
 
-      if (!is(businessObject, 'camunda:FormData')
-        || propertyName !== 'fields'
-        || !objectsToRemove.length) {
+      if (!is(moddleElement, 'camunda:FormData') || !has(properties, 'fields')) {
         return;
       }
 
-      const businessKey = businessObject.get('camunda:businessKey');
+      const businessKey = moddleElement.get('camunda:businessKey');
 
       if (!businessKey) {
         return;
       }
 
-      objectsToRemove.forEach((object) => {
-        if (is(object, 'camunda:FormField') && object.get('camunda:id') === businessKey) {
-          modeling.updateModdleProperties(element, businessObject, {
-            'camunda:businessKey': undefined
-          });
-        }
+      const fieldWithBusinessKey = moddleElement.get('fields').find(field => {
+        return field.get('camunda:id') === businessKey;
       });
+
+      if (!fieldWithBusinessKey) {
+        modeling.updateModdleProperties(element, moddleElement, {
+          'camunda:businessKey': undefined
+        });
+      }
     }, true);
   }
 }