@jylups/cmmn-js 0.0.0-stage → 0.21.0

package/lib/features/replace/CmmnReplace.js

@@ -0,0 +1,355 @@
+'use strict';
+
+var ModelUtil = require('../../util/ModelUtil'),
+    is = ModelUtil.is,
+    getDefinition = ModelUtil.getDefinition,
+    isAutoComplete = ModelUtil.isAutoComplete;
+
+var isCollapsed = require('../../util/DiUtil').isCollapsed,
+    isPlanningTableCollapsed = require('../../util/DiUtil').isPlanningTableCollapsed;
+
+var isPlanningTableCapable = require('../modeling/util/PlanItemDefinitionUtil').isPlanningTableCapable;
+var isItemCapable = require('../modeling/util/PlanItemDefinitionUtil').isItemCapable;
+
+/**
+ * This module takes care of replacing CMMN elements
+ */
+function CmmnReplace(cmmnFactory, replace, selection, cmmnRules) {
+
+  /**
+   * Prepares a new business object for the replacement element
+   * and triggers the replace operation.
+   *
+   * @param  {djs.model.Base} element
+   * @param  {Object} target
+   * @param  {Object} [hints]
+   *
+   * @return {djs.model.Base} the newly created element
+   */
+  function replaceElement(element, target, hints) {
+
+    hints = hints || {};
+
+    var type = target.type,
+        oldBusinessObject = element.businessObject,
+        newBusinessObject;
+
+
+    // TODO: need also to respect min/max Size
+    var newElement = {
+      type: type
+    };
+
+    if (isCriterion(oldBusinessObject)) {
+      newBusinessObject = replaceCriterion(oldBusinessObject, type);
+    }
+
+
+    if (isItemCapable(oldBusinessObject)) {
+
+      var oldDefinition = getDefinition(oldBusinessObject),
+          definitionType = target.definitionType,
+          newDefinition = oldDefinition;
+
+
+      // replace plan item definition if necessary
+      if (oldDefinition.$type !== definitionType) {
+        newDefinition = replacePlanItemDefinition(oldDefinition, definitionType);
+      }
+
+
+      // replace plan/discretionary item
+      newBusinessObject = replaceItemCapable(oldBusinessObject, type, newDefinition);
+
+
+      // handle isCollapsed property
+      if (isPlanFragment(oldDefinition) && isPlanFragment(newDefinition) && target.isCollapsed !== false) {
+        newElement.isCollapsed = isCollapsed(oldBusinessObject);
+      }
+
+
+      // switch collapsed/expanded plan fragment
+      if (isTask(oldDefinition) && target.isCollapsed === true) {
+        newElement.isCollapsed = true;
+      }
+
+      if (isTask(newDefinition) && target.isBlocking === false) {
+        newElement.isBlocking = false;
+      }
+
+
+      // handle isPlanningTableCollapsed property
+      if (isPlanningTableCapable(oldDefinition) && isPlanningTableCapable(newDefinition)) {
+        newElement.isPlanningTableCollapsed = isPlanningTableCollapsed(oldBusinessObject);
+      }
+
+
+      // handle autoComplete property
+      if (isStage(oldDefinition) && isStage(newDefinition)) {
+        newElement.autoComplete = isAutoComplete(oldBusinessObject);
+      }
+
+
+      // TODO: need also to respect min/max Size
+      // copy size, from an expanded plan fragment to an expanded alternative plan fragment
+      // except cmmn:Task, because Task is always expanded
+      if (!isCollapsed(oldBusinessObject) && !target.isCollapsed && !isTask(oldDefinition)) {
+        newElement.width = element.width;
+        newElement.height = element.height;
+      }
+    }
+
+    // create new business object if necessary
+    newElement.businessObject = newBusinessObject || cmmnFactory.create(type);
+
+    // trigger replacement
+    newElement = replace.replaceElement(element, newElement, hints);
+
+
+    if (hints.select !== false) {
+      selection.select(newElement);
+    }
+
+    return newElement;
+  }
+
+  this.replaceElement = replaceElement;
+
+
+  function replaceCriterion(criterion, type) {
+
+    var newCriterion;
+
+    if (criterion) {
+
+      type = type || criterion.$type;
+
+      newCriterion = cmmnFactory.createCriterion(type, {
+        sentryRef: criterion.sentryRef,
+        name: criterion.name
+      });
+
+    }
+
+    return newCriterion;
+
+  }
+
+  this.replaceCriterion = replaceCriterion;
+
+
+  function replaceSentry(sentry) {
+
+    var newSentry;
+
+    if (sentry) {
+
+      newSentry = cmmnFactory.createSentry({
+        name: sentry.name
+      });
+
+      if (sentry.ifPart) {
+
+        var newIfPart = cmmnFactory.create('cmmn:IfPart');
+        setParent(newIfPart, newSentry);
+        newSentry.ifPart = newIfPart;
+
+        var condition = replaceCondition(sentry.ifPart.condition);
+        setParent(condition, newIfPart);
+        newIfPart.condition = condition;
+
+      }
+
+    }
+
+    return newSentry;
+  }
+
+  this.replaceSentry = replaceSentry;
+
+
+  function replacePlanItemDefinition(definition, type) {
+
+    type = type || definition.$type;
+
+    var newDefinition = cmmnFactory.create(type, {
+      name: definition.name
+    });
+
+    if (isPlanItemControlCapable(newDefinition) && definition.defaultControl) {
+
+      var defaultControl = replacePlanItemControl(definition.defaultControl, newDefinition);
+
+      setParent(defaultControl, newDefinition);
+      newDefinition.defaultControl = defaultControl;
+
+    }
+
+    if (isStage(newDefinition) && definition.autoComplete) {
+      newDefinition.autoComplete = definition.autoComplete;
+    }
+
+    if (isTask(definition) && isTask(newDefinition)) {
+      newDefinition.isBlocking = definition.isBlocking;
+    }
+
+    return newDefinition;
+
+  }
+
+  this.replacePlanItemDefinition = replacePlanItemDefinition;
+
+
+  function replaceItemCapable(item, type, definition) {
+
+    type = type || item.$type;
+    definition = definition || getDefinition(item);
+
+    var newItem = cmmnFactory.create(type, {
+      name: item.name,
+      definitionRef: definition
+    });
+
+    if (isPlanItemControlCapable(newItem) && item.itemControl) {
+
+      var itemControl = replacePlanItemControl(item.itemControl, newItem);
+
+      setParent(itemControl, newItem);
+      newItem.itemControl = itemControl;
+
+    }
+
+    return newItem;
+
+  }
+
+  this.replaceItemCapable = replaceItemCapable;
+
+
+  function replacePlanItemControl(control, element) {
+
+    var newControl;
+
+    if (control) {
+
+      newControl = cmmnFactory.create('cmmn:PlanItemControl');
+
+      var repetitionRule = control.repetitionRule;
+      if (repetitionRule && (!element || cmmnRules.canSetRepetitionRule(element))) {
+
+        repetitionRule = replaceRule(repetitionRule);
+
+        setParent(repetitionRule, newControl);
+        newControl.repetitionRule = repetitionRule;
+
+      }
+
+      var requiredRule = control.requiredRule;
+      if (requiredRule && (!element || cmmnRules.canSetRequiredRule(element))) {
+
+        requiredRule = replaceRule(requiredRule);
+
+        setParent(requiredRule, newControl);
+        newControl.requiredRule = requiredRule;
+
+      }
+
+      var manualActivationRule = control.manualActivationRule;
+      if (manualActivationRule && (!element || cmmnRules.canSetManualActivationRule(element))) {
+
+        manualActivationRule = replaceRule(manualActivationRule);
+
+        setParent(manualActivationRule, newControl);
+        newControl.manualActivationRule = manualActivationRule;
+
+      }
+
+    }
+
+    return newControl;
+
+  }
+
+  this.replacePlanItemControl = replacePlanItemControl;
+
+
+  function replaceRule(rule) {
+
+    var newRule;
+
+    if (rule) {
+
+      var type = rule.$type;
+
+      var condition = replaceCondition(rule.condition);
+      newRule = cmmnFactory.create(type, {
+        condition: condition
+      });
+
+      setParent(condition, newRule);
+
+    }
+
+    return newRule;
+
+  }
+
+  this.replaceRule = replaceRule;
+
+
+  function replaceCondition(condition) {
+    var newCondition;
+
+    if (condition) {
+      newCondition = cmmnFactory.create('cmmn:Expression', {
+        language: condition.language,
+        body: condition.body
+      });
+    }
+
+    return newCondition;
+  }
+
+  this.replaceCondition = replaceCondition;
+
+
+  function setParent(element, parent) {
+    if (element) {
+      element.$parent = parent;
+    }
+  }
+
+}
+
+CmmnReplace.$inject = [ 'cmmnFactory', 'replace', 'selection', 'cmmnRules' ];
+
+module.exports = CmmnReplace;
+
+function isInstanceOf(element, type) {
+  element = getDefinition(element);
+  return is(element, type);
+}
+
+function isTask(element) {
+  return isInstanceOf(element, 'cmmn:Task');
+}
+
+function isMilestone(element) {
+  return isInstanceOf(element, 'cmmn:Milestone');
+}
+
+function isPlanFragment(element) {
+  return isInstanceOf(element, 'cmmn:PlanFragment');
+}
+
+function isStage(element) {
+  return isInstanceOf(element, 'cmmn:Stage');
+}
+
+function isCriterion(element) {
+  return is(element, 'cmmn:Criterion');
+}
+
+function isPlanItemControlCapable(element) {
+  return isTask(element) || isStage(element) || isMilestone(element);
+}

