@jylups/cmmn-js 0.0.0-stage → 0.21.0

package/lib/features/modeling/behavior/index.js

@@ -0,0 +1,24 @@
+module.exports = {
+  __init__: [
+    'attachCriterionBehavior',
+    'caseFileItemUpdater',
+    'labelBehavior',
+    'planItemDefinitionUpdater',
+    'planningTableUpdater',
+    'replaceConnectionBehavior',
+    'replaceElementBehavior',
+    'resizeCasePlanModelBehavior',
+    'sentryUpdater',
+    'unclaimIdBehavior'
+  ],
+  attachCriterionBehavior: [ 'type', require('./AttachCriterionBehavior') ],
+  caseFileItemUpdater: [ 'type', require('./CaseFileItemUpdater') ],
+  labelBehavior: [ 'type', require('./LabelBehavior') ],
+  planItemDefinitionUpdater: [ 'type', require('./PlanItemDefinitionUpdater') ],
+  planningTableUpdater: [ 'type', require('./PlanningTableUpdater') ],
+  replaceConnectionBehavior: [ 'type', require('./ReplaceConnectionBehavior') ],
+  replaceElementBehavior: [ 'type', require('./ReplaceElementBehavior') ],
+  resizeCasePlanModelBehavior: [ 'type', require('./ResizeCasePlanModelBehavior') ],
+  sentryUpdater: [ 'type', require('./SentryUpdater') ],
+  unclaimIdBehavior: [ 'type', require('./UnclaimIdBehavior') ]
+};

package/lib/features/modeling/cmd/AppendShapeHandler.js

@@ -0,0 +1,52 @@
+'use strict';
+
+var inherits = require('inherits');
+
+var is = require('../../../util/ModelUtil').is;
+
+var BaseHandler = require('diagram-js/lib/features/modeling/cmd/AppendShapeHandler').default;
+
+
+function AppendShapeHandler(modeling, cmmnRules) {
+  this._modeling = modeling;
+  this._cmmnRules = cmmnRules;
+}
+
+inherits(AppendShapeHandler, BaseHandler);
+
+
+AppendShapeHandler.$inject = [ 'modeling', 'cmmnRules' ];
+
+module.exports = AppendShapeHandler;
+
+
+// api /////////////////
+
+AppendShapeHandler.prototype.preExecute = function(context) {
+
+  if (!context.source) {
+    throw new Error('source required');
+  }
+
+  var cmmnRules = this._cmmnRules;
+
+  var shape = context.shape,
+      source = context.source,
+      parent = context.target || context.source.parent,
+      position = context.position,
+      isAttach = context.attach;
+
+  if (isCriterion(shape)) {
+    isAttach = cmmnRules.canAttach(shape, parent, source, position) === 'attach';
+  }
+
+  context.shape = this._modeling.createShape(shape, position, parent, {
+    attach: isAttach,
+    nested: true
+  });
+
+};
+
+function isCriterion(element) {
+  return is(element, 'cmmn:Criterion');
+}

package/lib/features/modeling/cmd/IdClaimHandler.js

@@ -0,0 +1,38 @@
+'use strict';
+
+
+function IdClaimHandler(moddle) {
+  this._moddle = moddle;
+}
+
+IdClaimHandler.$inject = [ 'moddle' ];
+
+module.exports = IdClaimHandler;
+
+
+IdClaimHandler.prototype.execute = function(context) {
+  var ids = this._moddle.ids,
+      id = context.id,
+      element = context.element,
+      claiming = context.claiming;
+
+  if (claiming) {
+    ids.claim(id, element);
+  } else {
+    ids.unclaim(id);
+  }
+};
+
+
+IdClaimHandler.prototype.revert = function(context) {
+  var ids = this._moddle.ids,
+      id = context.id,
+      element = context.element,
+      claiming = context.claiming;
+
+  if (claiming) {
+    ids.unclaim(id);
+  } else {
+    ids.claim(id, element);
+  }
+};

package/lib/features/modeling/cmd/ReconnectConnectionHandler.js

