cnhis-design-vue 3.1.5-beta.13 → 3.1.5-beta.16

package/es/packages/bpmn-workflow/src/custom/customModeler/customBpmn/CustomRules2.js

@@ -0,0 +1,40 @@
+import inherits from '../../../../../../node_modules/inherits/inherits.js';
+import RuleProvider from '../../../../../../node_modules/diagram-js/lib/features/rules/RuleProvider.js';
+
+function CustomRules(eventBus, elementRegistry) {
+  this.elementRegistry = elementRegistry;
+  RuleProvider.call(this, eventBus);
+}
+inherits(CustomRules, RuleProvider);
+CustomRules.$inject = ["eventBus", "elementRegistry"];
+CustomRules.prototype.init = function() {
+  this.addRule("shape.create", 1234, function(context) {
+    let shape = context.shape;
+    let target = context.target;
+    let startElement = target.children.findIndex((item) => {
+      return item.type == "bpmn:StartEvent";
+    });
+    if (startElement > -1 && shape.type == "bpmn:StartEvent") {
+      return false;
+    }
+  });
+  this.addRule("shape.resize", function(context) {
+    var shape = context.shape;
+    if (!context.newBounds) {
+      if (!shape.resizable) {
+        return false;
+      }
+      return;
+    } else {
+      return context.newBounds.width > 10 && context.newBounds.height > 10;
+    }
+  });
+};
+CustomRules.prototype.canDrop = function() {
+  return false;
+};
+CustomRules.prototype.canMove = function() {
+  return false;
+};
+
+export { CustomRules as default };

package/es/packages/bpmn-workflow/src/custom/customModeler/customBpmn/index.js

@@ -0,0 +1 @@
+export { default } from './index2.js';

package/es/packages/bpmn-workflow/src/custom/customModeler/customBpmn/index2.js

@@ -0,0 +1,25 @@
+import PaletteProvider from './CustomPalette2.js';
+import CustomPathMap from './CustomPathMap2.js';
+import CustomRenderer from './CustomRenderer2.js';
+import BpmnRenderer from './BpmnRenderer2.js';
+import ContextPadProvider from './CustomContextPadProvider2.js';
+import CustomRules from './CustomRules2.js';
+
+var CustomModule = {
+  __init__: [
+    "paletteProvider",
+    "customPathMap",
+    "customRenderer",
+    "bpmnRenderer",
+    "contextPadProvider",
+    "customRules"
+  ],
+  paletteProvider: ["type", PaletteProvider],
+  customPathMap: ["type", CustomPathMap],
+  customRenderer: ["type", CustomRenderer],
+  bpmnRenderer: ["type", BpmnRenderer],
+  contextPadProvider: ["type", ContextPadProvider],
+  customRules: ["type", CustomRules]
+};
+
+export { CustomModule as default };

package/es/packages/bpmn-workflow/src/custom/customModeler/index.js

@@ -0,0 +1 @@
+export { default } from './index2.js';

package/es/packages/bpmn-workflow/src/custom/customModeler/index2.js

@@ -0,0 +1,12 @@
+import Modeler from 'bpmn-js/lib/Modeler';
+import inherits from '../../../../../node_modules/inherits/inherits.js';
+import CustomModule from './customBpmn/index2.js';
+
+function CustomModeler(options) {
+  Modeler.call(this, options);
+  this._customElements = [];
+}
+inherits(CustomModeler, Modeler);
+CustomModeler.prototype._modules = [].concat(CustomModeler.prototype._modules, [CustomModule]);
+
+export { CustomModeler as default };

package/es/packages/bpmn-workflow/src/custom/customOtherModule/CustomPopupMenu.js

@@ -0,0 +1 @@
+export { default } from './CustomPopupMenu2.js';

package/es/packages/bpmn-workflow/src/custom/customOtherModule/CustomPopupMenu2.js

