tianheng-ui 0.1.0 → 0.1.2

package/packages/Workflow/designer/plugins/extension-moddle/activiti/activitiExtension.js

@@ -0,0 +1,74 @@
+"use strict";
+
+var some = require("min-dash").some;
+
+var ALLOWED_TYPES = {
+  FailedJobRetryTimeCycle: ["bpmn:StartEvent", "bpmn:BoundaryEvent", "bpmn:IntermediateCatchEvent", "bpmn:Activity"],
+  Connector: ["bpmn:EndEvent", "bpmn:IntermediateThrowEvent"],
+  Field: ["bpmn:EndEvent", "bpmn:IntermediateThrowEvent"]
+};
+
+function is(element, type) {
+  return element && typeof element.$instanceOf === "function" && element.$instanceOf(type);
+}
+
+function exists(element) {
+  return element && element.length;
+}
+
+function includesType(collection, type) {
+  return (
+    exists(collection) &&
+    some(collection, function(element) {
+      return is(element, type);
+    })
+  );
+}
+
+function anyType(element, types) {
+  return some(types, function(type) {
+    return is(element, type);
+  });
+}
+
+function isAllowed(propName, propDescriptor, newElement) {
+  var name = propDescriptor.name,
+    types = ALLOWED_TYPES[name.replace(/activiti:/, "")];
+
+  return name === propName && anyType(newElement, types);
+}
+
+function ActivitiModdleExtension(eventBus) {
+  eventBus.on(
+    "property.clone",
+    function(context) {
+      var newElement = context.newElement,
+        propDescriptor = context.propertyDescriptor;
+
+      this.canCloneProperty(newElement, propDescriptor);
+    },
+    this
+  );
+}
+
+ActivitiModdleExtension.$inject = ["eventBus"];
+
+ActivitiModdleExtension.prototype.canCloneProperty = function(newElement, propDescriptor) {
+  if (isAllowed("activiti:FailedJobRetryTimeCycle", propDescriptor, newElement)) {
+    return (
+      includesType(newElement.eventDefinitions, "bpmn:TimerEventDefinition") ||
+      includesType(newElement.eventDefinitions, "bpmn:SignalEventDefinition") ||
+      is(newElement.loopCharacteristics, "bpmn:MultiInstanceLoopCharacteristics")
+    );
+  }
+
+  if (isAllowed("activiti:Connector", propDescriptor, newElement)) {
+    return includesType(newElement.eventDefinitions, "bpmn:MessageEventDefinition");
+  }
+
+  if (isAllowed("activiti:Field", propDescriptor, newElement)) {
+    return includesType(newElement.eventDefinitions, "bpmn:MessageEventDefinition");
+  }
+};
+
+module.exports = ActivitiModdleExtension;

package/packages/Workflow/designer/plugins/extension-moddle/activiti/index.js

@@ -0,0 +1,9 @@
+/*
+ * @author igdianov
+ * address https://github.com/igdianov/activiti-bpmn-moddle
+ * */
+
+module.exports = {
+  __init__: ["ActivitiModdleExtension"],
+  ActivitiModdleExtension: ["type", require("./activitiExtension")]
+};

package/packages/Workflow/designer/plugins/extension-moddle/camunda/extension.js

