cnhis-design-vue 3.1.18-beta.5 → 3.1.18-beta.8

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

@@ -0,0 +1,348 @@
+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(params) {
+    return httpFn.get(PDF_URL, { params }).then(({ data }) => data);
+  }
+  downloadPDF(params) {
+    return new Promise((resolve, reject) => {
+      this.printDirect(params, async (res) => {
+        if (!res)
+          reject(null);
+        resolve(await this._downloadPDF(getFiledir(res.filedir)));
+        function getFiledir(filedir) {
+          const result = JSON.parse(filedir);
+          return isArray(result) ? result[0] || "" : "";
+        }
+      }, (err) => reject(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.js

@@ -1,14 +1 @@
-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 };
+export { default } from './index2.js';

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

@@ -0,0 +1,14 @@
+import { COMPONENT_NAMESPACE } from '../../shared/global/variable2.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/index2.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-data.js';
-import { UploadComputed } from './hooks/upload-computed.js';
+import { UploadProps, getUploadData, statusSet } from './hooks/upload-data2.js';
+import { UploadComputed } from './hooks/upload-computed2.js';
 import { FolderOutline, DocumentAttachOutline, Close } from '@vicons/ionicons5';
 import _export_sfc from '../../../_virtual/plugin-vue_export-helper.js';
 

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

@@ -1,70 +1 @@
-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 };
+export { UploadComputed } from './upload-computed2.js';

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

@@ -0,0 +1,70 @@
+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,96 +1 @@
-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 };
+export { UploadProps, getUploadData, statusSet } from './upload-data2.js';