@@ -0,0 +1,57 @@
+'use strict';
+
+var inherits = require('inherits');
+
+var isArray = require('min-dash').isArray;
+
+var BaseHandler = require('diagram-js/lib/features/modeling/cmd/ReconnectConnectionHandler').default;
+
+/**
+ * Overwrites the behavior of diagram-js/ReconnectConnectionHandler to enable
+ * a switch between source and target of a connection on reconnect.
+ */
+function ReconnectConnectionHandler(injector) {
+  injector.invoke(BaseHandler, this);
+}
+
+inherits(ReconnectConnectionHandler, BaseHandler);
+
+ReconnectConnectionHandler.$inject = [ 'injector' ];
+
+module.exports = ReconnectConnectionHandler;
+
+
+ReconnectConnectionHandler.prototype.execute = function(context) {
+
+  var newSource = context.newSource,
+      newTarget = context.newTarget,
+      connection = context.connection,
+      dockingOrPoints = context.dockingOrPoints;
+
+  if (!newSource && !newTarget) {
+    throw new Error('newSource or newTarget are required');
+  }
+
+  // removed from corresponding method in diagram-js@3.3.0
+
+  // if (newSource && newTarget) {
+  //   throw new Error('must specify either newSource or newTarget');
+  // }
+
+  if (isArray(dockingOrPoints)) {
+    context.oldWaypoints = connection.waypoints;
+    connection.waypoints = dockingOrPoints;
+  }
+
+  if (newSource) {
+    context.oldSource = connection.source;
+    connection.source = newSource;
+  }
+
+  if (newTarget) {
+    context.oldTarget = connection.target;
+    connection.target = newTarget;
+  }
+
+  return connection;
+};

package/lib/features/modeling/cmd/ReplaceShapeHandler.js

@@ -0,0 +1,46 @@
+'use strict';
+
+var inherits = require('inherits');
+
+var BaseHandler = require('diagram-js/lib/features/modeling/cmd/ReplaceShapeHandler').default;
+
+
+function ReplaceShapeHandler(modeling, rules) {
+  this._modeling = modeling;
+  this._rules = rules;
+}
+
+inherits(ReplaceShapeHandler, BaseHandler);
+
+ReplaceShapeHandler.$inject = [ 'modeling', 'rules' ];
+
+module.exports = ReplaceShapeHandler;
+
+
+// api /////////////////
+
+
+ReplaceShapeHandler.prototype.createShape = function(shape, position, target) {
+  var modeling = this._modeling;
+  return modeling.createShape(shape, position, target, {
+    nested: true
+  });
+};
+
+
+ReplaceShapeHandler.prototype.reconnectStart = function(connection, newSource, dockingPoint) {
+  var modeling = this._modeling;
+  modeling.reconnectStart(connection, newSource, dockingPoint, {
+    nested: true,
+    startChanged: true
+  });
+};
+
+
+ReplaceShapeHandler.prototype.reconnectEnd = function(connection, newTarget, dockingPoint) {
+  var modeling = this._modeling;
+  modeling.reconnectEnd(connection, newTarget, dockingPoint, {
+    nested: true,
+    endChanged: true
+  });
+};

package/lib/features/modeling/cmd/UpdateControlsHandler.js