@@ -0,0 +1,148 @@
+"use strict";
+
+var isFunction = require("min-dash").isFunction,
+  isObject = require("min-dash").isObject,
+  some = require("min-dash").some;
+
+var WILDCARD = "*";
+
+function CamundaModdleExtension(eventBus) {
+  var self = this;
+
+  eventBus.on("moddleCopy.canCopyProperty", function(context) {
+    var property = context.property,
+      parent = context.parent;
+
+    return self.canCopyProperty(property, parent);
+  });
+}
+
+CamundaModdleExtension.$inject = ["eventBus"];
+
+/**
+ * Check wether to disallow copying property.
+ */
+CamundaModdleExtension.prototype.canCopyProperty = function(property, parent) {
+  // (1) check wether property is allowed in parent
+  if (isObject(property) && !isAllowedInParent(property, parent)) {
+    return false;
+  }
+
+  // (2) check more complex scenarios
+
+  if (is(property, "camunda:InputOutput") && !this.canHostInputOutput(parent)) {
+    return false;
+  }
+
+  if (isAny(property, ["camunda:Connector", "camunda:Field"]) && !this.canHostConnector(parent)) {
+    return false;
+  }
+
+  if (is(property, "camunda:In") && !this.canHostIn(parent)) {
+    return false;
+  }
+};
+
+CamundaModdleExtension.prototype.canHostInputOutput = function(parent) {
+  // allowed in camunda:Connector
+  var connector = getParent(parent, "camunda:Connector");
+
+  if (connector) {
+    return true;
+  }
+
+  // special rules inside bpmn:FlowNode
+  var flowNode = getParent(parent, "bpmn:FlowNode");
+
+  if (!flowNode) {
+    return false;
+  }
+
+  if (isAny(flowNode, ["bpmn:StartEvent", "bpmn:Gateway", "bpmn:BoundaryEvent"])) {
+    return false;
+  }
+
+  if (is(flowNode, "bpmn:SubProcess") && flowNode.get("triggeredByEvent")) {
+    return false;
+  }
+
+  return true;
+};
+
+CamundaModdleExtension.prototype.canHostConnector = function(parent) {
+  var serviceTaskLike = getParent(parent, "camunda:ServiceTaskLike");
+
+  if (is(serviceTaskLike, "bpmn:MessageEventDefinition")) {
+    // only allow on throw and end events
+    return getParent(parent, "bpmn:IntermediateThrowEvent") || getParent(parent, "bpmn:EndEvent");
+  }
+
+  return true;
+};
+
+CamundaModdleExtension.prototype.canHostIn = function(parent) {
+  var callActivity = getParent(parent, "bpmn:CallActivity");
+
+  if (callActivity) {
+    return true;
+  }
+
+  var signalEventDefinition = getParent(parent, "bpmn:SignalEventDefinition");
+
+  if (signalEventDefinition) {
+    // only allow on throw and end events
+    return getParent(parent, "bpmn:IntermediateThrowEvent") || getParent(parent, "bpmn:EndEvent");
+  }
+
+  return true;
+};
+
+module.exports = CamundaModdleExtension;
+
+// helpers //////////
+
+function is(element, type) {
+  return element && isFunction(element.$instanceOf) && element.$instanceOf(type);
+}
+
+function isAny(element, types) {
+  return some(types, function(t) {
+    return is(element, t);
+  });
+}
+
+function getParent(element, type) {
+  if (!type) {
+    return element.$parent;
+  }
+
+  if (is(element, type)) {
+    return element;
+  }
+
+  if (!element.$parent) {
+    return;
+  }
+
+  return getParent(element.$parent, type);
+}
+
+function isAllowedInParent(property, parent) {
+  // (1) find property descriptor
+  var descriptor = property.$type && property.$model.getTypeDescriptor(property.$type);
+
+  var allowedIn = descriptor && descriptor.meta && descriptor.meta.allowedIn;
+
+  if (!allowedIn || isWildcard(allowedIn)) {
+    return true;
+  }
+
+  // (2) check wether property has parent of allowed type
+  return some(allowedIn, function(type) {
+    return getParent(parent, type);
+  });
+}
+
+function isWildcard(allowedIn) {
+  return allowedIn.indexOf(WILDCARD) !== -1;
+}

package/packages/Workflow/designer/plugins/extension-moddle/camunda/index.js

@@ -0,0 +1,6 @@
+"use strict";
+
+module.exports = {
+  __init__: ["camundaModdleExtension"],
+  camundaModdleExtension: ["type", require("./extension")]
+};

