cnhis-design-vue 3.1.24-beta.7 → 3.1.24-beta.9

package/es/components/scale-view/src/hooks/scaleview-init.js

@@ -0,0 +1,437 @@
+import { handleQueryParams, getQueryVariable } from '../utils/judge-types.js';
+import useNoData from './use-noData.js';
+import XEUtils from 'xe-utils';
+import 'moment';
+import { componentMap } from './use-component.js';
+import { useEvent } from './use-event.js';
+import { ScaleViewComputed } from './scaleview-computed.js';
+import { ScaleViewValidate } from './scaleview-validate.js';
+import { useDialog } from 'naive-ui';
+
+const ScaleViewInit = (props, state, emit, config) => {
+  const dialog = useDialog();
+  const { setNoData } = useNoData();
+  const { hasEvaluateResultSetting, hasparamsEvaluate, hasDefault, formKey } = ScaleViewComputed(props, state, config);
+  const { formatRules } = ScaleViewValidate(props, state, config);
+  const { nextLogicEvent } = useEvent(props, state);
+  const setEvaluateStartTime = (evaluateResultSetting) => {
+    const evaluateStartTime = evaluateResultSetting == null ? void 0 : evaluateResultSetting.evaluateStartTime;
+    if (!evaluateStartTime)
+      return;
+    if (!XEUtils.isValidDate(new Date(evaluateStartTime)) && XEUtils.isValidDate(new Date(Number(evaluateStartTime)))) {
+      evaluateResultSetting.evaluateStartTime = Number(evaluateStartTime);
+    }
+  };
+  const setDefaultEvaluate = (evaluateResultSetting) => {
+    let query = handleQueryParams();
+    if (hasparamsEvaluate.value) {
+      query = state.paramsEvaluate;
+    }
+    if (query.evaname) {
+      evaluateResultSetting.evaluateName = query.evaname;
+    }
+    if (query.evadesc) {
+      evaluateResultSetting.evaluateExplain = query.evadesc;
+    }
+    if (query.evast) {
+      evaluateResultSetting.evaluateStartTime = query.evast;
+    }
+    if (query.evadur) {
+      evaluateResultSetting.evaluateTime = query.evadur;
+    }
+    if (query.evaan) {
+      query.evaan === "true" || query.evaan == 1 ? true : false;
+      evaluateResultSetting.evaluateAnswer = query.evaan;
+    }
+    setEvaluateStartTime(evaluateResultSetting);
+  };
+  const handleShowEvaluate = () => {
+    var _a;
+    if (!hasEvaluateResultSetting.value) {
+      if (!hasDefault.value)
+        return false;
+      if (!("evaluateResultSetting" in state.config)) {
+        state.config.evaluateResultSetting = {};
+      }
+      setDefaultEvaluate(state.config.evaluateResultSetting);
+      state.showEvaluatePage = true;
+      state.showEvaluateCountdownWrap = true;
+      return;
+    }
+    const { evaluateResultSetting = {} } = state.config;
+    if (!evaluateResultSetting || !Object.keys(evaluateResultSetting).length)
+      return;
+    state.showEvaluateCountdownWrap = true;
+    const { evaluateStartTime } = evaluateResultSetting;
+    const { evaluateName } = ((_a = state.originConfig) == null ? void 0 : _a.evaluateResultSetting) || {};
+    if (!evaluateStartTime) {
+      state.showEvaluatePage = true;
+      return;
+    }
+    if (!XEUtils.isValidDate(new Date(evaluateStartTime))) {
+      if (!evaluateName)
+        return false;
+    }
+    state.showEvaluatePage = true;
+  };
+  const initForm = (data) => {
+    var _a;
+    let { list = [], map = {}, isFinished = false } = data;
+    const curUrl = handleFrontAddress(list);
+    if (curUrl) {
+      window.location.href = curUrl;
+      return;
+    }
+    map.maxScore && (state.maxScore = map.maxScore);
+    state.isFinished = isFinished;
+    if (data.isNotFilled) {
+      state.spinning = false;
+      state.hasFrontAddress = false;
+      setNoData(true, "\u672A\u67E5\u8BE2\u5230\u91CF\u8868\u586B\u5199\u8BB0\u5F55");
+      return;
+    }
+    if (data.isLackCustomer) {
+      dialog.info({
+        title: "\u5DF2\u8BBE\u7F6E\u586B\u5199\u6B21\u6570\u9650\u5236",
+        content: "\u8BF7\u5728\u5305\u542B\u7528\u6237\u4FE1\u606F\u7684\u73AF\u5883\u4E2D\u6253\u5F00\u6B64\u91CF\u8868",
+        maskClosable: false,
+        onPositiveClick() {
+          emit("onCloseSetting");
+        }
+      });
+    }
+    state.config = map;
+    if ("evaluateResultConfig" in map && XEUtils.isJSON(map.evaluateResultConfig)) {
+      state.config.evaluateResultConfig = JSON.parse(map.evaluateResultConfig);
+    }
+    if ("evaluateResultSetting" in map && XEUtils.isJSON(map.evaluateResultSetting)) {
+      state.config.evaluateResultSetting = JSON.parse(map.evaluateResultSetting);
+      if (((_a = state.config) == null ? void 0 : _a.randomId) && state.config.evaluateResultSetting) {
+        state.config.evaluateResultSetting.evaluateName = state.config.name;
+        state.config.evaluateResultSetting.evaluateExplain = state.config.remark;
+      }
+    }
+    state.originConfig = JSON.parse(JSON.stringify(state.config));
+    if (props.params && Object.keys(props.params).length) {
+      const res = handleBtnParamsEvaluate(props.params);
+      res && Object.keys(res).length && (state.paramsEvaluate = res);
+    }
+    handleEvaluateParams(state.config.evaluateResultSetting);
+    handleShowEvaluate();
+    state.defaultFormArray = JSON.parse(JSON.stringify(list));
+    const filterArr = state.filterArr;
+    list = list.filter((v) => !filterArr.includes(v.type));
+    state.formArray = formatArray(list || []);
+    state.form = defaultFormValue(state.formArray);
+    state.rules = formatRules(state.formArray);
+    state.fontSize = data.fontSize;
+    state.spinning = false;
+    state.hasFrontAddress = false;
+  };
+  const replaceConditionItem = (options, value) => {
+    const matchOption = options.find((v) => value === v.value);
+    if (!matchOption)
+      return value;
+    return matchOption.key;
+  };
+  const isRadioOrCheckBox = (options, type) => {
+    const typeArr = ["RADIO_BLOCK", "CHECKBOX_BLOCK"];
+    if (!typeArr.includes(type))
+      return;
+    if (!options)
+      return;
+    if (options && XEUtils.isJSON(options)) {
+      options = JSON.parse(options);
+    }
+    if (!options.length)
+      return;
+    return true;
+  };
+  const handLenextLogic = (item) => {
+    const { nextLogic, options, type } = item || {};
+    if (!nextLogic || !isRadioOrCheckBox(options, type))
+      return;
+    const { condition } = nextLogic || {};
+    if (!condition || !condition.length)
+      return;
+    condition.forEach((c) => {
+      let value = c.value;
+      if (Array.isArray(value)) {
+        value = value.map((v) => {
+          return replaceConditionItem(options, v);
+        });
+        c.value = value;
+      } else {
+        c.value = replaceConditionItem(options, value);
+      }
+    });
+  };
+  const handleRelationLogic = (list, item) => {
+    const relationLogicObj = XEUtils.isString(item.relationLogic) ? JSON.parse(item.relationLogic) : item.relationLogic;
+    const { condition } = relationLogicObj || {};
+    if (!condition || !condition.length)
+      return;
+    condition.forEach((c) => {
+      const matchItem = list.find((f) => f.seq == c.subject_seq);
+      if (!matchItem)
+        return;
+      if (!isRadioOrCheckBox(matchItem.options, matchItem.type))
+        return;
+      let value = c.value;
+      if (Array.isArray(value)) {
+        value = value.map((v) => {
+          return replaceConditionItem(matchItem.options, v);
+        });
+        c.value = value;
+      } else {
+        c.value = replaceConditionItem(matchItem.options, value);
+      }
+    });
+    item.relationLogic = relationLogicObj;
+  };
+  const handleFrontAddress = (list) => {
+    var _a, _b;
+    if (!list || !list.length)
+      return;
+    const query = handleQueryParams();
+    if ((props == null ? void 0 : props.noBtn) || (query == null ? void 0 : query.noBtn))
+      return;
+    const matchItem = list.find((item) => item.type === "FRONT_ADDRESS");
+    if (!matchItem || !Object.keys(matchItem).length)
+      return;
+    let setting;
+    if (matchItem.setting && XEUtils.isJSON(matchItem.setting)) {
+      setting = JSON.parse(matchItem.setting);
+    }
+    if (!setting || !Object.keys(setting).length)
+      return;
+    if ((query == null ? void 0 : query.redirect) == 1 || ((_a = props.params) == null ? void 0 : _a.redirect) == 1 || query.isEdit == 3 || ((_b = props.params) == null ? void 0 : _b.isEdit) == 3)
+      return;
+    const { frontAddress } = setting;
+    if (frontAddress) {
+      const urlHref = window.location.href;
+      let preStr = "?";
+      if (frontAddress.includes("?")) {
+        preStr = "&";
+      }
+      const curUrl = `${frontAddress}${preStr}redirect_url=${encodeURIComponent(urlHref)}`;
+      return curUrl;
+    }
+  };
+  const handleBtnParamsEvaluate = (params) => {
+    const defaultVariable = ["evaname", "evadesc", "evast", "evadur", "evaan"];
+    const res = {};
+    for (const key in params) {
+      const value = params[key];
+      if (defaultVariable.includes(key) && value) {
+        res[key] = value;
+      }
+    }
+    return res;
+  };
+  const handleEvaluateParams = (evaluateResultSetting) => {
+    if (!evaluateResultSetting || !Object.keys(evaluateResultSetting).length)
+      return;
+    let query = handleQueryParams() || {};
+    if (hasparamsEvaluate.value) {
+      query = state.paramsEvaluate;
+    }
+    const obj = {
+      evaluateName: "evaname",
+      evaluateExplain: "evadesc",
+      evaluateStartTime: "evast",
+      evaluateTime: "evadur",
+      evaluateAnswer: "evaan"
+    };
+    for (const key in evaluateResultSetting) {
+      const value = evaluateResultSetting[key];
+      const isParseKey = value && key != "evaluateAnswer" && typeof value === "string" && value.includes("${");
+      if (isParseKey) {
+        const parseValue = value.replace(/\$\{([^}]+)\}/g, (_v, $1) => {
+          let param;
+          if ($1.startsWith("form.")) {
+            param = query[$1.split(".")[1]];
+          }
+          return param || "";
+        });
+        evaluateResultSetting[key] = parseValue;
+      } else {
+        let val = query[obj[key]];
+        if (key == "evaluateAnswer") {
+          val = val === "true" || val == 1 ? true : false;
+        }
+        query[obj[key]] && (evaluateResultSetting[key] = val);
+      }
+    }
+    if (hasDefault.value) {
+      const defaultVariable = ["evaname", "evadesc", "evast", "evadur", "evaan"];
+      const defObj = {
+        evaname: "evaluateName",
+        evadesc: "evaluateExplain",
+        evast: "evaluateStartTime",
+        evadur: "evaluateTime",
+        evaan: "evaluateAnswer"
+      };
+      defaultVariable.forEach((item) => {
+        const key = defObj[item];
+        if (!evaluateResultSetting[key]) {
+          let val = query[item];
+          if (item == "evaan") {
+            val = val === "true" || val == 1 ? true : false;
+          }
+          query[item] && (evaluateResultSetting[key] = val);
+        }
+      });
+    }
+    setEvaluateStartTime(evaluateResultSetting);
+  };
+  const isChoice = (type) => {
+    return type == "SELECT" || type == "RADIO_BLOCK" || type == "CHECKBOX_BLOCK" || type == "SEARCH_CASCADE" || type == "EVALUATE_RADIO_BLOCK" || type == "EVALUATE_CHECKBOX_BLOCK" || type == "EVALUATE_SELECT";
+  };
+  const handleFormatOptions = (options, type) => {
+    if (!isRadioOrCheckBox(options, type))
+      return;
+    options.forEach((item, i) => {
+      if (item.key !== "other") {
+        item.key = i + 1;
+      }
+      if (item.prefix || item.suffix) {
+        item.value = item.prefix || item.suffix;
+      }
+    });
+  };
+  const formatArray = (list) => {
+    let i = 1;
+    const results = list.map((item) => {
+      const key = formKey(item);
+      (key || "").replace(/\n/g, "");
+      item.showTitle = item.title;
+      item.val_key = key;
+      item.renderCom = componentMap[item.type];
+      item.isShow = true;
+      Object.keys(item).forEach((key2) => {
+        if (XEUtils.isJSON(item[key2])) {
+          if (item.type != "LOCATION") {
+            item[key2] = JSON.parse(item[key2]);
+          }
+        }
+      });
+      const notIndexArr = ["LINEBAR", "TITLE", "PROMPT", "IMGCARD", "RICH_TEXT"];
+      if (notIndexArr.indexOf(item.type) < 0 && !item.hide) {
+        item.softcode = i++;
+      }
+      if (isChoice(item.type)) {
+        handleFormatOptions(item.options, item.type);
+        if (item.type != "SEARCH_CASCADE") {
+          if (item.dbValue) {
+            nextLogicEvent(item.dbValue, item, list);
+          } else {
+            if (item.setting.defaultValue) {
+              nextLogicEvent(item.setting.defaultValue, item, list);
+            }
+          }
+        }
+      }
+      return item;
+    });
+    return results.map((item) => {
+      handleRelationLogic(list, item);
+      handLenextLogic(item);
+      if (item.type === "CHECKBOX_BLOCK" && item.dbValue && !Array.isArray(item.dbValue) && props.type === "customList") {
+        item.dbValue = item.dbValue.split(",").filter((ii) => !!ii);
+      }
+      return item;
+    });
+  };
+  const defaultFormValue = (formArray) => {
+    const formData = {};
+    let val;
+    formArray.forEach((item) => {
+      var _a, _b, _c, _d;
+      const key = item.val_key;
+      const { type } = item;
+      let defValue;
+      if (item.dbValue) {
+        defValue = item.dbValue;
+      } else {
+        if (((_a = item.setting) == null ? void 0 : _a.defValType) == 3) {
+          const urlKey = (_c = (_b = item.setting) == null ? void 0 : _b.outDefaultValue) == null ? void 0 : _c.urlKey;
+          if (urlKey) {
+            const list = urlKey.split(",");
+            if (list.length > 1) {
+              const val2 = list.map((l) => {
+                const tempV = getQueryVariable(l, state, props.params);
+                if (tempV)
+                  return decodeURIComponent(tempV);
+                return null;
+              }).filter(Boolean);
+              val2.length && (defValue = val2);
+            } else {
+              let val2 = getQueryVariable(list[0], state, props.params);
+              if (val2) {
+                val2 = decodeURIComponent(val2);
+                defValue = item.type == "CHECKBOX_BLOCK" ? val2.split() : val2;
+              }
+            }
+          }
+        }
+      }
+      switch (type) {
+        case "LOCATION":
+          formData[key] = defValue || "";
+          break;
+        case "SEARCH_CASCADE":
+          formData[key] = defValue || [];
+          break;
+        case "ADDRESS":
+          formData[key] = defValue || "";
+          state.defaultAddress = defValue || {};
+          break;
+        case "LABEL":
+          formData[key] = defValue || {};
+          if (XEUtils.isObject(defValue)) {
+            state.labelSelectedList = (defValue == null ? void 0 : defValue.labels) || [];
+          } else if (Array.isArray(defValue)) {
+            state.labelSelectedList = defValue;
+          } else {
+            state.labelSelectedList = [];
+          }
+          break;
+        case "TITLE":
+          formData[key] = item.title;
+          break;
+        case "IMGCARD":
+          formData[key] = ((_d = item.setting) == null ? void 0 : _d.imgUrl) || "";
+          break;
+        case "UPFILE":
+        case "UPPICTURE":
+          formData[key] = defValue || [];
+          break;
+        case "CHECKBOX_BLOCK":
+          if (defValue && !Array.isArray(defValue) && props.type === "customList") {
+            formData[key] = defValue.split(",").filter((ii) => !!ii);
+          } else {
+            val = defValue || item.setting.defaultValue;
+            if (XEUtils.isJSON(val)) {
+              val = JSON.parse(val);
+            }
+            formData[key] = val;
+          }
+          break;
+        default:
+          val = defValue || item.setting.defaultValue;
+          if (XEUtils.isJSON(val)) {
+            val = JSON.parse(val);
+          }
+          formData[key] = val;
+          break;
+      }
+    });
+    return formData;
+  };
+  return {
+    initForm
+  };
+};
+
+export { ScaleViewInit };

