cnhis-design-vue 3.1.23-beta.8 → 3.1.23

package/es/components/button-print/src/utils/print.js

@@ -1 +1,357 @@
-export { Print } from './print2.js';
+import axios from 'axios';
+import { isArray } from 'lodash-es';
+import { IdentityVerificationDialog } from './dialog.js';
+
+const PRINT_ORIGIN = "http://127.0.0.1:11111";
+const EDIT_LOCAL_URL = `${PRINT_ORIGIN}/services/print`;
+const PRINT_URL = `${PRINT_ORIGIN}/PrintLocal`;
+const PDF_URL = `${PRINT_ORIGIN}/download`;
+const PRINT_CMD_ID = "7";
+const PREVIEW_CMD_ID = "8";
+const PRINTER_NAME_DEFAULT = "Default";
+const testHttpFn = axios.create({
+  timeout: 1e3,
+  withCredentials: false
+});
+const httpFn = axios.create({ withCredentials: false });
+class Print {
+  constructor() {
+    this.dialog = new IdentityVerificationDialog();
+    this.messageHandlerQueue = [];
+    var _a;
+    const _window = window;
+    this.webview = (_a = _window.chrome) == null ? void 0 : _a.webview;
+    if (!this.webview)
+      return;
+    this.currentMessageHandler = this.messageHandler.bind(this);
+    this.webview.addEventListener("message", this.currentMessageHandler);
+  }
+  messageHandler(e) {
+    const handler = this.messageHandlerQueue.pop();
+    if (!handler)
+      return console.log("\u5F53\u524D\u56DE\u6267", e, "\u6CA1\u6709\u53EF\u7528\u7684handler");
+    const { resolve, reject } = handler;
+    try {
+      console.log(e);
+      resolve(JSON.parse(e.data).res);
+    } catch (e2) {
+      reject(e2);
+    }
+  }
+  async postMessage(data) {
+    if (!this.webview)
+      return Promise.reject();
+    return new Promise((resolve, reject) => {
+      this.messageHandlerQueue.push({ resolve, reject });
+      this.webview.postMessage(data);
+    });
+  }
+  destroy() {
+    if (this.webview && this.currentMessageHandler) {
+      this.webview.removeEventListener("message", this.currentMessageHandler);
+      this.currentMessageHandler = void 0;
+    }
+  }
+  show(...args) {
+    return this.dialog.show(...args);
+  }
+  _testConnection() {
+    if (this.webview)
+      return Promise.resolve(true);
+    return new Promise((resolve) => {
+      testHttpFn({
+        url: `${PRINT_ORIGIN}/test`,
+        method: "get",
+        withCredentials: false,
+        params: {
+          inputdata: {
+            result: "success"
+          }
+        }
+      }).then(({ data }) => {
+        if (data.result !== "success") {
+          resolve(false);
+          return;
+        }
+        resolve(true);
+      }).catch((err) => {
+        resolve(false);
+      });
+    });
+  }
+  _queryServicesPrint(params) {
+    if (this.webview) {
+      return this.postMessage({ exec: "print", data: { inputData: params } });
+    }
+    return httpFn({
+      url: EDIT_LOCAL_URL,
+      method: "get",
+      params: {
+        inputData: JSON.stringify(params)
+      }
+    }).then(({ data }) => {
+      return data;
+    });
+  }
+  _callPrintWithFile(queryParams) {
+    const defaultQueryParams = {
+      cmdid: PRINT_CMD_ID,
+      flag: "1"
+    };
+    const params = {
+      inputData: JSON.stringify(Object.assign({}, defaultQueryParams, queryParams))
+    };
+    if (this.webview) {
+      return this.postMessage({ exec: "print", data: transformData(params) });
+    }
+    return httpFn({
+      url: PRINT_URL,
+      method: "post",
+      data: params,
+      transformRequest: [transformData]
+    }).then(({ data }) => {
+      return data;
+    });
+    function transformData(oldData) {
+      let newStr = "";
+      for (const item in oldData) {
+        newStr += encodeURIComponent(item) + "=" + encodeURIComponent(oldData[item]) + "&";
+      }
+      newStr = newStr.slice(0, -1);
+      return newStr;
+    }
+  }
+  _handleResult(data, errorCallbackFn) {
+    if (data.result !== "success") {
+      const message = data.message || data.Message;
+      const errorMsgObj = {
+        type: "printError",
+        message,
+        result: data.result,
+        errinfo: data.errinfo
+      };
+      errorCallbackFn == null ? void 0 : errorCallbackFn(errorMsgObj);
+      return false;
+    }
+    return data;
+  }
+  _handleResultTest(result, errorCallbackFn) {
+    if (!result) {
+      console.log("notInstalledApp");
+      errorCallbackFn == null ? void 0 : errorCallbackFn({
+        type: "notInstalledApp",
+        message: "\u8BF7\u6253\u5F00\u6253\u5370\u670D\u52A1\u5668\u63D2\u4EF6"
+      });
+      return false;
+    }
+    return true;
+  }
+  async _handleEventQueryPrintData(templateId, formatId, params, errorCallbackFn) {
+    const queryParams = {
+      templateId,
+      formatId,
+      params,
+      cmdid: PRINT_CMD_ID
+    };
+    const printData = await this._queryServicesPrint(queryParams);
+    return this._handleQueryPrintDataResult(printData, formatId, errorCallbackFn);
+  }
+  _handleQueryPrintDataResult(printData, formatId, errorCallbackFn) {
+    if (!(printData == null ? void 0 : printData.file)) {
+      try {
+        const message = printData.message || printData.Message;
+        console.log(message);
+        errorCallbackFn == null ? void 0 : errorCallbackFn({
+          type: "queryPrintDataFailure",
+          message
+        });
+      } catch (err) {
+        console.log(err);
+      }
+      return false;
+    }
+    return {
+      file: printData.file,
+      printerName: printData.defprinter,
+      pageCount: printData.pagecount,
+      formatId
+    };
+  }
+  async _handleEventDirect({
+    templateId,
+    formatId,
+    params,
+    cmdid,
+    print,
+    printdlgshow = "1",
+    nobillnode = "1"
+  }) {
+    const queryParams = {
+      templateId,
+      formatId,
+      params,
+      cmdid,
+      nobillnode,
+      printdlgshow
+    };
+    if (print) {
+      try {
+        print = JSON.parse(print);
+      } catch (error) {
+      }
+      queryParams.print = print;
+    }
+    return await this._queryServicesPrint(queryParams);
+  }
+  async _handleEventEditFormat({ templateId, formatId = "", params = "", token }) {
+    const DEFAULT_PARAMS = {};
+    let formatParams = {};
+    try {
+      formatParams = Object.assign({}, DEFAULT_PARAMS, JSON.parse(params));
+    } catch (error) {
+      formatParams = DEFAULT_PARAMS;
+    }
+    const queryParams = {
+      templateId,
+      formatId,
+      cmdid: "9",
+      token,
+      params: JSON.stringify(formatParams)
+    };
+    return await this._queryServicesPrint(queryParams);
+  }
+  async preview({ templateId, formatId, params = "" }, successCallbackFn, errorCallbackFn) {
+    const testResult = await this._testConnection();
+    if (!this._handleResultTest(testResult, errorCallbackFn))
+      return false;
+    const result = await this._handleEventDirect({
+      templateId,
+      formatId,
+      params,
+      cmdid: PREVIEW_CMD_ID
+    });
+    if (!result)
+      return false;
+    const handledResult = this._handleResult(result, errorCallbackFn);
+    if (!handledResult)
+      return false;
+    successCallbackFn && successCallbackFn(handledResult);
+  }
+  async printDirect({ templateId, formatId, params = "", print, printdlgshow, nobillnode }, successCallbackFn, errorCallbackFn) {
+    const testResult = await this._testConnection();
+    if (!this._handleResultTest(testResult, errorCallbackFn))
+      return false;
+    const result = await this._handleEventDirect({
+      templateId,
+      formatId,
+      params,
+      cmdid: PRINT_CMD_ID,
+      print,
+      printdlgshow,
+      nobillnode
+    });
+    if (!result)
+      return false;
+    const handledResult = this._handleResult(result, errorCallbackFn);
+    if (!handledResult)
+      return false;
+    successCallbackFn && successCallbackFn(handledResult);
+  }
+  _downloadPDF(inputData) {
+    if (this.webview) {
+      return this.postMessage({ exec: "pdf", data: { file: inputData } });
+    }
+    return httpFn.get(PDF_URL, { params: { inputData } }).then(({ data }) => data);
+  }
+  downloadPDF(params, onResolve, onReject) {
+    this.printDirect(
+      params,
+      async (res) => {
+        if (!res)
+          onReject(null);
+        onResolve(await this._downloadPDF(getFiledir(res.filedir)));
+        function getFiledir(filedir) {
+          const result = JSON.parse(filedir);
+          return isArray(result) ? result[0] || "" : "";
+        }
+      },
+      (err) => onReject(err)
+    );
+  }
+  async print({ templateId, formatId, params = "" }, successCallbackFn, errorCallbackFn) {
+    const testResult = await this._testConnection();
+    if (!this._handleResultTest(testResult, errorCallbackFn))
+      return false;
+    const printData = await this.queryPrintData({ templateId, formatId, params }, void 0, errorCallbackFn);
+    if (!printData)
+      return false;
+    const handledResult = this.printFileData(
+      {
+        formatId,
+        file: printData.file,
+        printerName: printData.printerName
+      },
+      void 0,
+      errorCallbackFn
+    );
+    if (!handledResult)
+      return false;
+    successCallbackFn && successCallbackFn(handledResult);
+  }
+  async queryPrintData({ templateId, formatId, params = "" }, successCallbackFn, errorCallbackFn) {
+    const testResult = await this._testConnection();
+    if (!this._handleResultTest(testResult, errorCallbackFn))
+      return false;
+    const result = await this._handleEventQueryPrintData(templateId, formatId, params, errorCallbackFn);
+    if (!result)
+      return false;
+    successCallbackFn && successCallbackFn(result);
+    return result;
+  }
+  async printFileData({ formatId, file, printerName = PRINTER_NAME_DEFAULT }, successCallbackFn, errorCallbackFn) {
+    const testResult = await this._testConnection();
+    if (!this._handleResultTest(testResult, errorCallbackFn))
+      return false;
+    const result = await this._callPrintWithFile({
+      formatId,
+      printname: printerName,
+      file
+    });
+    const handledResult = this._handleResult(result, errorCallbackFn);
+    if (!handledResult)
+      return false;
+    successCallbackFn && successCallbackFn(handledResult);
+    return handledResult;
+  }
+  async editPrintFormat({ templateId, formatId, params, token }, successCallbackFn, errorCallbackFn) {
+    const testResult = await this._testConnection();
+    if (!this._handleResultTest(testResult, errorCallbackFn))
+      return false;
+    const result = await this._handleEventEditFormat({
+      templateId,
+      formatId,
+      params,
+      token
+    });
+    const handledResult = this._handleResult(result, errorCallbackFn);
+    if (!handledResult)
+      return false;
+    successCallbackFn && successCallbackFn(handledResult);
+  }
+  async addPrintFormat({ templateId, params, token }, successCallbackFn, errorCallbackFn) {
+    const testResult = await this._testConnection();
+    if (!this._handleResultTest(testResult, errorCallbackFn))
+      return false;
+    const result = await this._handleEventEditFormat({
+      templateId,
+      params,
+      token
+    });
+    const handledResult = this._handleResult(result, errorCallbackFn);
+    if (!handledResult)
+      return false;
+    successCallbackFn && successCallbackFn(handledResult);
+  }
+}
+
+export { Print };