package/packages/Workflow/designer/plugins/extension-moddle/flowable/flowableExtension.js

@@ -0,0 +1,74 @@
+"use strict";
+
+var some = require("min-dash").some;
+
+var ALLOWED_TYPES = {
+  FailedJobRetryTimeCycle: ["bpmn:StartEvent", "bpmn:BoundaryEvent", "bpmn:IntermediateCatchEvent", "bpmn:Activity"],
+  Connector: ["bpmn:EndEvent", "bpmn:IntermediateThrowEvent"],
+  Field: ["bpmn:EndEvent", "bpmn:IntermediateThrowEvent"]
+};
+
+function is(element, type) {
+  return element && typeof element.$instanceOf === "function" && element.$instanceOf(type);
+}
+
+function exists(element) {
+  return element && element.length;
+}
+
+function includesType(collection, type) {
+  return (
+    exists(collection) &&
+    some(collection, function(element) {
+      return is(element, type);
+    })
+  );
+}
+
+function anyType(element, types) {
+  return some(types, function(type) {
+    return is(element, type);
+  });
+}
+
+function isAllowed(propName, propDescriptor, newElement) {
+  var name = propDescriptor.name,
+    types = ALLOWED_TYPES[name.replace(/flowable:/, "")];
+
+  return name === propName && anyType(newElement, types);
+}
+
+function FlowableModdleExtension(eventBus) {
+  eventBus.on(
+    "property.clone",
+    function(context) {
+      var newElement = context.newElement,
+        propDescriptor = context.propertyDescriptor;
+
+      this.canCloneProperty(newElement, propDescriptor);
+    },
+    this
+  );
+}
+
+FlowableModdleExtension.$inject = ["eventBus"];
+
+FlowableModdleExtension.prototype.canCloneProperty = function(newElement, propDescriptor) {
+  if (isAllowed("flowable:FailedJobRetryTimeCycle", propDescriptor, newElement)) {
+    return (
+      includesType(newElement.eventDefinitions, "bpmn:TimerEventDefinition") ||
+      includesType(newElement.eventDefinitions, "bpmn:SignalEventDefinition") ||
+      is(newElement.loopCharacteristics, "bpmn:MultiInstanceLoopCharacteristics")
+    );
+  }
+
+  if (isAllowed("flowable:Connector", propDescriptor, newElement)) {
+    return includesType(newElement.eventDefinitions, "bpmn:MessageEventDefinition");
+  }
+
+  if (isAllowed("flowable:Field", propDescriptor, newElement)) {
+    return includesType(newElement.eventDefinitions, "bpmn:MessageEventDefinition");
+  }
+};
+
+module.exports = FlowableModdleExtension;

package/packages/Workflow/designer/plugins/extension-moddle/flowable/index.js

@@ -0,0 +1,9 @@
+/*
+ * @author igdianov
+ * address https://github.com/igdianov/activiti-bpmn-moddle
+ * */
+
+module.exports = {
+  __init__: ["FlowableModdleExtension"],
+  FlowableModdleExtension: ["type", require("./flowableExtension")]
+};

package/packages/Workflow/designer/plugins/palette/CustomPalette.js