package/es/components/scale-view/src/hooks/scaleview-props.d.ts

@@ -0,0 +1,115 @@
+declare const ScaleViewProps: {
+    ids: {
+        type: ObjectConstructor;
+        default: () => {
+            guage_id: string;
+            db_id: undefined;
+        };
+    };
+    params: {
+        default: () => {};
+        type: ObjectConstructor;
+    };
+    guageData: {
+        type: ObjectConstructor;
+        default: () => {};
+    };
+    noBtn: {
+        type: (BooleanConstructor | NumberConstructor | StringConstructor)[];
+        default: boolean;
+    };
+    hideBtn: {
+        type: (BooleanConstructor | NumberConstructor | StringConstructor)[];
+        default: boolean;
+    };
+    source: {
+        type: StringConstructor;
+        default: string;
+    };
+    isLock: {
+        type: (BooleanConstructor | NumberConstructor | StringConstructor)[];
+        default: boolean;
+    };
+    type: {
+        type: StringConstructor;
+        default: string;
+    };
+    styleSetting: {
+        type: ObjectConstructor;
+        default: () => {};
+    };
+    fontSizeObj: {
+        type: ObjectConstructor;
+        default: () => {
+            large: number;
+            medium: number;
+            small: number;
+            extrasmall: number;
+        };
+    };
+    openType: {
+        type: StringConstructor;
+        default: string;
+    };
+    scaleApiConfig: {
+        type: ObjectConstructor;
+        default: () => {};
+    };
+    getSelectOptions: {
+        type: FunctionConstructor;
+        default: () => Promise<never[]>;
+    };
+    getSearchOptions: {
+        type: FunctionConstructor;
+        default: () => Promise<never[]>;
+    };
+    getCascadeOptions: {
+        type: FunctionConstructor;
+        default: () => Promise<never[]>;
+    };
+    getLabelList: {
+        type: FunctionConstructor;
+        default: () => Promise<never[]>;
+    };
+    deleteLabel: {
+        type: FunctionConstructor;
+        default: () => Promise<{
+            status: boolean;
+        }>;
+    };
+    saveLabelItem: {
+        type: FunctionConstructor;
+        default: () => Promise<{
+            status: boolean;
+        }>;
+    };
+    uploadPictureUrl: {
+        type: StringConstructor;
+        default: string;
+    };
+    uploadFileUrl: {
+        type: StringConstructor;
+        default: string;
+    };
+    ak: {
+        type: StringConstructor;
+        default: string;
+    };
+    sourceType: {
+        type: StringConstructor;
+        default: string;
+    };
+    getChunkUploadConfig: {
+        type: FunctionConstructor;
+        default: () => Promise<{
+            checkFileMd5Exist: string;
+            fileChannel: string;
+            md5: string;
+            objectName: string;
+            partFileMerge: string;
+            partFileUpload: string;
+            token: string;
+        }>;
+    };
+};
+export default ScaleViewProps;