package/es/components/chunk-upload/index.d.ts

@@ -209,7 +209,7 @@ declare const VodChunkUpload: SFCWithInstall<import("vue").DefineComponent<{
             type: NumberConstructor;
             default: number;
         };
-    }, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    }, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
         visible: BooleanConstructor;
         formData: {
             type: ObjectConstructor;

package/es/components/chunk-upload/index.js

@@ -1 +1,14 @@
-export { default } from './index2.js';
+import { COMPONENT_NAMESPACE } from '../../shared/global/variable.js';
+import script from './src/vod-chunk-upload/vod-chunk-upload.js';
+import uploader from 'vue-simple-uploader';
+import 'vue-simple-uploader/dist/style.css';
+import { safeComponentRegister } from '../../shared/utils/index.js';
+import '../../shared/utils/utilExpand.js';
+
+const VodChunkUpload = script;
+VodChunkUpload.install = function(app) {
+  app.use(uploader);
+  safeComponentRegister(app, VodChunkUpload, COMPONENT_NAMESPACE + "VodChunkUpload");
+};
+
+export { VodChunkUpload as default };

package/es/components/chunk-upload/src/chunk-upload-new.js

@@ -2,8 +2,8 @@ import { defineComponent, ref, reactive, onMounted, nextTick, onUnmounted, resol
 import SparkMD5 from 'spark-md5';
 import axios from 'axios';
 import { useMessage, NIcon, NProgress, NButton } from 'naive-ui';
-import { UploadProps, getUploadData, statusSet } from './hooks/upload-data2.js';
-import { UploadComputed } from './hooks/upload-computed2.js';
+import { UploadProps, getUploadData, statusSet } from './hooks/upload-data.js';
+import { UploadComputed } from './hooks/upload-computed.js';
 import { FolderOutline, DocumentAttachOutline, Close } from '@vicons/ionicons5';
 import _export_sfc from '../../../_virtual/plugin-vue_export-helper.js';
 
@@ -21,7 +21,6 @@ const _hoisted_11 = { class: "c-f-item-info-time" };
 const _hoisted_12 = { class: "c-f-item-btn" };
 const _hoisted_13 = { class: "upload-btn" };
 const _hoisted_14 = /* @__PURE__ */ createElementVNode("span", null, "\u4E0A\u4F20\u65B0\u6587\u4EF6", -1);
-const _hoisted_15 = /* @__PURE__ */ createTextVNode("\u5F00\u59CB\u4E0A\u4F20");
 const _sfc_main = /* @__PURE__ */ defineComponent({
   __name: "chunk-upload-new",
   props: { ...UploadProps },
@@ -236,11 +235,14 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
         return;
       }
       statusSet(file, "merging");
-      mergeRequest({
-        md5: file.uniqueIdentifier,
-        fileName: file.name,
-        fileChunkNum: file.chunks.length
-      }, file);
+      mergeRequest(
+        {
+          md5: file.uniqueIdentifier,
+          fileName: file.name,
+          fileChunkNum: file.chunks.length
+        },
+        file
+      );
       if (res.needMerge) {
         statusSet(file, "merging");
       }
@@ -458,7 +460,7 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
                 onClick: handleStartUpload
               }, {
                 default: withCtx(() => [
-                  _hoisted_15
+                  createTextVNode("\u5F00\u59CB\u4E0A\u4F20")
                 ]),
                 _: 1
               })

package/es/components/chunk-upload/src/hooks/upload-computed.js

@@ -1 +1,70 @@
-export { UploadComputed } from './upload-computed2.js';
+import { computed } from 'vue';
+
+const UploadComputed = (props, state, config) => {
+  const handleProcessHeaders = () => {
+    return {
+      Authorization: "bearer " + state.uploadConfig.token
+    };
+  };
+  const handleGetTargetUrl = (file) => {
+    var _a;
+    return ((_a = state == null ? void 0 : state.uploadConfig) == null ? void 0 : _a.partFileUpload) || "";
+  };
+  const handleProcessParams = (params, file) => {
+    let res = {
+      channel: channel.value,
+      md5: file.uniqueIdentifier,
+      name: params.filename,
+      chunk: params.chunkNumber - 1,
+      chunks: params.totalChunks,
+      chunkSize: params.currentChunkSize
+    };
+    return res || params;
+  };
+  const processResponse = (response, cb, file, Chunk) => {
+    cb(null, response);
+  };
+  const parseTimeRemaining = (timeRemaining, parsedTimeRemaining) => {
+    return parsedTimeRemaining.replace(/\syears?/, "\u5E74").replace(/\days?/, "\u5929").replace(/\shours?/, "\u5C0F\u65F6").replace(/\sminutes?/, "\u5206\u949F").replace(/\sseconds?/, "\u79D2");
+  };
+  const initState = () => {
+    state.options.target = handleGetTargetUrl;
+    state.options.headers = handleProcessHeaders;
+    state.options.processParams = handleProcessParams;
+    state.options.parseTimeRemaining = parseTimeRemaining;
+    state.options.processResponse = processResponse;
+  };
+  const autoStart = computed(() => {
+    return false;
+  });
+  const btnAttrs = computed(() => {
+    return {
+      accept: props.propsCategoryMap
+    };
+  });
+  const channel = computed(() => {
+    let obj = state.uploadConfig;
+    if (Object.keys(obj || {}).length === 0) {
+      return void 0;
+    }
+    let res = props.uploaderType === "file" ? obj.fileChannel : obj.channel;
+    return res || obj.fileChannel;
+  });
+  const uploadArguments = computed(() => {
+    return {
+      type: props.uploaderType,
+      channel: channel.value
+    };
+  });
+  computed(() => {
+    return { ...uploadArguments.value, share: state.share };
+  });
+  return {
+    initState,
+    uploadArguments,
+    autoStart,
+    btnAttrs
+  };
+};
+
+export { UploadComputed };

package/es/components/chunk-upload/src/hooks/upload-data.js

@@ -1 +1,96 @@
-export { UploadProps, getUploadData, statusSet } from './upload-data2.js';
+const getUploadData = () => {
+  const UploadState = {
+    spinning: false,
+    uploadConfig: {},
+    progress: 0,
+    options: {
+      target: {},
+      chunkSize: 3 * 1024 * 1024,
+      fileParameterName: "file",
+      maxChunkRetries: 3,
+      simultaneousUploads: 3,
+      prioritizeFirstAndLastChunk: true,
+      forceChunkSize: true,
+      testChunks: false,
+      headers: {},
+      query() {
+      },
+      processParams: {},
+      parseTimeRemaining: {},
+      processResponse: {}
+    },
+    attrs: {},
+    collapse: false,
+    configList: [],
+    share: 1,
+    baseUrl: "http://192.168.20.113:12060",
+    headers: {
+      Authorization: "bearer d012a22a9f284801b1bed4c20f3715de"
+    },
+    withCredentials: false
+  };
+  return { UploadState };
+};
+const UploadProps = {
+  propsCategoryMap: { type: String, default: "" },
+  max_size: { type: String, default: "" },
+  maxLength: { type: Number, default: 0 },
+  defaultList: { type: Array, default: () => [] },
+  uploaderType: { type: String, default: "video" },
+  getChunkUploadConfig: { type: Function, default: () => Promise.resolve({}) }
+};
+const statusSet = (file, status) => {
+  let statusMap = {
+    init: {
+      status: "init",
+      text: "\u521D\u59CB\u5316\u4E2D",
+      bgc: "#fff"
+    },
+    md5: {
+      status: "md5",
+      text: "\u6821\u9A8CMD5",
+      bgc: "#fff"
+    },
+    ready: {
+      status: "ready",
+      text: "\u521D\u59CB\u5316\u5B8C\u6210",
+      bgc: "#fff"
+    },
+    merging: {
+      status: "merging",
+      text: "\u5408\u5E76\u4E2D",
+      bgc: "#e2eeff"
+    },
+    uploading: {
+      status: "uploading",
+      text: "\u4E0A\u4F20\u4E2D",
+      bgc: "#e2eeff"
+    },
+    transcoding: {
+      status: "transcoding",
+      text: "\u8F6C\u7801\u4E2D",
+      bgc: "#e2eeff"
+    },
+    paused: {
+      status: "paused",
+      text: "\u6682\u505C",
+      bgc: "#e2eeff"
+    },
+    failed: {
+      status: "failed",
+      text: "\u4E0A\u4F20\u5931\u8D25",
+      bgc: "#e2eeff"
+    },
+    complete: {
+      status: "complete",
+      text: "\u4E0A\u4F20\u5B8C\u6210",
+      bgc: "#e2eeff"
+    }
+  };
+  if (status === "failed") {
+    file.pause && file.pause();
+  }
+  file.file_upload_status = { ...statusMap[status] };
+};
+
+export { UploadProps, getUploadData, statusSet };

package/es/components/chunk-upload/src/hooks/vod-computed.js

@@ -1 +1,79 @@
-export { VodComputed } from './vod-computed2.js';
+import { computed } from 'vue';
+
+const defaultAccept = ".mp4,.ts,.mov,.mxf,.mpg,.flv,.wmv,.avi,.m4v,.f4v,.mpeg,.3gp,.asf,.mkv,.hls";
+const VodComputed = (props, state, config) => {
+  let { mainForm } = config;
+  const isShowBtn = computed(() => {
+    var _a;
+    let { max_length } = ((_a = props.formData) == null ? void 0 : _a.validate) || {};
+    if (props.source == "guage") {
+      max_length = +props.limitNum;
+    }
+    if (max_length) {
+      return state.fileList.length < max_length;
+    }
+    return true;
+  });
+  const maskHeight = computed(() => (item) => {
+    return `${item.percent}%`;
+  });
+  const showPercent = computed(() => (percent) => {
+    let res = percent > 99 ? 99 : percent;
+    return Math.floor(res);
+  });
+  const allow_format = computed(() => {
+    if (props.source === "guage")
+      return defaultAccept;
+    const { allow_format: allow_format2 } = props.formData;
+    try {
+      if (allow_format2) {
+        let list = allow_format2.split(",");
+        let resList = list.map((v) => {
+          if (v.startsWith(".")) {
+            return v;
+          } else {
+            return "." + v;
+          }
+        });
+        let resStr = resList.join(",");
+        return resStr;
+      } else {
+        return defaultAccept;
+      }
+    } catch (error) {
+      console.log(error);
+      return defaultAccept;
+    }
+  });
+  const defaultValue = computed(() => {
+    const { formData, source, defFileList } = props;
+    if (source === "guage") {
+      return defFileList;
+    }
+    return (mainForm == null ? void 0 : mainForm.defaultValue[formData.name]) || formData.default_val;
+  });
+  const isDisabled = computed(() => {
+    return props.formData.is_edit == 0 || props.isLock;
+  });
+  const max_size = computed(() => {
+    var _a;
+    const { max_size: max_size2 } = ((_a = props.formData) == null ? void 0 : _a.validate) || {};
+    return max_size2 || "";
+  });
+  const maxlength = computed(() => {
+    var _a, _b, _c, _d;
+    return +(((_b = (_a = props == null ? void 0 : props.formData) == null ? void 0 : _a.validate) == null ? void 0 : _b.max_length) || ((_d = (_c = props == null ? void 0 : props.formData) == null ? void 0 : _c.setting) == null ? void 0 : _d.limitPic) || 0);
+  });
+  return {
+    isShowBtn,
+    maskHeight,
+    showPercent,
+    allow_format,
+    defaultValue,
+    isDisabled,
+    max_size,
+    maxlength
+  };
+};
+
+export { VodComputed };