@@ -0,0 +1,156 @@
+import PaletteProvider from "bpmn-js/lib/features/palette/PaletteProvider";
+import { assign } from "min-dash";
+
+export default function CustomPalette(palette, create, elementFactory, spaceTool, lassoTool, handTool, globalConnect, translate) {
+  PaletteProvider.call(this, palette, create, elementFactory, spaceTool, lassoTool, handTool, globalConnect, translate, 2000);
+}
+
+const F = function() {}; // 核心，利用空对象作为中介；
+F.prototype = PaletteProvider.prototype; // 核心，将父类的原型赋值给空对象F；
+
+// 利用中介函数重写原型链方法
+F.prototype.getPaletteEntries = function() {
+  var actions = {},
+    create = this._create,
+    elementFactory = this._elementFactory,
+    spaceTool = this._spaceTool,
+    lassoTool = this._lassoTool,
+    handTool = this._handTool,
+    globalConnect = this._globalConnect,
+    translate = this._translate;
+
+  function createAction(type, group, className, title, options) {
+    function createListener(event) {
+      var shape = elementFactory.createShape(assign({ type: type }, options));
+
+      if (options) {
+        shape.businessObject.di.isExpanded = options.isExpanded;
+      }
+
+      create.start(event, shape);
+    }
+
+    var shortType = type.replace(/^bpmn:/, "");
+
+    return {
+      group: group,
+      className: className,
+      title: title || translate("Create {type}", { type: shortType }),
+      action: {
+        dragstart: createListener,
+        click: createListener
+      }
+    };
+  }
+
+  function createSubprocess(event) {
+    var subProcess = elementFactory.createShape({
+      type: "bpmn:SubProcess",
+      x: 0,
+      y: 0,
+      isExpanded: true
+    });
+
+    var startEvent = elementFactory.createShape({
+      type: "bpmn:StartEvent",
+      x: 40,
+      y: 82,
+      parent: subProcess
+    });
+
+    create.start(event, [subProcess, startEvent], {
+      hints: {
+        autoSelect: [startEvent]
+      }
+    });
+  }
+
+  function createParticipant(event) {
+    create.start(event, elementFactory.createParticipantShape());
+  }
+
+  assign(actions, {
+    "hand-tool": {
+      group: "tools",
+      className: "bpmn-icon-hand-tool",
+      title: translate("Activate the hand tool"),
+      action: {
+        click: function(event) {
+          handTool.activateHand(event);
+        }
+      }
+    },
+    "lasso-tool": {
+      group: "tools",
+      className: "bpmn-icon-lasso-tool",
+      title: translate("Activate the lasso tool"),
+      action: {
+        click: function(event) {
+          lassoTool.activateSelection(event);
+        }
+      }
+    },
+    "space-tool": {
+      group: "tools",
+      className: "bpmn-icon-space-tool",
+      title: translate("Activate the create/remove space tool"),
+      action: {
+        click: function(event) {
+          spaceTool.activateSelection(event);
+        }
+      }
+    },
+    "global-connect-tool": {
+      group: "tools",
+      className: "bpmn-icon-connection-multi",
+      title: translate("Activate the global connect tool"),
+      action: {
+        click: function(event) {
+          globalConnect.toggle(event);
+        }
+      }
+    },
+    "tool-separator": {
+      group: "tools",
+      separator: true
+    },
+    "create.start-event": createAction("bpmn:StartEvent", "event", "bpmn-icon-start-event-none", translate("Create StartEvent")),
+    "create.intermediate-event": createAction(
+      "bpmn:IntermediateThrowEvent",
+      "event",
+      "bpmn-icon-intermediate-event-none",
+      translate("Create Intermediate/Boundary Event")
+    ),
+    "create.end-event": createAction("bpmn:EndEvent", "event", "bpmn-icon-end-event-none", translate("Create EndEvent")),
+    "create.exclusive-gateway": createAction("bpmn:ExclusiveGateway", "gateway", "bpmn-icon-gateway-none", translate("Create Gateway")),
+    "create.user-task": createAction("bpmn:UserTask", "activity", "bpmn-icon-user-task", translate("Create User Task")),
+    "create.data-object": createAction("bpmn:DataObjectReference", "data-object", "bpmn-icon-data-object", translate("Create DataObjectReference")),
+    "create.data-store": createAction("bpmn:DataStoreReference", "data-store", "bpmn-icon-data-store", translate("Create DataStoreReference")),
+    "create.subprocess-expanded": {
+      group: "activity",
+      className: "bpmn-icon-subprocess-expanded",
+      title: translate("Create expanded SubProcess"),
+      action: {
+        dragstart: createSubprocess,
+        click: createSubprocess
+      }
+    },
+    "create.participant-expanded": {
+      group: "collaboration",
+      className: "bpmn-icon-participant",
+      title: translate("Create Pool/Participant"),
+      action: {
+        dragstart: createParticipant,
+        click: createParticipant
+      }
+    },
+    "create.group": createAction("bpmn:Group", "artifact", "bpmn-icon-group", translate("Create Group"))
+  });
+
+  return actions;
+};
+
+CustomPalette.$inject = ["palette", "create", "elementFactory", "spaceTool", "lassoTool", "handTool", "globalConnect", "translate"];
+
+CustomPalette.prototype = new F(); // 核心，将 F的实例赋值给子类；
+CustomPalette.prototype.constructor = CustomPalette; // 修复子类CustomPalette的构造器指向，防止原型链的混乱；