@@ -0,0 +1,47 @@
+import PopupMenu from '../../../../../node_modules/diagram-js/lib/features/popup-menu/PopupMenu.js';
+import { forEach, omit, isFunction } from '../../../../../node_modules/min-dash/dist/index.esm.js';
+
+var CustomPopupMenu = {
+  __init__: ["popupMenu"],
+  popupMenu: ["type", PopupMenu]
+};
+PopupMenu.prototype._getEntries = function(element, providers) {
+  var entries = {};
+  forEach(providers, function(provider) {
+    if (!provider.getPopupMenuEntries) {
+      forEach(provider.getEntries(element), function(entry) {
+        var id = entry.id;
+        if (!id) {
+          throw new Error("every entry must have the id property set");
+        }
+        let display = [
+          "replace-with-inclusive-gateway",
+          "replace-with-complex-gateway",
+          "replace-with-event-based-gateway"
+        ].includes(id);
+        if (!display) {
+          entries[id] = omit(entry, ["id"]);
+        }
+      });
+      return;
+    }
+    var entriesOrUpdater = provider.getPopupMenuEntries(element);
+    if (isFunction(entriesOrUpdater)) {
+      entries = entriesOrUpdater(entries);
+    } else {
+      forEach(entriesOrUpdater, function(entry, id) {
+        let display = [
+          "replace-with-inclusive-gateway",
+          "replace-with-complex-gateway",
+          "replace-with-event-based-gateway"
+        ].includes(id);
+        if (!display) {
+          entries[id] = entry;
+        }
+      });
+    }
+  });
+  return entries;
+};
+
+export { CustomPopupMenu as default };

package/es/packages/bpmn-workflow/src/custom/customOtherModule/customViewerRenderer.js

@@ -0,0 +1 @@
+export { default } from './customViewerRenderer2.js';

package/es/packages/bpmn-workflow/src/custom/customOtherModule/customViewerRenderer2.js

@@ -0,0 +1,14 @@
+import CustomRenderer from '../customModeler/customBpmn/CustomRenderer2.js';
+import CustomRules from '../customModeler/customBpmn/CustomRules2.js';
+import CustomPathMap from '../customModeler/customBpmn/CustomPathMap2.js';
+import BpmnRenderer from '../customModeler/customBpmn/BpmnRenderer2.js';
+
+var customViewerRenderer = {
+  __init__: ["customPathMap", "customRenderer", "bpmnRenderer", "customRules"],
+  customPathMap: ["type", CustomPathMap],
+  customRenderer: ["type", CustomRenderer],
+  bpmnRenderer: ["type", BpmnRenderer],
+  customRules: ["type", CustomRules]
+};
+
+export { customViewerRenderer as default };

package/es/packages/bpmn-workflow/src/custom/customOtherModule/zoomScroll.js

@@ -0,0 +1 @@
+export { default } from './zoomScroll2.js';

package/es/packages/bpmn-workflow/src/custom/customOtherModule/zoomScroll2.js

@@ -0,0 +1,10 @@
+import ZoomScroll$1 from '../../../../../node_modules/diagram-js/lib/navigation/zoomscroll/ZoomScroll.js';
+
+ZoomScroll$1.prototype.scroll = () => {
+};
+var ZoomScroll = {
+  __init__: ["zoomScroll"],
+  zoomScroll: ["type", ZoomScroll$1]
+};
+
+export { ZoomScroll as default };

package/es/packages/bpmn-workflow/src/custom/customRules/no-task.js

@@ -0,0 +1 @@
+export { default } from './no-task2.js';

package/es/packages/bpmn-workflow/src/custom/customTranslate/customTranslate.js

@@ -0,0 +1 @@
+export { default } from './customTranslate2.js';

package/es/packages/bpmn-workflow/src/custom/customTranslate/zh.js

@@ -0,0 +1 @@
+export { default } from './zh2.js';

package/es/packages/button-print/index.js

@@ -0,0 +1 @@
+export { default } from './index2.js';

package/es/packages/button-print/index2.js

