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

package/es/packages/scale-view/src/hooks/scaleview-init2.js

@@ -0,0 +1,442 @@
+import { handleQueryParams, getQueryVariable } from '../utils/judge-types2.js';
+import useNoData from './use-noData2.js';
+import vexutils from '../..\\..\\../src/utils/vexutils';
+import { componentMap } from './use-component2.js';
+import { useEvent } from './use-event2.js';
+import { ScaleViewComputed } from './scaleview-computed2.js';
+import { ScaleViewValidate } from './scaleview-validate2.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) => {
+    let evaluateStartTime = evaluateResultSetting == null ? void 0 : evaluateResultSetting.evaluateStartTime;
+    if (!evaluateStartTime)
+      return;
+    if (!vexutils.isValidDate(new Date(evaluateStartTime)) && vexutils.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;
+    }
+    let { evaluateResultSetting = {} } = state.config;
+    if (!evaluateResultSetting || !Object.keys(evaluateResultSetting).length)
+      return;
+    state.showEvaluateCountdownWrap = true;
+    let { evaluateStartTime } = evaluateResultSetting;
+    let { evaluateName } = ((_a = state.originConfig) == null ? void 0 : _a.evaluateResultSetting) || {};
+    if (!evaluateStartTime) {
+      state.showEvaluatePage = true;
+      return;
+    }
+    if (!vexutils.isValidDate(new Date(evaluateStartTime))) {
+      if (!evaluateName)
+        return false;
+    }
+    state.showEvaluatePage = true;
+  };
+  const initForm = (data) => {
+    var _a;
+    let { list = [], map = {}, isFinished = false } = data;
+    let 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 && vexutils.isJSON(map.evaluateResultConfig)) {
+      state.config.evaluateResultConfig = JSON.parse(map.evaluateResultConfig);
+    }
+    if ("evaluateResultSetting" in map && vexutils.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) {
+      let res = handleBtnParamsEvaluate(props.params);
+      res && Object.keys(res).length && (state.paramsEvaluate = res);
+    }
+    handleEvaluateParams(state.config.evaluateResultSetting);
+    handleShowEvaluate();
+    state.defaultFormArray = JSON.parse(JSON.stringify(list));
+    let 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) => {
+    let matchOption = options.find((v) => value === v.value);
+    if (!matchOption)
+      return value;
+    return matchOption.key;
+  };
+  const isRadioOrCheckBox = (options, type) => {
+    let typeArr = ["RADIO_BLOCK", "CHECKBOX_BLOCK"];
+    if (!typeArr.includes(type))
+      return;
+    if (!options)
+      return;
+    if (options && vexutils.isJSON(options)) {
+      options = JSON.parse(options);
+    }
+    if (!options.length)
+      return;
+    return true;
+  };
+  const handLenextLogic = (item) => {
+    let { nextLogic, options, type } = item || {};
+    if (!nextLogic || !isRadioOrCheckBox(options, type))
+      return;
+    let { 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) => {
+    let relationLogicObj = vexutils.isString(item.relationLogic) ? JSON.parse(item.relationLogic) : item.relationLogic;
+    let { condition } = relationLogicObj || {};
+    if (!condition || !condition.length)
+      return;
+    condition.forEach((c) => {
+      let 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) => {
+    if (!list || !list.length)
+      return;
+    let matchItem = list.find((item) => item.type === "FRONT_ADDRESS");
+    if (!matchItem || !Object.keys(matchItem).length)
+      return;
+    let setting;
+    if (matchItem.setting && vexutils.isJSON(matchItem.setting)) {
+      setting = JSON.parse(matchItem.setting);
+    }
+    if (!setting || !Object.keys(setting).length)
+      return;
+    let query = handleQueryParams();
+    if ((query == null ? void 0 : query.redirect) == 1)
+      return;
+    let { frontAddress } = setting;
+    if (frontAddress) {
+      let urlHref = window.location.href;
+      let preStr = "?";
+      if (frontAddress.includes("?")) {
+        preStr = "&";
+      }
+      let curUrl = `${frontAddress}${preStr}redirect_url=${encodeURIComponent(urlHref)}`;
+      return curUrl;
+    }
+  };
+  const handleBtnParamsEvaluate = (params) => {
+    let defaultVariable = ["evaname", "evadesc", "evast", "evadur", "evaan"];
+    let res = {};
+    for (let key in params) {
+      let 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;
+    }
+    let obj = {
+      evaluateName: "evaname",
+      evaluateExplain: "evadesc",
+      evaluateStartTime: "evast",
+      evaluateTime: "evadur",
+      evaluateAnswer: "evaan"
+    };
+    for (let key in evaluateResultSetting) {
+      let value = evaluateResultSetting[key];
+      let isParseKey = value && key != "evaluateAnswer" && typeof value === "string" && value.includes("${");
+      if (isParseKey) {
+        let 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) {
+      let defaultVariable = ["evaname", "evadesc", "evast", "evadur", "evaan"];
+      let defObj = {
+        evaname: "evaluateName",
+        evadesc: "evaluateExplain",
+        evast: "evaluateStartTime",
+        evadur: "evaluateTime",
+        evaan: "evaluateAnswer"
+      };
+      defaultVariable.forEach((item) => {
+        let 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);
+      let title = (key || "").replace(/\n/g, "");
+      item.showTitle = item.title;
+      item.val_key = key;
+      item.renderCom = componentMap[item.type];
+      if (title.includes(".")) {
+        let newTitle = title.replace(/\./g, "~-~");
+        item.showTitle = newTitle;
+      }
+      item.isShow = true;
+      Object.keys(item).forEach((key2) => {
+        if (vexutils.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) {
+          let urlKey = (_c = (_b = item.setting) == null ? void 0 : _b.outDefaultValue) == null ? void 0 : _c.urlKey;
+          if (urlKey) {
+            let list = urlKey.split(",");
+            if (list.length > 1) {
+              let val2 = list.map((l) => {
+                let 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 (vexutils.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 (vexutils.isJSON(val)) {
+              val = JSON.parse(val);
+            }
+            formData[key] = val;
+          }
+          break;
+        default:
+          val = defValue || item.setting.defaultValue;
+          if (vexutils.isJSON(val)) {
+            val = JSON.parse(val);
+          }
+          formData[key] = val;
+          break;
+      }
+    });
+    return formData;
+  };
+  return {
+    initForm
+  };
+};
+
+export { ScaleViewInit };

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

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

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

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

package/es/packages/scale-view/src/hooks/scaleview-submit.js

@@ -0,0 +1 @@
+export { ScaleViewSubmit } from './scaleview-submit2.js';

package/es/packages/scale-view/src/hooks/scaleview-submit2.js

@@ -0,0 +1,162 @@
+import { getQueryVariable, isOnlyOptions } from '../utils/judge-types2.js';
+import vexutils from '../..\\..\\../src/utils/vexutils';
+import moment from 'moment';
+import { ScaleViewComputed } from './scaleview-computed2.js';
+
+const ScaleViewSubmit = (props, state, emit, config) => {
+  const {
+    showEvent,
+    formKey
+  } = ScaleViewComputed(props, state, config);
+  const compileSpreadParams = (spreadParams) => {
+    return spreadParams.domains.map((v) => {
+      let obj = {};
+      if (v.valueType == "1") {
+        obj[v.name] = v.value;
+      } else if (v.valueType == "2") {
+        obj[v.name] = getQueryVariable(v.value, state, props.params);
+      }
+      return obj;
+    });
+  };
+  const submitMethod = () => {
+    const hasSpreadParams = state.defaultFormArray.find((v) => v.type === "SPREAD_PARAMS");
+    if (hasSpreadParams) {
+      if (vexutils.isJSON(hasSpreadParams.setting)) {
+        hasSpreadParams.setting = JSON.parse(hasSpreadParams.setting);
+      }
+      let spreadKey = formKey(hasSpreadParams);
+      state.submitForm[spreadKey] = compileSpreadParams(hasSpreadParams.setting.spreadParams);
+    }
+    let checkBoxKey = state.defaultFormArray.find((ii) => ii.type == "CHECKBOX_BLOCK");
+    if (checkBoxKey && Array.isArray(state.form[checkBoxKey.title]) && props.type === "customList") {
+      state.form[checkBoxKey.title] = state.form[checkBoxKey.title].join(",");
+    }
+    const scoreJson = handleScoreJson();
+    let params;
+    if (props.type === "customList") {
+      params = {
+        definedListId: props.ids.guage_id,
+        dbId: props.ids.db_id,
+        scoreJson: JSON.stringify(scoreJson)
+      };
+    } else {
+      const { guageId, randomId } = state.config;
+      params = Object.assign(props.params, {
+        guageId,
+        scoreJson: JSON.stringify(scoreJson),
+        randomId
+      });
+    }
+    if (state.shareId) {
+      params.shareId = state.shareId;
+    }
+    const tipSetting = state.defaultFormArray.find((item) => item.type === "SUCCESS_TIP");
+    if (tipSetting) {
+      const tip = vexutils.isJSON(tipSetting.setting) ? JSON.parse(tipSetting.setting) : tipSetting.setting;
+      params.tipSetting = JSON.stringify({
+        tipMode: tip.tipMode,
+        tipType: tip.tipType,
+        tipText: tip.tipText,
+        tipApi: tip.tipApi
+      });
+    }
+    let hasCallbackItem = state.defaultFormArray.find((v) => v.type === "CALLBACK_INTERFACE");
+    let isCallback = false;
+    if (hasCallbackItem) {
+      isCallback = showEvent(hasCallbackItem, true);
+    }
+    emit("onSubmit", params, hasCallbackItem, isCallback);
+  };
+  const handleScoreJson = () => {
+    let tempObj = Object.assign({}, state.form, state.submitForm);
+    let res = {};
+    if (!Object.keys(tempObj).length)
+      return {};
+    for (let key in tempObj) {
+      let itemTemp = state.formArray.find((item) => formKey(item) == key);
+      if (key && itemTemp) {
+        let keyTemp;
+        if (itemTemp && itemTemp.databaseTitle)
+          keyTemp = itemTemp.databaseTitle;
+        if (props.type == "customList" && itemTemp && itemTemp.setting && itemTemp.setting.startToStop != 1 && tempObj[key] && itemTemp.type == "DATETIME") {
+          if (itemTemp.setting && itemTemp.setting.dateType == "time" && tempObj[key])
+            tempObj[key] = moment().format("YYYY-MM-DD ") + tempObj[key];
+          if (itemTemp.setting && itemTemp.setting.dateType == "date" && tempObj[key])
+            tempObj[key] = moment(tempObj[key]).format("YYYY-MM-DD ") + moment().format("HH:mm:ss");
+        }
+        if (key.includes("~-~")) {
+          let newKey = keyTemp ? keyTemp.replace(/~-~/g, ".") : key.replace(/~-~/g, ".");
+          res[newKey] = tempObj[key];
+        } else {
+          res[keyTemp || key] = !tempObj[key] ? null : tempObj[key];
+        }
+        if (isOnlyOptions(itemTemp.type)) {
+          let { options } = itemTemp;
+          let useKey = itemTemp.val_key;
+          let obj = state.choiceComObj[useKey];
+          let value = tempObj[key];
+          if (itemTemp.type === "RADIO_BLOCK" && value) {
+            res[useKey] = handleChoiceItem(value, options, obj);
+          }
+          if (itemTemp.type === "CHECKBOX_BLOCK" && (value == null ? void 0 : value.length)) {
+            let resArr = handleCheckboxParams(value, options, obj);
+            res[useKey] = resArr;
+          }
+        }
+      } else {
+        res[key] = tempObj[key];
+      }
+    }
+    console.log("res", res);
+    return res;
+  };
+  const handleCheckboxParams = (value, options, obj) => {
+    let res = [];
+    let i = 0, len = value.length, v;
+    for (; i < len; i++) {
+      v = value[i];
+      let matchItem = options.find((o, i2) => {
+        if (i2 + 1 === v) {
+          return true;
+        }
+        return false;
+      });
+      if (matchItem && !matchItem.prefix && !matchItem.suffix) {
+        res.push(matchItem.value);
+        continue;
+      }
+      let tempValue = handleChoiceItem(v, options, obj);
+      res.push(tempValue);
+    }
+    return res;
+  };
+  const handleChoiceItem = (value, options, obj) => {
+    let { othersText, optionsPreSuffixObj = {} } = obj || {};
+    if (value === "other") {
+      return othersText || "\u5176\u4ED6";
+    }
+    let matchItem = options.find((o, i) => {
+      if (i + 1 === value) {
+        return true;
+      }
+      return false;
+    });
+    if (!matchItem)
+      return;
+    if (!matchItem.prefix && !matchItem.suffix)
+      return matchItem.value;
+    let resValue = optionsPreSuffixObj[value] || "";
+    if (matchItem.prefix) {
+      resValue = matchItem.prefix + resValue;
+    } else {
+      resValue += matchItem.suffix;
+    }
+    return resValue;
+  };
+  return {
+    submitMethod
+  };
+};
+
+export { ScaleViewSubmit };

package/es/packages/scale-view/src/hooks/scaleview-validate.js

@@ -0,0 +1 @@
+export { ScaleViewValidate } from './scaleview-validate2.js';