package/packages/Workflow/designer/plugins/palette/index.js

@@ -0,0 +1,6 @@
+import CustomPalette from "./CustomPalette";
+
+export default {
+  __init__: ["customPalette"],
+  customPalette: ["type", CustomPalette]
+};

package/packages/Workflow/designer/plugins/palette/paletteProvider.js

@@ -0,0 +1,160 @@
+import { assign } from "min-dash";
+
+/**
+ * A palette provider for BPMN 2.0 elements.
+ */
+export default function PaletteProvider(palette, create, elementFactory, spaceTool, lassoTool, handTool, globalConnect, translate) {
+  this._palette = palette;
+  this._create = create;
+  this._elementFactory = elementFactory;
+  this._spaceTool = spaceTool;
+  this._lassoTool = lassoTool;
+  this._handTool = handTool;
+  this._globalConnect = globalConnect;
+  this._translate = translate;
+
+  palette.registerProvider(this);
+}
+
+PaletteProvider.$inject = ["palette", "create", "elementFactory", "spaceTool", "lassoTool", "handTool", "globalConnect", "translate"];
+
+PaletteProvider.prototype.getPaletteEntries = function() {
+  var actions = {},
+    create = this._create,
+    elementFactory = this._elementFactory,
+    spaceTool = this._spaceTool,
+    lassoTool = this._lassoTool,
+    handTool = this._handTool,
+    globalConnect = this._globalConnect,
+    translate = this._translate;
+
+  function createAction(type, group, className, title, options) {
+    function createListener(event) {
+      var shape = elementFactory.createShape(assign({ type: type }, options));
+
+      if (options) {
+        shape.businessObject.di.isExpanded = options.isExpanded;
+      }
+
+      create.start(event, shape);
+    }
+
+    var shortType = type.replace(/^bpmn:/, "");
+
+    return {
+      group: group,
+      className: className,
+      title: title || translate("Create {type}", { type: shortType }),
+      action: {
+        dragstart: createListener,
+        click: createListener
+      }
+    };
+  }
+
+  function createSubprocess(event) {
+    var subProcess = elementFactory.createShape({
+      type: "bpmn:SubProcess",
+      x: 0,
+      y: 0,
+      isExpanded: true
+    });
+
+    var startEvent = elementFactory.createShape({
+      type: "bpmn:StartEvent",
+      x: 40,
+      y: 82,
+      parent: subProcess
+    });
+
+    create.start(event, [subProcess, startEvent], {
+      hints: {
+        autoSelect: [startEvent]
+      }
+    });
+  }
+
+  function createParticipant(event) {
+    create.start(event, elementFactory.createParticipantShape());
+  }
+
+  assign(actions, {
+    "hand-tool": {
+      group: "tools",
+      className: "bpmn-icon-hand-tool",
+      title: translate("Activate the hand tool"),
+      action: {
+        click: function(event) {
+          handTool.activateHand(event);
+        }
+      }
+    },
+    "lasso-tool": {
+      group: "tools",
+      className: "bpmn-icon-lasso-tool",
+      title: translate("Activate the lasso tool"),
+      action: {
+        click: function(event) {
+          lassoTool.activateSelection(event);
+        }
+      }
+    },
+    "space-tool": {
+      group: "tools",
+      className: "bpmn-icon-space-tool",
+      title: translate("Activate the create/remove space tool"),
+      action: {
+        click: function(event) {
+          spaceTool.activateSelection(event);
+        }
+      }
+    },
+    "global-connect-tool": {
+      group: "tools",
+      className: "bpmn-icon-connection-multi",
+      title: translate("Activate the global connect tool"),
+      action: {
+        click: function(event) {
+          globalConnect.toggle(event);
+        }
+      }
+    },
+    "tool-separator": {
+      group: "tools",
+      separator: true
+    },
+    "create.start-event": createAction("bpmn:StartEvent", "event", "bpmn-icon-start-event-none", translate("Create StartEvent")),
+    "create.intermediate-event": createAction(
+      "bpmn:IntermediateThrowEvent",
+      "event",
+      "bpmn-icon-intermediate-event-none",
+      translate("Create Intermediate/Boundary Event")
+    ),
+    "create.end-event": createAction("bpmn:EndEvent", "event", "bpmn-icon-end-event-none", translate("Create EndEvent")),
+    "create.exclusive-gateway": createAction("bpmn:ExclusiveGateway", "gateway", "bpmn-icon-gateway-none", translate("Create Gateway")),
+    "create.user-task": createAction("bpmn:UserTask", "activity", "bpmn-icon-user-task", translate("Create User Task")),
+    "create.data-object": createAction("bpmn:DataObjectReference", "data-object", "bpmn-icon-data-object", translate("Create DataObjectReference")),
+    "create.data-store": createAction("bpmn:DataStoreReference", "data-store", "bpmn-icon-data-store", translate("Create DataStoreReference")),
+    "create.subprocess-expanded": {
+      group: "activity",
+      className: "bpmn-icon-subprocess-expanded",
+      title: translate("Create expanded SubProcess"),
+      action: {
+        dragstart: createSubprocess,
+        click: createSubprocess
+      }
+    },
+    "create.participant-expanded": {
+      group: "collaboration",
+      className: "bpmn-icon-participant",
+      title: translate("Create Pool/Participant"),
+      action: {
+        dragstart: createParticipant,
+        click: createParticipant
+      }
+    },
+    "create.group": createAction("bpmn:Group", "artifact", "bpmn-icon-group", translate("Create Group"))
+  });
+
+  return actions;
+};