@@ -0,0 +1,11 @@
+import { COMPONENT_NAMESPACE } from '../../src/global/variable';
+import { safeComponentRegister } from '../../src/utils';
+import './src/ButtonPrint2.js';
+import script from './src/ButtonPrint.vue_vue_type_script_setup_true_lang.js';
+
+const ButtonPrint = script;
+ButtonPrint.install = function(app) {
+  safeComponentRegister(app, ButtonPrint, COMPONENT_NAMESPACE + "ButtonPrint");
+};
+
+export { ButtonPrint as default };

package/es/packages/button-print/src/ButtonPrint.js

@@ -0,0 +1,2 @@
+import './ButtonPrint2.js';
+export { default } from './ButtonPrint.vue_vue_type_script_setup_true_lang.js';

package/es/packages/button-print/src/ButtonPrint.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,440 @@
+import { defineComponent, reactive, computed, onMounted, watch, openBlock, createElementBlock, Fragment, createVNode, unref, withCtx, renderSlot, withModifiers, createCommentVNode, createTextVNode, toDisplayString, mergeProps } from 'vue';
+import { useMessage, NDropdown, NButton, NIcon } from 'naive-ui';
+import { ChevronDown } from '@vicons/ionicons5';
+import Yi from './utils/print.es.min2.js';
+import './components/IdentityVerification2.js';
+import moment from 'moment';
+import script$1 from './components/IdentityVerification.vue_vue_type_script_setup_true_lang.js';
+
+var script = /* @__PURE__ */ defineComponent({
+  props: {
+    printParams: {
+      type: Array
+    },
+    params: {
+      default: () => [],
+      type: Array
+    },
+    btnText: {
+      default: "\u6253\u5370",
+      type: String
+    },
+    printText: {
+      default: "\u76F4\u63A5\u6253\u5370",
+      type: String
+    },
+    previewText: {
+      default: "\u6253\u5370\u9884\u89C8",
+      type: String
+    },
+    formatEditText: {
+      default: "\u683C\u5F0F\u7F16\u8F91",
+      type: String
+    },
+    prevFn: {
+      default: () => Promise.resolve(),
+      type: Function
+    },
+    queryPrintFormatByNumber: {
+      default: () => Promise.resolve({}),
+      type: Function
+    },
+    queryTemplateParams: {
+      default: () => Promise.resolve({}),
+      type: Function
+    },
+    strategy: {
+      default: "MULTI",
+      type: String
+    },
+    clickPrevFn: {
+      default: () => Promise.resolve(true),
+      type: Function
+    },
+    noDataMsg: {
+      default: "\u8BF7\u9009\u4E2D\u9700\u8981\u6253\u5370\u7684\u6570\u636E",
+      type: String
+    }
+  },
+  emits: ["success", "error", "clickoutside"],
+  setup(__props, {
+    emit
+  }) {
+    const props = __props;
+    const $message = useMessage();
+    let printInstance = null;
+    const state = reactive({
+      spinning: false,
+      visible: false,
+      formatList: [],
+      templateParams: {},
+      printParams: [],
+      currentFormatId: "",
+      identityVerification: {
+        visible: false
+      },
+      isInited: false,
+      watchPrintParamsReformatFn: null,
+      spinTimer: null
+    });
+    const options = reactive([{
+      label: props.printText,
+      key: "printText"
+    }, {
+      label: props.previewText,
+      key: "previewText"
+    }, {
+      label: props.formatEditText,
+      key: "formatEditText"
+    }]);
+    const currentFormatItem = computed(() => {
+      if (!state.currentFormatId)
+        return {};
+      let id = state.currentFormatId;
+      return state.formatList.find((item) => item.id === id);
+    });
+    const formatTitle = computed(() => currentFormatItem.value.name || "\u683C\u5F0F\u9009\u62E9");
+    const renderLabel = (option) => {
+      return createVNode("span", {
+        "class": {
+          active: option.key === state.currentFormatId
+        }
+      }, [option.label]);
+    };
+    const getTemplateIdByFormatId = (id) => {
+      let find = state.formatList.find((item) => item.id === id);
+      return find.templateId;
+    };
+    const callLocalServicesSuccessCb = (res, type) => {
+      let info = {
+        type,
+        formatId: state.currentFormatId,
+        templateId: getTemplateIdByFormatId(state.currentFormatId)
+      };
+      emit("success", res, info);
+    };
+    const callLocalServicesErrorCb = (res) => {
+      emit("error", res);
+    };
+    const prevFnError = () => {
+      let error = {
+        message: "\u524D\u7F6E\u6761\u4EF6\u6267\u884C\u9519\u8BEF"
+      };
+      emit("error", error);
+    };
+    const getPrintParams = (index = 0) => {
+      var _a;
+      const params = ((_a = props.printParams) == null ? void 0 : _a.length) ? props.printParams[index] : state.printParams[index];
+      return JSON.stringify(params);
+    };
+    const getOnceParams = () => {
+      var _a, _b;
+      let params = {};
+      let obj = {};
+      if ((_a = state.templateParams.customizeDataset) == null ? void 0 : _a.length) {
+        const key = ((_b = Object.keys(state.printParams[0].datasetData || {})) == null ? void 0 : _b[0]) || "";
+        const datasetDataKeyVal = JSON.stringify(state.printParams.map((v) => JSON.parse(v.datasetData[key])));
+        obj = {
+          datasetData: {}
+        };
+        obj.datasetData[key] = datasetDataKeyVal;
+      } else {
+        Object.keys(state.printParams[0]).forEach((v) => {
+          obj[v] = [];
+          state.printParams.forEach((k) => {
+            obj[v].push(k[v]);
+          });
+          obj[v] = obj[v].join(",");
+        });
+      }
+      params = Object.assign({}, JSON.parse(getPrintParams(0)), obj);
+      return JSON.stringify(params);
+    };
+    const handleClickPrint = () => {
+      let len = state.printParams.length;
+      const callLocalServicesSuccessCbTmp = async (data) => {
+        try {
+          if (--len <= 0) {
+            callLocalServicesSuccessCb(data, "print");
+          }
+        } catch (error) {
+          console.log("error", error);
+        }
+      };
+      props.prevFn().catch(() => {
+        prevFnError();
+        return Promise.reject();
+      }).then(() => {
+        if (props.strategy === "MULTI") {
+          for (let i = 0; i < state.printParams.length; i++) {
+            const queryParams = {
+              formatId: state.currentFormatId,
+              templateId: getTemplateIdByFormatId(state.currentFormatId),
+              params: getPrintParams(i)
+            };
+            printInstance.printDirect(queryParams, callLocalServicesSuccessCbTmp, callLocalServicesErrorCb);
+          }
+        } else {
+          const queryParams = {
+            formatId: state.currentFormatId,
+            templateId: getTemplateIdByFormatId(state.currentFormatId),
+            params: getOnceParams()
+          };
+          printInstance.printDirect(queryParams, (res) => {
+            callLocalServicesSuccessCb(res, "print");
+          }, callLocalServicesErrorCb);
+        }
+      }).finally(() => {
+        state.visible = false;
+      });
+    };
+    const handleClickPreview = async () => {
+      props.prevFn().catch(() => {
+        prevFnError();
+        return Promise.reject();
+      }).then(() => {
+        const params = props.strategy === "MULTI" ? getPrintParams() : getOnceParams();
+        const queryParams = {
+          formatId: state.currentFormatId,
+          templateId: getTemplateIdByFormatId(state.currentFormatId),
+          params
+        };
+        printInstance.preview(queryParams, (res) => {
+          callLocalServicesSuccessCb(res, "preview");
+        }, callLocalServicesErrorCb);
+      }).finally(() => {
+        state.visible = false;
+      });
+    };
+    const handleClickEdit = () => {
+      props.prevFn().catch(() => {
+        prevFnError();
+        return Promise.reject();
+      }).then(() => {
+        state.identityVerification.visible = true;
+      }).finally(() => {
+        state.visible = false;
+      });
+    };
+    const handleSelect = (key) => {
+      switch (key) {
+        case "printText":
+          handleClickPrint();
+          break;
+        case "previewText":
+          handleClickPreview();
+          break;
+        case "formatEditText":
+          handleClickEdit();
+          break;
+        default:
+          state.currentFormatId = key;
+          state.visible = false;
+          break;
+      }
+    };
+    const handleClickOutside = () => {
+      state.visible = false;
+      emit("clickoutside");
+    };
+    const instantiatePrintSDK = () => {
+      if (printInstance)
+        return false;
+      printInstance = new Yi();
+    };
+    const getDefaultFormatId = (list, key) => {
+      if (!(list == null ? void 0 : list.length))
+        return "";
+      let findDefault = list.find((item) => item[key] == 1);
+      return (findDefault == null ? void 0 : findDefault.id) || list[0].id;
+    };
+    const setOptions = () => {
+      const children = state.formatList.map((v) => {
+        return {
+          label: v.name,
+          key: v.id
+        };
+      });
+      options.unshift({
+        label: formatTitle.value,
+        key: "format",
+        children
+      });
+    };
+    const formatFormatList = (list) => {
+      let formatList = [];
+      list && list.forEach((item) => {
+        if (!item.format)
+          return false;
+        formatList.push(...item.format);
+      });
+      return formatList;
+    };
+    const requestError = () => {
+      state.isInited = false;
+      state.spinning = false;
+      setTimeout(() => {
+        state.visible = false;
+      }, 0);
+      return false;
+    };
+    const formatDefaultVal = (i, tableVal) => {
+      let val = i.defaultValue || "";
+      let tVal = tableVal;
+      if (i.type === "NUMBER") {
+        tVal = Number(tableVal) || 0;
+      }
+      if (i.type === "DATE") {
+        tVal = tableVal ? moment(tableVal).format("YYYY-MM-DD") : "";
+      }
+      if (i.type === "DATETIME") {
+        tVal = tableVal ? moment(tableVal).format("YYYY-MM-DD HH:mm:ss") : "";
+      }
+      return val ? val : tVal;
+    };
+    const formatPrintParams = (paramObj, fieldList, keyName) => {
+      const obj = {};
+      fieldList.forEach((i) => {
+        let defaultVal = formatDefaultVal(i, paramObj[i[keyName]]);
+        if (paramObj[i[keyName]] && defaultVal) {
+          obj[i[keyName]] = defaultVal;
+        }
+      });
+      return obj;
+    };
+    const formatParams = ({
+      customizeDataset = [],
+      param = []
+    }, params = []) => {
+      return params.map((paramObj) => {
+        let res = {};
+        customizeDataset.forEach((dataSetItem) => {
+          const selectFieldList = dataSetItem.dataSetting[0].selectFieldList;
+          res["datasetData"] = {
+            [dataSetItem.name]: JSON.stringify(formatPrintParams(paramObj, selectFieldList, "fieldName"))
+          };
+        });
+        res = Object.assign({}, res, formatPrintParams(paramObj, param, "key"));
+        return res;
+      });
+    };
+    const initCRM = async (formatListResult) => {
+      var _a;
+      state.formatList = formatListResult ? formatFormatList(formatListResult.obj) : [];
+      console.log("formatListResult", formatListResult);
+      state.currentFormatId = getDefaultFormatId(state.formatList, "defaultFlag");
+      setOptions();
+      if (!state.currentFormatId) {
+        $message.error("\u83B7\u53D6\u6253\u5370\u683C\u5F0F\u5931\u8D25\uFF0C\u8BF7\u8054\u7CFB\u7BA1\u7406\u5458\uFF01");
+        return requestError();
+      }
+      if (!state.currentFormatId) {
+        requestError();
+        return;
+      }
+      let templateParamsResult = ((_a = await props.queryTemplateParams()) == null ? void 0 : _a.obj) || {};
+      if (templateParamsResult) {
+        state.templateParams = templateParamsResult;
+      } else {
+        return requestError();
+      }
+      state.printParams = formatParams(state.templateParams, props.params);
+    };
+    const init = async () => {
+      if (state.isInited)
+        return true;
+      state.isInited = true;
+      state.spinning = true;
+      instantiatePrintSDK();
+      const formatListResult = await props.queryPrintFormatByNumber();
+      await initCRM(formatListResult);
+      state.spinning = false;
+      return true;
+    };
+    const handleClickBtn = async () => {
+      var _a;
+      const status = await props.clickPrevFn();
+      if (!status)
+        return;
+      if (!((_a = props.params) == null ? void 0 : _a.length)) {
+        $message.warning(props.noDataMsg);
+        return;
+      }
+      if (!state.visible) {
+        let result = await init();
+        if (!result)
+          return false;
+      }
+      state.visible = !state.visible;
+    };
+    const reformatPrintParams = () => {
+      state.watchPrintParamsReformatFn && state.watchPrintParamsReformatFn();
+      if (!state.isInited) {
+        state.watchPrintParamsReformatFn = () => watch(() => state.isInited, (val) => {
+          if (!val)
+            return false;
+          reformatPrintParams();
+        });
+        return;
+      }
+      state.printParams = formatParams(state.templateParams, props.params);
+    };
+    const verifiySuccess = (token) => {
+      state.identityVerification.visible = false;
+      const queryParams = {
+        formatId: state.currentFormatId,
+        templateId: getTemplateIdByFormatId(state.currentFormatId),
+        params: getPrintParams(),
+        token
+      };
+      printInstance.editPrintFormat(queryParams, (res) => {
+        callLocalServicesSuccessCb(res, "edit");
+      }, callLocalServicesErrorCb);
+    };
+    onMounted(() => {
+      state.isInited = false;
+    });
+    watch(() => props.params, (val) => {
+      if (!(val == null ? void 0 : val.length))
+        return false;
+      reformatPrintParams();
+    }, {
+      deep: true
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock(Fragment, null, [createVNode(unref(NDropdown), {
+        class: "c-dropdown",
+        placement: "bottom-start",
+        trigger: "click",
+        show: unref(state).visible,
+        onClickoutside: handleClickOutside,
+        options: unref(options),
+        onSelect: handleSelect,
+        "render-label": renderLabel
+      }, {
+        default: withCtx(() => [renderSlot(_ctx.$slots, "button", {
+          handleClickPrintBtn: handleClickBtn,
+          printSpinning: unref(state).spinning,
+          printbtnText: __props.btnText,
+          printVisible: unref(state).visible
+        }, () => [createVNode(unref(NButton), {
+          class: "dropdown-button",
+          onClick: withModifiers(handleClickBtn, ["stop"])
+        }, {
+          default: withCtx(() => [createCommentVNode(' <n-spin v-show="state.spinning" size="small"></n-spin> '), createTextVNode(toDisplayString(__props.btnText) + " ", 1), createVNode(unref(NIcon), {
+            component: unref(ChevronDown)
+          }, null, 8, ["component"])]),
+          _: 1
+        }, 8, ["onClick"])])]),
+        _: 3
+      }, 8, ["show", "options"]), createVNode(script$1, mergeProps({
+        modelValue: unref(state).identityVerification.visible,
+        "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => unref(state).identityVerification.visible = $event)
+      }, _ctx.$attrs, {
+        onSuccess: verifiySuccess
+      }), null, 16, ["modelValue"])], 64);
+    };
+  }
+});
+
+export { script as default };

package/es/packages/button-print/src/ButtonPrint2.js

@@ -0,0 +1,4 @@
+import script from './ButtonPrint.vue_vue_type_script_setup_true_lang.js';
+export { default } from './ButtonPrint.vue_vue_type_script_setup_true_lang.js';
+
+script.__file = "packages/button-print/src/ButtonPrint.vue";

package/es/packages/button-print/src/components/IdentityVerification.js

@@ -0,0 +1,2 @@
+import './IdentityVerification2.js';
+export { default } from './IdentityVerification.vue_vue_type_script_setup_true_lang.js';