package/lib/features/replace/ReplaceOptions.js

@@ -0,0 +1,241 @@
+'use strict';
+
+
+module.exports.TASK = [
+  {
+    label: 'Task',
+    actionName: 'replace-with-task-plan-item',
+    className: 'cmmn-icon-task-none',
+    target: {
+      definitionType: 'cmmn:Task',
+      type: 'cmmn:PlanItem'
+    }
+  },
+  {
+    label: 'Human Task',
+    actionName: 'replace-with-blocking-human-task-plan-item',
+    className: 'cmmn-icon-human-blocking-task',
+    target: {
+      definitionType: 'cmmn:HumanTask',
+      type: 'cmmn:PlanItem',
+      isBlocking: true
+    }
+  },
+  {
+    label: 'Human Task',
+    actionName: 'replace-with-non-blocking-human-task-plan-item',
+    className: 'cmmn-icon-human-non-blocking-task',
+    target: {
+      definitionType: 'cmmn:HumanTask',
+      type: 'cmmn:PlanItem',
+      isBlocking: false
+    }
+  },
+  {
+    label: 'Decision Task',
+    actionName: 'replace-with-decision-task-plan-item',
+    className: 'cmmn-icon-decision-task',
+    target: {
+      definitionType: 'cmmn:DecisionTask',
+      type: 'cmmn:PlanItem'
+    }
+  },
+  {
+    label: 'Process Task',
+    actionName: 'replace-with-process-task-plan-item',
+    className: 'cmmn-icon-process-task',
+    target: {
+      definitionType: 'cmmn:ProcessTask',
+      type: 'cmmn:PlanItem'
+    }
+  },
+  {
+    label: 'Case Task',
+    actionName: 'replace-with-case-task-plan-item',
+    className: 'cmmn-icon-case-task',
+    target: {
+      definitionType: 'cmmn:CaseTask',
+      type: 'cmmn:PlanItem'
+    }
+  },
+  {
+    label: 'Stage (collapsed)',
+    actionName: 'replace-with-collapsed-stage-plan-item',
+    className: 'cmmn-icon-stage-collapsed',
+    target: {
+      definitionType: 'cmmn:Stage',
+      type: 'cmmn:PlanItem',
+      isCollapsed: true
+    }
+  },
+  {
+    label: 'Stage (expanded)',
+    actionName: 'replace-with-expanded-stage-plan-item',
+    className: 'cmmn-icon-stage-expanded',
+    target: {
+      definitionType: 'cmmn:Stage',
+      type: 'cmmn:PlanItem',
+      isCollapsed: false
+    }
+  },
+  {
+    label: 'Discretionary Task',
+    actionName: 'replace-with-task-discretionary-item',
+    className: 'cmmn-icon-task-discretionary',
+    target: {
+      definitionType: 'cmmn:Task',
+      type: 'cmmn:DiscretionaryItem'
+    }
+  },
+  {
+    label: 'Discretionary Human Task',
+    actionName: 'replace-with-blocking-human-task-discretionary-item',
+    className: 'cmmn-icon-human-blocking-task-discretionary',
+    target: {
+      definitionType: 'cmmn:HumanTask',
+      type: 'cmmn:DiscretionaryItem',
+      isBlocking: true
+    }
+  },
+  {
+    label: 'Discretionary Human Task',
+    actionName: 'replace-with-non-blocking-human-task-discretionary-item',
+    className: 'cmmn-icon-human-non-blocking-task-discretionary',
+    target: {
+      definitionType: 'cmmn:HumanTask',
+      type: 'cmmn:DiscretionaryItem',
+      isBlocking: false
+    }
+  },
+  {
+    label: 'Discretionary Decision Task',
+    actionName: 'replace-with-decision-task-discretionary-item',
+    className: 'cmmn-icon-decision-task-discretionary',
+    target: {
+      definitionType: 'cmmn:DecisionTask',
+      type: 'cmmn:DiscretionaryItem'
+    }
+  },
+  {
+    label: 'Discretionary Process Task',
+    actionName: 'replace-with-process-task-discretionary-item',
+    className: 'cmmn-icon-process-task-discretionary',
+    target: {
+      definitionType: 'cmmn:ProcessTask',
+      type: 'cmmn:DiscretionaryItem'
+    }
+  },
+  {
+    label: 'Discretionary Case Task',
+    actionName: 'replace-with-case-task-discretionary-item',
+    className: 'cmmn-icon-case-task-discretionary',
+    target: {
+      definitionType: 'cmmn:CaseTask',
+      type: 'cmmn:DiscretionaryItem'
+    }
+  },
+  {
+    label: 'Discretionary Stage (collapsed)',
+    actionName: 'replace-with-collapsed-stage-discretionary-item',
+    className: 'cmmn-icon-stage-collapsed-discretionary',
+    target: {
+      definitionType: 'cmmn:Stage',
+      type: 'cmmn:DiscretionaryItem',
+      isCollapsed: true
+    }
+  },
+  {
+    label: 'Discretionary Stage (expanded)',
+    actionName: 'replace-with-expanded-stage-discretionary-item',
+    className: 'cmmn-icon-stage-expanded-discretionary',
+    target: {
+      definitionType: 'cmmn:Stage',
+      type: 'cmmn:DiscretionaryItem',
+      isCollapsed: false
+    }
+  }
+];
+
+
+module.exports.PLAN_FRAGMENT_EXPANDED = [
+  {
+    label: 'Stage',
+    actionName: 'replace-with-stage-plan-item',
+    className: 'cmmn-icon-stage-expanded',
+    target: {
+      definitionType: 'cmmn:Stage',
+      type: 'cmmn:PlanItem',
+      isCollapsed: false
+    }
+  },
+  {
+    label: 'Discretionary Stage',
+    actionName: 'replace-with-stage-discretionary-item',
+    className: 'cmmn-icon-stage-expanded-discretionary',
+    target: {
+      definitionType: 'cmmn:Stage',
+      type: 'cmmn:DiscretionaryItem',
+      isCollapsed: false
+    }
+  },
+  {
+    label: 'Discretionary Plan Fragment',
+    actionName: 'replace-with-plan-fragment-discretionary-item',
+    className: 'cmmn-icon-plan-fragment-expanded-discretionary',
+    target: {
+      definitionType: 'cmmn:PlanFragment',
+      type: 'cmmn:DiscretionaryItem',
+      isCollapsed: false
+    }
+  }
+];
+
+module.exports.EVENT_LISTENER = [
+  {
+    label: 'Event Listener',
+    actionName: 'replace-with-event-listener-plan-item',
+    className: 'cmmn-icon-event-listener',
+    target: {
+      definitionType: 'cmmn:EventListener',
+      type: 'cmmn:PlanItem'
+    }
+  },
+  {
+    label: 'Timer Event Listener',
+    actionName: 'replace-with-timer-event-listener-plan-item',
+    className: 'cmmn-icon-timer-event-listener',
+    target: {
+      definitionType: 'cmmn:TimerEventListener',
+      type: 'cmmn:PlanItem'
+    }
+  },
+  {
+    label: 'User Event Listener',
+    actionName: 'replace-with-user-event-listener-plan-item',
+    className: 'cmmn-icon-user-event-listener',
+    target: {
+      definitionType: 'cmmn:UserEventListener',
+      type: 'cmmn:PlanItem'
+    }
+  }
+];
+
+
+module.exports.CRITERION = [
+  {
+    label: 'Entry Criterion',
+    actionName: 'replace-with-entry-criterion',
+    className: 'cmmn-icon-entry-criterion',
+    target: {
+      type: 'cmmn:EntryCriterion'
+    }
+  },
+  {
+    label: 'Exit Criterion',
+    actionName: 'replace-with-exit-criterion',
+    className: 'cmmn-icon-exit-criterion',
+    target: {
+      type: 'cmmn:ExitCriterion'
+    }
+  }
+];

package/lib/features/replace/index.js

@@ -0,0 +1,8 @@
+module.exports = {
+  __depends__: [
+    require('diagram-js/lib/features/popup-menu').default,
+    require('diagram-js/lib/features/replace').default,
+    require('diagram-js/lib/features/selection').default
+  ],
+  cmmnReplace: [ 'type', require('./CmmnReplace') ]
+};