package/es/components/scale-view/src/hooks/scaleview-props.js

@@ -0,0 +1,81 @@
+const ScaleViewProps = {
+  ids: {
+    type: Object,
+    default: () => {
+      return { guage_id: "", db_id: void 0 };
+    }
+  },
+  params: { default: () => ({}), type: Object },
+  guageData: { type: Object, default: () => ({}) },
+  noBtn: { type: [Boolean, String, Number], default: false },
+  hideBtn: { type: [Boolean, String, Number], default: false },
+  source: { type: String, default: "" },
+  isLock: { type: [Boolean, String, Number], default: false },
+  type: {
+    type: String,
+    default: ""
+  },
+  styleSetting: {
+    type: Object,
+    default: () => ({})
+  },
+  fontSizeObj: {
+    type: Object,
+    default: () => ({
+      large: 1.25,
+      medium: 1.1,
+      small: 1,
+      extrasmall: 0.9
+    })
+  },
+  openType: { type: String, default: "" },
+  scaleApiConfig: {
+    type: Object,
+    default: () => ({})
+  },
+  getSelectOptions: {
+    type: Function,
+    default: () => Promise.resolve([])
+  },
+  getSearchOptions: {
+    type: Function,
+    default: () => Promise.resolve([])
+  },
+  getCascadeOptions: {
+    type: Function,
+    default: () => Promise.resolve([])
+  },
+  getLabelList: {
+    type: Function,
+    default: () => Promise.resolve([])
+  },
+  deleteLabel: {
+    type: Function,
+    default: () => Promise.resolve({ status: true })
+  },
+  saveLabelItem: {
+    type: Function,
+    default: () => Promise.resolve({ status: true })
+  },
+  uploadPictureUrl: { type: String, default: "" },
+  uploadFileUrl: { type: String, default: "" },
+  ak: {
+    type: String,
+    default: "KP3BZ-OAC3W-PY6RY-OJ6DV-JYKN3-H6F72"
+  },
+  sourceType: { type: String, default: "" },
+  getChunkUploadConfig: {
+    type: Function,
+    default: () => Promise.resolve({
+      checkFileMd5Exist: "http://192.168.1.223:12060/storage/checkFileMd5Exist",
+      fileChannel: "null",
+      md5: "9ed34823e7ef4754819704135b29c9ab",
+      objectName: "0/0/20220602",
+      partFileMerge: "http://192.168.1.223:12060/storage/partFileMerge",
+      partFileUpload: "http://192.168.1.223:12060/storage/partFileUpload",
+      token: "4d0eb8f174994d33adb71766d1ef8ce4"
+    })
+  }
+};
+
+export { ScaleViewProps as default };

