Merge branch 'master' of http://49.233.37.222:3000/wjm/mec-cloud_IntelligentManufacturing_CRM

ruoyi-ui/src/components/updateModule/bpmn-js/lib/BaseViewer.js

@@ -35,6 +35,785 @@ import {
   wrapForCompatibility
 } from './util/CompatibilityUtil';
 
+/**
+ * A base viewer for BPMN 2.0 diagrams.
+ *
+ * Have a look at {@link Viewer}, {@link NavigatedViewer} or {@link Modeler} for
+ * bundles that include actual features.
+ *
+ * @param {Object} [options] configuration options to pass to the viewer
+ * @param {DOMElement} [options.container] the container to render the viewer in, defaults to body.
+ * @param {string|number} [options.width] the width of the viewer
+ * @param {string|number} [options.height] the height of the viewer
+ * @param {Object} [options.moddleExtensions] extension packages to provide
+ * @param {Array<didi.Module>} [options.modules] a list of modules to override the default modules
+ * @param {Array<didi.Module>} [options.additionalModules] a list of modules to use with the default modules
+ */
+export default function BaseViewer(options) {
+
+  options = assign({}, DEFAULT_OPTIONS, options);
+
+  this._moddle = this._createModdle(options);
+
+  this._container = this._createContainer(options);
+
+  /* <project-logo> */
+
+  // addProjectLogo(this._container);
+
+  /* </project-logo> */
+
+  this._init(this._container, this._moddle, options);
+}
+
+inherits(BaseViewer, Diagram);
+
+/**
+* The importXML result.
+*
+* @typedef {Object} ImportXMLResult
+*
+* @property {Array<string>} warnings
+*/
+
+/**
+* The importXML error.
+*
+* @typedef {Error} ImportXMLError
+*
+* @property {Array<string>} warnings
+*/
+
+/**
+ * Parse and render a BPMN 2.0 diagram.
+ *
+ * Once finished the viewer reports back the result to the
+ * provided callback function with (err, warnings).
+ *
+ * ## Life-Cycle Events
+ *
+ * During import the viewer will fire life-cycle events:
+ *
+ *   * import.parse.start (about to read model from xml)
+ *   * import.parse.complete (model read; may have worked or not)
+ *   * import.render.start (graphical import start)
+ *   * import.render.complete (graphical import finished)
+ *   * import.done (everything done)
+ *
+ * You can use these events to hook into the life-cycle.
+ *
+ * @param {string} xml the BPMN 2.0 xml
+ * @param {ModdleElement<BPMNDiagram>|string} [bpmnDiagram] BPMN diagram or id of diagram to render (if not provided, the first one will be rendered)
+ *
+ * Returns {Promise<ImportXMLResult, ImportXMLError>}
+ */
+BaseViewer.prototype.importXML = wrapForCompatibility(function importXML(xml, bpmnDiagram) {
+
+  var self = this;
+
+  function ParseCompleteEvent(data) {
+
+    var event = self.get('eventBus').createEvent(data);
+
+    // TODO(nikku): remove with future bpmn-js version
+    Object.defineProperty(event, 'context', {
+      enumerable: true,
+      get: function () {
+
+        console.warn(new Error(
+          'import.parse.complete <context> is deprecated ' +
+          'and will be removed in future library versions'
+        ));
+
+        return {
+          warnings: data.warnings,
+          references: data.references,
+          elementsById: data.elementsById
+        };
+      }
+    });
+
+    return event;
+  }
+
+  return new Promise(function (resolve, reject) {
+
+    // hook in pre-parse listeners +
+    // allow xml manipulation
+    xml = self._emit('import.parse.start', { xml: xml }) || xml;
+
+    self._moddle.fromXML(xml, 'bpmn:Definitions').then(function (result) {
+      var definitions = result.rootElement;
+      var references = result.references;
+      var parseWarnings = result.warnings;
+      var elementsById = result.elementsById;
+
+      // hook in post parse listeners +
+      // allow definitions manipulation
+      definitions = self._emit('import.parse.complete', ParseCompleteEvent({
+        error: null,
+        definitions: definitions,
+        elementsById: elementsById,
+        references: references,
+        warnings: parseWarnings
+      })) || definitions;
+
+      self.importDefinitions(definitions, bpmnDiagram).then(function (result) {
+        var allWarnings = [].concat(parseWarnings, result.warnings || []);
+
+        self._emit('import.done', { error: null, warnings: allWarnings });
+
+        return resolve({ warnings: allWarnings });
+      }).catch(function (err) {
+        var allWarnings = [].concat(parseWarnings, err.warnings || []);
+
+        self._emit('import.done', { error: err, warnings: allWarnings });
+
+        return reject(addWarningsToError(err, allWarnings));
+      });
+    }).catch(function (err) {
+
+      self._emit('import.parse.complete', {
+        error: err
+      });
+
+      err = checkValidationError(err);
+
+      self._emit('import.done', { error: err, warnings: err.warnings });
+
+      return reject(err);
+    });
+  });
+});
+
+/**
+* The importDefinitions result.
+*
+* @typedef {Object} ImportDefinitionsResult
+*
+* @property {Array<string>} warnings
+*/
+
+/**
+* The importDefinitions error.
+*
+* @typedef {Error} ImportDefinitionsError
+*
+* @property {Array<string>} warnings
+*/
+
+/**
+ * Import parsed definitions and render a BPMN 2.0 diagram.
+ *
+ * Once finished the viewer reports back the result to the
+ * provided callback function with (err, warnings).
+ *
+ * ## Life-Cycle Events
+ *
+ * During import the viewer will fire life-cycle events:
+ *
+ *   * import.render.start (graphical import start)
+ *   * import.render.complete (graphical import finished)
+ *
+ * You can use these events to hook into the life-cycle.
+ *
+ * @param {ModdleElement<Definitions>} definitions parsed BPMN 2.0 definitions
+ * @param {ModdleElement<BPMNDiagram>|string} [bpmnDiagram] BPMN diagram or id of diagram to render (if not provided, the first one will be rendered)
+ *
+ * Returns {Promise<ImportDefinitionsResult, ImportDefinitionsError>}
+ */
+BaseViewer.prototype.importDefinitions = wrapForCompatibility(function importDefinitions(definitions, bpmnDiagram) {
+
+  var self = this;
+
+  return new Promise(function (resolve, reject) {
+
+    self._setDefinitions(definitions);
+
+    self.open(bpmnDiagram).then(function (result) {
+
+      var warnings = result.warnings;
+
+      return resolve({ warnings: warnings });
+    }).catch(function (err) {
+
+      return reject(err);
+    });
+  });
+});
+
+/**
+ * The open result.
+ *
+ * @typedef {Object} OpenResult
+ *
+ * @property {Array<string>} warnings
+ */
+
+/**
+* The open error.
+*
+* @typedef {Error} OpenError
+*
+* @property {Array<string>} warnings
+*/
+
+/**
+ * Open diagram of previously imported XML.
+ *
+ * Once finished the viewer reports back the result to the
+ * provided callback function with (err, warnings).
+ *
+ * ## Life-Cycle Events
+ *
+ * During switch the viewer will fire life-cycle events:
+ *
+ *   * import.render.start (graphical import start)
+ *   * import.render.complete (graphical import finished)
+ *
+ * You can use these events to hook into the life-cycle.
+ *
+ * @param {string|ModdleElement<BPMNDiagram>} [bpmnDiagramOrId] id or the diagram to open
+ *
+ * Returns {Promise<OpenResult, OpenError>}
+ */
+BaseViewer.prototype.open = wrapForCompatibility(function open(bpmnDiagramOrId) {
+
+  var definitions = this._definitions;
+  var bpmnDiagram = bpmnDiagramOrId;
+
+  var self = this;
+
+  return new Promise(function (resolve, reject) {
+    if (!definitions) {
+      var err1 = new Error('no XML imported');
+
+      return reject(addWarningsToError(err1, []));
+    }
+
+    if (typeof bpmnDiagramOrId === 'string') {
+      bpmnDiagram = findBPMNDiagram(definitions, bpmnDiagramOrId);
+
+      if (!bpmnDiagram) {
+        var err2 = new Error('BPMNDiagram <' + bpmnDiagramOrId + '> not found');
+
+        return reject(addWarningsToError(err2, []));
+      }
+    }
+
+    // clear existing rendered diagram
+    // catch synchronous exceptions during #clear()
+    try {
+      self.clear();
+    } catch (error) {
+
+      return reject(addWarningsToError(error, []));
+    }
+
+    // perform graphical import
+    importBpmnDiagram(self, definitions, bpmnDiagram).then(function (result) {
+
+      var warnings = result.warnings;
+
+      return resolve({ warnings: warnings });
+    }).catch(function (err) {
+
+      return reject(err);
+    });
+  });
+});
+
+/**
+ * The saveXML result.
+ *
+ * @typedef {Object} SaveXMLResult
+ *
+ * @property {string} xml
+ */
+
+/**
+ * Export the currently displayed BPMN 2.0 diagram as
+ * a BPMN 2.0 XML document.
+ *
+ * ## Life-Cycle Events
+ *
+ * During XML saving the viewer will fire life-cycle events:
+ *
+ *   * saveXML.start (before serialization)
+ *   * saveXML.serialized (after xml generation)
+ *   * saveXML.done (everything done)
+ *
+ * You can use these events to hook into the life-cycle.
+ *
+ * @param {Object} [options] export options
+ * @param {boolean} [options.format=false] output formatted XML
+ * @param {boolean} [options.preamble=true] output preamble
+ *
+ * Returns {Promise<SaveXMLResult, Error>}
+ */
+BaseViewer.prototype.saveXML = wrapForCompatibility(function saveXML(options) {
+
+  options = options || {};
+
+  var self = this;
+
+  var definitions = this._definitions;
+
+  return new Promise(function (resolve) {
+
+    if (!definitions) {
+      return resolve({
+        error: new Error('no definitions loaded')
+      });
+    }
+
+    // allow to fiddle around with definitions
+    definitions = self._emit('saveXML.start', {
+      definitions: definitions
+    }) || definitions;
+
+    self._moddle.toXML(definitions, options).then(function (result) {
+
+      var xml = result.xml;
+
+      xml = self._emit('saveXML.serialized', {
+        xml: xml
+      }) || xml;
+
+      return resolve({
+        xml: xml
+      });
+    });
+  }).catch(function (error) {
+    return { error: error };
+  }).then(function (result) {
+
+    self._emit('saveXML.done', result);
+
+    var error = result.error;
+
+    if (error) {
+      return Promise.reject(error);
+    }
+
+    return result;
+  });
+});
+
+/**
+ * The saveSVG result.
+ *
+ * @typedef {Object} SaveSVGResult
+ *
+ * @property {string} svg
+ */
+
+/**
+ * Export the currently displayed BPMN 2.0 diagram as
+ * an SVG image.
+ *
+ * ## Life-Cycle Events
+ *
+ * During SVG saving the viewer will fire life-cycle events:
+ *
+ *   * saveSVG.start (before serialization)
+ *   * saveSVG.done (everything done)
+ *
+ * You can use these events to hook into the life-cycle.
+ *
+ * @param {Object} [options]
+ *
+ * Returns {Promise<SaveSVGResult, Error>}
+ */
+BaseViewer.prototype.saveSVG = wrapForCompatibility(function saveSVG(options) {
+
+  options = options || {};
+
+  var self = this;
+
+  return new Promise(function (resolve, reject) {
+
+    self._emit('saveSVG.start');
+
+    var svg, err;
+
+    try {
+      var canvas = self.get('canvas');
+
+      var contentNode = canvas.getActiveLayer(),
+        defsNode = domQuery('defs', canvas._svg);
+
+      var contents = innerSVG(contentNode),
+        defs = defsNode ? '<defs>' + innerSVG(defsNode) + '</defs>' : '';
+
+      var bbox = contentNode.getBBox();
+
+      svg =
+        '<?xml version="1.0" encoding="utf-8"?>\n' +
+        '<!-- created with bpmn-js / http://bpmn.io -->\n' +
+        '<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">\n' +
+        '<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" ' +
+        'width="' + bbox.width + '" height="' + bbox.height + '" ' +
+        'viewBox="' + bbox.x + ' ' + bbox.y + ' ' + bbox.width + ' ' + bbox.height + '" version="1.1">' +
+        defs + contents +
+        '</svg>';
+    } catch (e) {
+      err = e;
+    }
+
+    self._emit('saveSVG.done', {
+      error: err,
+      svg: svg
+    });
+
+    if (!err) {
+      return resolve({ svg: svg });
+    }
+
+    return reject(err);
+  });
+});
+
+/**
+ * Get a named diagram service.
+ *
+ * @example
+ *
+ * var elementRegistry = viewer.get('elementRegistry');
+ * var startEventShape = elementRegistry.get('StartEvent_1');
+ *
+ * @param {string} name
+ *
+ * @return {Object} diagram service instance
+ *
+ * @method BaseViewer#get
+ */
+
+/**
+ * Invoke a function in the context of this viewer.
+ *
+ * @example
+ *
+ * viewer.invoke(function(elementRegistry) {
+ *   var startEventShape = elementRegistry.get('StartEvent_1');
+ * });
+ *
+ * @param {Function} fn to be invoked
+ *
+ * @return {Object} the functions return value
+ *
+ * @method BaseViewer#invoke
+ */
+
+
+BaseViewer.prototype._setDefinitions = function (definitions) {
+  this._definitions = definitions;
+};
+
+BaseViewer.prototype.getModules = function () {
+  return this._modules;
+};
+
+/**
+ * Remove all drawn elements from the viewer.
+ *
+ * After calling this method the viewer can still
+ * be reused for opening another diagram.
+ *
+ * @method BaseViewer#clear
+ */
+BaseViewer.prototype.clear = function () {
+  if (!this.getDefinitions()) {
+
+    // no diagram to clear
+    return;
+  }
+
+  // remove drawn elements
+  Diagram.prototype.clear.call(this);
+};
+
+/**
+ * Destroy the viewer instance and remove all its
+ * remainders from the document tree.
+ */
+BaseViewer.prototype.destroy = function () {
+
+  // diagram destroy
+  Diagram.prototype.destroy.call(this);
+
+  // dom detach
+  domRemove(this._container);
+};
+
+/**
+ * Register an event listener
+ *
+ * Remove a previously added listener via {@link #off(event, callback)}.
+ *
+ * @param {string} event
+ * @param {number} [priority]
+ * @param {Function} callback
+ * @param {Object} [that]
+ */
+BaseViewer.prototype.on = function (event, priority, callback, target) {
+  return this.get('eventBus').on(event, priority, callback, target);
+};
+
+/**
+ * De-register an event listener
+ *
+ * @param {string} event
+ * @param {Function} callback
+ */
+BaseViewer.prototype.off = function (event, callback) {
+  this.get('eventBus').off(event, callback);
+};
+
+BaseViewer.prototype.attachTo = function (parentNode) {
+
+  if (!parentNode) {
+    throw new Error('parentNode required');
+  }
+
+  // ensure we detach from the
+  // previous, old parent
+  this.detach();
+
+  // unwrap jQuery if provided
+  if (parentNode.get && parentNode.constructor.prototype.jquery) {
+    parentNode = parentNode.get(0);
+  }
+
+  if (typeof parentNode === 'string') {
+    parentNode = domQuery(parentNode);
+  }
+
+  parentNode.appendChild(this._container);
+
+  this._emit('attach', {});
+
+  this.get('canvas').resized();
+};
+
+BaseViewer.prototype.getDefinitions = function () {
+  return this._definitions;
+};
+
+BaseViewer.prototype.detach = function () {
+
+  var container = this._container,
+    parentNode = container.parentNode;
+
+  if (!parentNode) {
+    return;
+  }
+
+  this._emit('detach', {});
+
+  parentNode.removeChild(container);
+};
+
+BaseViewer.prototype._init = function (container, moddle, options) {
+
+  var baseModules = options.modules || this.getModules(),
+    additionalModules = options.additionalModules || [],
+    staticModules = [
+      {
+        bpmnjs: ['value', this],
+        moddle: ['value', moddle]
+      }
+    ];
+
+  var diagramModules = [].concat(staticModules, baseModules, additionalModules);
+
+  var diagramOptions = assign(omit(options, ['additionalModules']), {
+    canvas: assign({}, options.canvas, { container: container }),
+    modules: diagramModules
+  });
+
+  // invoke diagram constructor
+  Diagram.call(this, diagramOptions);
+
+  if (options && options.container) {
+    this.attachTo(options.container);
+  }
+};
+
+/**
+ * Emit an event on the underlying {@link EventBus}
+ *
+ * @param  {string} type
+ * @param  {Object} event
+ *
+ * @return {Object} event processing result (if any)
+ */
+BaseViewer.prototype._emit = function (type, event) {
+  return this.get('eventBus').fire(type, event);
+};
+
+BaseViewer.prototype._createContainer = function (options) {
+
+  var container = domify('<div class="bjs-container"></div>');
+
+  assignStyle(container, {
+    width: ensureUnit(options.width),
+    height: ensureUnit(options.height),
+    position: options.position
+  });
+
+  return container;
+};
+
+BaseViewer.prototype._createModdle = function (options) {
+  var moddleOptions = assign({}, this._moddleExtensions, options.moddleExtensions);
+
+  return new BpmnModdle(moddleOptions);
+};
+
+BaseViewer.prototype._modules = [];
+
+// helpers ///////////////
+
+function addWarningsToError(err, warningsAry) {
+  err.warnings = warningsAry;
+  return err;
+}
+
+function checkValidationError(err) {
+
+  // check if we can help the user by indicating wrong BPMN 2.0 xml
+  // (in case he or the exporting tool did not get that right)
+
+  var pattern = /unparsable content <([^>]+)> detected([\s\S]*)$/;
+  var match = pattern.exec(err.message);
+
+  if (match) {
+    err.message =
+      'unparsable content <' + match[1] + '> detected; ' +
+      'this may indicate an invalid BPMN 2.0 diagram file' + match[2];
+  }
+
+  return err;
+}
+
+var DEFAULT_OPTIONS = {
+  width: '100%',
+  height: '100%',
+  position: 'relative'
+};
+
+
+/**
+ * Ensure the passed argument is a proper unit (defaulting to px)
+ */
+function ensureUnit(val) {
+  return val + (isNumber(val) ? 'px' : '');
+}
+
+
+/**
+ * Find BPMNDiagram in definitions by ID
+ *
+ * @param {ModdleElement<Definitions>} definitions
+ * @param {string} diagramId
+ *
+ * @return {ModdleElement<BPMNDiagram>|null}
+ */
+function findBPMNDiagram(definitions, diagramId) {
+  if (!diagramId) {
+    return null;
+  }
+
+  return find(definitions.diagrams, function (element) {
+    return element.id === diagramId;
+  }) || null;
+}
+
+
+/* <project-logo> */
+
+import {
+  open as openPoweredBy,
+  BPMNIO_IMG,
+  LOGO_STYLES,
+  LINK_STYLES
+} from './util/PoweredByUtil';
+
+import {
+  event as domEvent
+} from 'min-dom';
+
+/**
+ * Adds the project logo to the diagram container as
+ * required by the bpmn.io license.
+ *
+ * @see http://bpmn.io/license
+ *
+ * @param {Element} container
+ */
+function addProjectLogo(container) {
+  var img = BPMNIO_IMG;
+
+  var linkMarkup = '';
+
+  var linkElement = domify(linkMarkup);
+
+  assignStyle(domQuery('svg', linkElement), LOGO_STYLES);
+  assignStyle(linkElement, LINK_STYLES, {
+    position: 'absolute',
+    bottom: '15px',
+    right: '15px',
+    zIndex: '100'
+  });
+
+  container.appendChild(linkElement);
+
+  domEvent.bind(linkElement, 'click', function (event) {
+    openPoweredBy();
+
+    event.preventDefault();
+  });
+}
+
+/* </project-logo> */
+/**
+ * The code in the <project-logo></project-logo> area
+ * must not be changed.
+ *
+ * @see http://bpmn.io/license for more information.
+ */
+import {
+  assign,
+  find,
+  isNumber,
+  omit
+} from 'min-dash';
+
+import {
+  domify,
+  assignStyle,
+  query as domQuery,
+  remove as domRemove
+} from 'min-dom';
+
+import {
+  innerSVG
+} from 'tiny-svg';
+
+import Diagram from 'diagram-js';
+import BpmnModdle from 'bpmn-moddle';
+
+import inherits from 'inherits-browser';
+
+import {
+  importBpmnDiagram
+} from './import/Importer';
+
+import {
+  wrapForCompatibility
+} from './util/CompatibilityUtil';
+
 /**
  * A base viewer for BPMN 2.0 diagrams.
  *

ruoyi-ui/src/utils/bpmn/xml.js

@@ -8,7 +8,6 @@ export function emptyXML(key, name) {
   xmlns:bpmndi="http://www.omg.org/spec/BPMN/20100524/DI"
   xmlns:dc="http://www.omg.org/spec/DD/20100524/DC"
   xmlns:di="http://www.omg.org/spec/DD/20100524/DI"
-  targetNamespace="http://bpmn.io/schema/bpmn"
   id="Definitions_0001">
   <bpmn:process id="${key}" name="${name}" isExecutable="true" />
   <bpmndi:BPMNDiagram id="BPMNDiagram_1">

ruoyi-ui/src/views/bpmprocess/index.vue

@@ -295,6 +295,7 @@
           prop="startEventType"
           label="启动事件类型"
           align="center"
+          width="100px"
         >
         </el-table-column>
         <el-table-column prop="note" label="版本注释" align="center">

ruoyi-ui/src/views/dragform/index.vue

@@ -57,8 +57,7 @@
       >
         <el-input
           v-model="queryParams.dfDatabase"
-          placeholder="请输入数据源名称
-"
+          placeholder="请输入数据源名称"
           clearable
           @keyup.enter.native="handleQuery"
         />
@@ -524,8 +523,13 @@ export default {
           ...this.queryParams,
         },
         `form_${new Date().getTime()}.xlsx`
-      );
+      );0
     },
   },
 };
 </script>
+<style scoped lang="scss">
+::v-deep .el-form-item__label{
+  width: 85px !important;
+}
+</style>

ruoyi-ui/src/views/system/bpmnPro/components/Panel/components/ElementDocumentations.vue

@@ -5,7 +5,7 @@
         <lucide-icon name="FileText" />
       </collapse-title>
     </template>
-    <edit-item label="文档" :label-width="120">
+    <edit-item label="文档">
       <el-input
         v-model="elementDoc"
         type="textarea"

ruoyi-ui/src/views/system/bpmnPro/components/Settings/index.vue

@@ -205,3 +205,11 @@ export default {
   },
 };
 </script>
+<style scoped lang="scss">
+::v-deep .el-input--mini .el-input__inner{
+  width: 175px;
+}
+::v-deep .el-form-item__content{
+  margin-left: 0;
+}
+</style>

ruoyi-ui/src/views/system/bpmnPro/components/theme/panel.scss

@@ -63,3 +63,6 @@
     }
   }
 }
+.el-collapse-item__content{
+  margin-right: 10px;
+}