package/packages/Workflow/designer/plugins/translate/customTranslate.js

@@ -0,0 +1,41 @@
+// import translations from "./zh";
+//
+// export default function customTranslate(template, replacements) {
+//   replacements = replacements || {};
+//
+//   // Translate
+//   template = translations[template] || template;
+//
+//   // Replace
+//   return template.replace(/{([^}]+)}/g, function(_, key) {
+//     let str = replacements[key];
+//     if (
+//       translations[replacements[key]] !== null &&
+//       translations[replacements[key]] !== "undefined"
+//     ) {
+//       // eslint-disable-next-line no-mixed-spaces-and-tabs
+//       str = translations[replacements[key]];
+//       // eslint-disable-next-line no-mixed-spaces-and-tabs
+//     }
+//     return str || "{" + key + "}";
+//   });
+// }
+
+export default function customTranslate(translations) {
+  return function(template, replacements) {
+    replacements = replacements || {};
+    // Translate
+    template = translations[template] || template;
+
+    // Replace
+    return template.replace(/{([^}]+)}/g, function(_, key) {
+      let str = replacements[key];
+      if (translations[replacements[key]] !== null && translations[replacements[key]] !== undefined) {
+        // eslint-disable-next-line no-mixed-spaces-and-tabs
+        str = translations[replacements[key]];
+        // eslint-disable-next-line no-mixed-spaces-and-tabs
+      }
+      return str || "{" + key + "}";
+    });
+  };
+}