package/es/components/scale-view/src/hooks/scaleview-state.d.ts

@@ -0,0 +1,34 @@
+import moment from 'moment';
+export declare const getScaleViewState: () => {
+    ScaleViewState: {
+        other: string;
+        form: {};
+        submitForm: {};
+        rules: {};
+        config: {};
+        formArray: never[];
+        mapVisible: boolean;
+        mapLocation: string;
+        labelSelectedList: never[];
+        defaultFormArray: never[];
+        fontSize: string;
+        filterArr: string[];
+        spinning: boolean;
+        indicator: string;
+        totalScore: undefined;
+        shareId: string;
+        currentTime: moment.Moment;
+        showEvaluatePage: boolean;
+        showEvaluateSettingWrap: boolean;
+        showEvaluateCountdownWrap: boolean;
+        showEvaluateCountdown: boolean;
+        banSubmit: boolean;
+        isFinished: boolean;
+        maxScore: number;
+        originConfig: {};
+        paramsEvaluate: null;
+        hasFrontAddress: boolean;
+        choiceComObj: {};
+        evatipMap: {};
+    };
+};

package/es/components/scale-view/src/hooks/scaleview-state.js

@@ -0,0 +1,38 @@
+import moment from 'moment';
+
+const getScaleViewState = () => {
+  const ScaleViewState = {
+    other: "",
+    form: {},
+    submitForm: {},
+    rules: {},
+    config: {},
+    formArray: [],
+    mapVisible: false,
+    mapLocation: "",
+    labelSelectedList: [],
+    defaultFormArray: [],
+    fontSize: "",
+    filterArr: ["SUCCESS_TIP", "CALLBACK_INTERFACE", "SPREAD_PARAMS", "REDIRECT", "FRONT_ADDRESS", "RETURN_PATH"],
+    spinning: false,
+    indicator: "",
+    totalScore: void 0,
+    shareId: "",
+    currentTime: moment(),
+    showEvaluatePage: false,
+    showEvaluateSettingWrap: true,
+    showEvaluateCountdownWrap: false,
+    showEvaluateCountdown: false,
+    banSubmit: false,
+    isFinished: false,
+    maxScore: 0,
+    originConfig: {},
+    paramsEvaluate: null,
+    hasFrontAddress: true,
+    choiceComObj: {},
+    evatipMap: {}
+  };
+  return { ScaleViewState };
+};
+
+export { getScaleViewState };