@@ -0,0 +1,221 @@
+'use strict';
+
+var filter = require('min-dash').filter,
+    forEach = require('min-dash').forEach;
+
+var getBusinessObject = require('../../../util/ModelUtil').getBusinessObject,
+    getItemControl = require('../../../util/ModelUtil').getItemControl,
+    getDefaultControl = require('../../../util/ModelUtil').getDefaultControl,
+    getDefinition = require('../../../util/ModelUtil').getDefinition,
+    hasPlanningTable = require('../../../util/ModelUtil').hasPlanningTable;
+
+var isPlanningTableCapable = require('../util/PlanItemDefinitionUtil').isPlanningTableCapable;
+
+
+function UpdateControlsHandler(itemRegistry, modeling, cmmnReplace, cmmnFactory) {
+  this._itemRegistry = itemRegistry;
+  this._modeling = modeling;
+  this._cmmnReplace = cmmnReplace;
+  this._cmmnFactory = cmmnFactory;
+}
+
+UpdateControlsHandler.$inject = [ 'itemRegistry', 'modeling', 'cmmnReplace', 'cmmnFactory' ];
+
+module.exports = UpdateControlsHandler;
+
+
+var PLAN_ITEM_CONTROL_PROPS = [
+  'requiredRule',
+  'repetitionRule',
+  'manualActivationRule'
+];
+
+function getUpdate(key, value) {
+  var update = {};
+  update[key] = value;
+  return update;
+}
+
+
+UpdateControlsHandler.prototype.preExecute = function(context) {
+
+  var self = this;
+
+  var element = context.element,
+      values = context.values;
+
+  if (!element) {
+    throw new Error('element required');
+  }
+
+  forEach(values, function(value, key) {
+
+    if (PLAN_ITEM_CONTROL_PROPS.indexOf(key) !== -1) {
+      self._updateRule(element, key, value);
+    }
+    else {
+      self._updateDecorator(element, key, value);
+    }
+
+  });
+
+};
+
+
+UpdateControlsHandler.prototype.execute = function() {};
+
+UpdateControlsHandler.prototype.revert = function() {};
+
+
+// API ////////////////////////////////////////////////
+
+
+UpdateControlsHandler.prototype._updateDecorator = function(element, key, value) {
+
+  var self = this,
+      modeling = self._modeling;
+
+  var definition = getDefinition(element),
+      update = getUpdate(key, value),
+      changed = [];
+
+  if (definition[key] !== value) {
+
+    changed = self._getReferencingShapes(definition);
+
+    if (changed.length > 1 && canReplaceDefinition(definition)) {
+      definition = self._replaceDefinition(element);
+      changed = element;
+    }
+
+    modeling.updateProperties(definition, update, changed);
+
+  }
+
+};
+
+
+UpdateControlsHandler.prototype._updateRule = function(element, rule, value) {
+
+  var self = this,
+      modeling = self._modeling,
+      cmmnFactory = self._cmmnFactory;
+
+  var itemControl = getItemControl(element),
+      defaultControl = getDefaultControl(element),
+      definition = getDefinition(element),
+      update = getUpdate(rule, value);
+
+
+  !value ? deleteRule() : setRule();
+
+
+  function deleteRule() {
+
+    var oldValue;
+
+    if (isRulePresent(itemControl, rule)) {
+      oldValue = itemControl[rule];
+      modeling.updateProperties(itemControl, update, element);
+      modeling.updateSemanticParent(oldValue);
+
+      if (canDeletePlanItemControl(itemControl)) {
+        modeling.updateProperties(element, { itemControl: undefined });
+        modeling.updateSemanticParent(itemControl);
+      }
+
+    }
+
+    if (isRulePresent(defaultControl, rule)) {
+      oldValue = defaultControl[rule];
+
+      var changed = self._getReferencingShapes(definition);
+
+      if (changed.length > 1 && canReplaceDefinition(definition)) {
+
+        changed = filter(changed, function(elem) {
+          var localItemControl = getItemControl(elem),
+              localDefaultControl = getDefaultControl(elem);
+
+          return !isRulePresent(localItemControl, rule) &&
+                  isRulePresent(localDefaultControl, rule);
+        });
+
+        if (changed.length > 1) {
+          self._replaceDefinition(element);
+          defaultControl = getDefaultControl(element);
+          changed = element;
+        }
+
+      }
+
+      modeling.updateProperties(defaultControl, update, changed);
+      modeling.updateSemanticParent(oldValue);
+
+      if (canDeletePlanItemControl(defaultControl)) {
+        modeling.updateProperties(definition, { defaultControl: undefined }, changed);
+        modeling.updateSemanticParent(defaultControl);
+      }
+
+    }
+
+  }
+
+  function setRule() {
+
+    if (!itemControl) {
+      itemControl = createPlanItemControl();
+      modeling.updateProperties(element, { itemControl: itemControl });
+      modeling.updateSemanticParent(itemControl, getBusinessObject(element));
+    }
+
+    modeling.updateProperties(itemControl, update, element);
+    modeling.updateSemanticParent(value, itemControl);
+  }
+
+  function isRulePresent(control, rule) {
+    return control && control[rule];
+  }
+
+  function createPlanItemControl() {
+    return cmmnFactory.create('cmmn:PlanItemControl');
+  }
+
+  function canDeletePlanItemControl(control) {
+    return !!(control && !control.repetitionRule && !control.requiredRule && !control.manualActivationRule);
+  }
+
+};
+
+
+UpdateControlsHandler.prototype._replaceDefinition = function(element) {
+
+  var self = this,
+      modeling = self._modeling,
+      cmmnReplace = self._cmmnReplace;
+
+  var definition = getDefinition(element);
+
+  var newDefinition = cmmnReplace.replacePlanItemDefinition(definition);
+  modeling.updateProperties(element, { definitionRef: newDefinition });
+
+  modeling.updateSemanticParent(newDefinition, definition.$parent, 'planItemDefinitions');
+
+  return newDefinition;
+
+};
+
+
+UpdateControlsHandler.prototype._getReferencingShapes = function(definition) {
+
+  var self = this,
+      itemRegistry = self._itemRegistry;
+
+  return itemRegistry.getShapes(definition);
+
+};
+
+
+function canReplaceDefinition(definition) {
+  return !(isPlanningTableCapable(definition) && hasPlanningTable(definition));
+}

package/lib/features/modeling/cmd/UpdatePropertiesHandler.js

@@ -0,0 +1,240 @@
+'use strict';
+
+var reduce = require('min-dash').reduce,
+    keys = require('min-dash').keys,
+    forEach = require('min-dash').forEach,
+    assign = require('min-dash').assign;
+
+var getBusinessObject = require('../../../util/ModelUtil').getBusinessObject;
+
+var NAME = 'name',
+    STANDARD_EVENT = 'standardEvent',
+    ID = 'id',
+    DEFINITION_REF = 'definitionRef',
+    SENTRY_REF = 'sentryRef',
+    IS_STANDARD_EVENT_VISIBLE = 'isStandardEventVisible';
+
+var flatten = require('min-dash').flatten;
+
+/**
+ * A handler that implements a CMMN 1.1 property update.
+ *
+ * This should be used to set simple properties on elements with
+ * an underlying CMMN business object.
+ *
+ * Use respective diagram-js provided handlers if you would
+ * like to perform automated modeling.
+ */
+function UpdatePropertiesHandler(elementRegistry, itemRegistry, moddle) {
+  this._elementRegistry = elementRegistry;
+  this._itemRegistry = itemRegistry;
+  this._moddle = moddle;
+}
+
+UpdatePropertiesHandler.$inject = [ 'elementRegistry', 'itemRegistry', 'moddle' ];
+
+module.exports = UpdatePropertiesHandler;
+
+
+// api /////////////////
+
+UpdatePropertiesHandler.prototype.preExecute = function(context) {
+
+  var element = context.element,
+      shape = context.shape;
+
+  if (!element) {
+    throw new Error('element required');
+  }
+
+  var bo = element.businessObject || element;
+
+  context.businessObject = bo;
+
+  var changed = [];
+
+  if (element.businessObject) {
+    changed.push(element);
+  }
+
+  if (shape) {
+    changed.push(shape);
+  }
+
+  context.changed = flatten(changed);
+};
+
+
+/**
+ * Updates a CMMN element with a list of new properties
+ *
+ * @param {Object} context
+ * @param {djs.model.Base} context.element the element to update
+ * @param {Object} context.properties a list of properties to set on the element's
+ *                                    businessObject (the CMMN model element)
+ *
+ * @return {Array<djs.mode.Base>} the updated element
+ */
+UpdatePropertiesHandler.prototype.execute = function(context) {
+
+  var elementRegistry = this._elementRegistry,
+      itemRegistry = this._itemRegistry,
+      ids = this._moddle.ids;
+
+  var changed = context.changed;
+
+  var element = context.element,
+      businessObject = context.businessObject,
+      properties = unwrapBusinessObjects(context.properties),
+      oldProperties = context.oldProperties || getProperties(businessObject, keys(properties));
+
+  if (isIdChange(properties, businessObject)) {
+    ids.unclaim(businessObject[ID]);
+
+    itemRegistry.updateId(businessObject, properties[ID]);
+
+    var shape = elementRegistry.get(element.id);
+
+    if (shape) {
+      elementRegistry.updateId(shape, properties[ID]);
+    }
+
+    ids.claim(properties[ID], businessObject);
+  }
+
+  if (isDefinitionRefChange(properties, businessObject)) {
+    itemRegistry.updateReference(businessObject, properties[DEFINITION_REF]);
+  }
+
+  if (isSentryRefChange(properties, businessObject)) {
+    itemRegistry.updateReference(businessObject, properties[SENTRY_REF]);
+  }
+
+  if (NAME in properties) {
+
+    forEach(changed, function(changedShape) {
+      if (changedShape.label) {
+        changed.push(changedShape.label);
+      }
+    });
+
+  }
+
+  if (STANDARD_EVENT in properties || IS_STANDARD_EVENT_VISIBLE in properties) {
+
+    forEach(changed, function(changedShape) {
+      if (changedShape.label) {
+        changed.push(changedShape.label);
+      }
+    });
+
+  }
+
+  // update properties
+  setProperties(businessObject, properties);
+
+  // store old values
+  context.oldProperties = oldProperties;
+
+  // indicate changed on objects affected by the update
+  return changed;
+};
+
+/**
+ * Reverts the update on a CMMN elements properties.
+ *
+ * @param  {Object} context
+ *
+ * @return {djs.mode.Base} the updated element
+ */
+UpdatePropertiesHandler.prototype.revert = function(context) {
+
+  var properties = context.properties,
+      oldProperties = context.oldProperties,
+      businessObject = context.businessObject,
+      elementRegistry = this._elementRegistry,
+      itemRegistry = this._itemRegistry,
+      ids = this._moddle.ids;
+
+  if (isIdChange(oldProperties, businessObject)) {
+    itemRegistry.updateId(businessObject, oldProperties[ID]);
+  }
+
+  if (isDefinitionRefChange(oldProperties, businessObject)) {
+    itemRegistry.updateReference(businessObject, oldProperties[DEFINITION_REF]);
+  }
+
+  if (isSentryRefChange(oldProperties, businessObject)) {
+    itemRegistry.updateReference(businessObject, oldProperties[SENTRY_REF]);
+  }
+
+  // update properties
+  setProperties(businessObject, oldProperties);
+
+  if (isIdChange(properties, businessObject)) {
+    ids.unclaim(properties[ID]);
+
+    var shape = elementRegistry.get(properties[ID]);
+
+    if (shape) {
+      elementRegistry.updateId(shape, oldProperties[ID]);
+    }
+
+    ids.claim(oldProperties[ID], businessObject);
+  }
+
+  return context.changed;
+};
+
+
+function isIdChange(properties, businessObject) {
+  return ID in properties && properties[ID] !== businessObject[ID];
+}
+
+function isDefinitionRefChange(properties, businessObject) {
+  return DEFINITION_REF in properties && properties[DEFINITION_REF] !== businessObject[DEFINITION_REF];
+}
+
+function isSentryRefChange(properties, businessObject) {
+  return SENTRY_REF in properties && properties[SENTRY_REF] !== businessObject[SENTRY_REF];
+}
+
+
+function getProperties(businessObject, propertyNames) {
+  return reduce(propertyNames, function(result, key) {
+    result[key] = businessObject.get(key);
+    return result;
+  }, {});
+}
+
+
+function setProperties(businessObject, properties) {
+  forEach(properties, function(value, key) {
+    businessObject.set(key, value);
+  });
+}
+
+
+var referencePropertyNames = [ 'default' ];
+
+/**
+ * Make sure we unwrap the actual business object
+ * behind diagram element that may have been
+ * passed as arguments.
+ *
+ * @param  {Object} properties
+ *
+ * @return {Object} unwrappedProps
+ */
+function unwrapBusinessObjects(properties) {
+
+  var unwrappedProps = assign({}, properties);
+
+  referencePropertyNames.forEach(function(name) {
+    if (name in properties) {
+      unwrappedProps[name] = getBusinessObject(unwrappedProps[name]);
+    }
+  });
+
+  return unwrappedProps;
+}