cnhis-design-vue 3.1.40-beta.1 → 3.1.40-beta.11

package/es/components/table-filter/src/hooks/useMixins.js

@@ -0,0 +1,532 @@
+import { ref } from 'vue';
+import moment from 'moment';
+import timeDomain from '../tool/time-domain.js';
+import useRenderWidget from './useRenderWidget.js';
+import useTableSearchCon from './useTableSearchCon.js';
+import axios from 'axios';
+import XEUtils from 'xe-utils';
+
+const { initRenderWidgetCfg, getRenderSearchConObj } = useRenderWidget();
+const { getSearchDefValueByLimit } = useTableSearchCon();
+const EVALUATEList = [
+  {
+    label: "\u4E00\u661F",
+    value: "1",
+    isSelect: false
+  },
+  {
+    label: "\u4E8C\u661F",
+    value: "2",
+    isSelect: false
+  },
+  {
+    label: "\u4E09\u661F",
+    value: "3",
+    isSelect: false
+  },
+  {
+    label: "\u56DB\u661F",
+    value: "4",
+    isSelect: false
+  },
+  {
+    label: "\u4E94\u661F",
+    value: "5",
+    isSelect: false
+  }
+];
+function useMixins() {
+  const filterApiConfig = ref({});
+  async function handleGetConfigApi(params, key, config = {}, filterApiConfigVal) {
+    try {
+      if (filterApiConfigVal) {
+        filterApiConfig.value = filterApiConfigVal;
+      }
+      const fn = filterApiConfig.value[key] || null;
+      if (typeof fn === "function") {
+        const res = await fn(params, config);
+        return Promise.resolve(res);
+      } else {
+        return Promise.reject(new Error(`${key} Is not a function`));
+      }
+    } catch (error) {
+      return Promise.reject(error);
+    }
+  }
+  const $utils = {
+    getBtnStyle(v) {
+      if (v.showStyle == "white_bg") {
+        return {
+          "border-color": v.color,
+          color: v.color
+        };
+      } else if (v.showStyle == "none_bg") {
+        return {
+          color: v.color
+        };
+      } else if (v.showStyle == "only_icon") {
+        return {
+          "background-color": v.color,
+          "border-color": v.color
+        };
+      }
+      return {
+        "background-color": v.color,
+        "border-color": v.color
+      };
+    },
+    getRowOperatorIdSetting(row = {}, btn) {
+      if (row.operatorColumn) {
+        const rowOperatorId = row.operatorColumn.find((v) => v.includes(btn.sid));
+        if (btn.setting && typeof rowOperatorId === "string" && rowOperatorId.includes("###")) {
+          const [btnId, objId] = rowOperatorId.split("###");
+          if (btnId && objId) {
+            const settingObj = JSON.parse(btn.setting);
+            if (Array.isArray(settingObj)) {
+              const f = settingObj.find((s) => s.obj_id == objId);
+              if (f) {
+                const copyBtn2 = JSON.parse(JSON.stringify(btn));
+                copyBtn2.settingObj = {
+                  ...f
+                };
+                copyBtn2.setting = JSON.stringify(f);
+                return copyBtn2;
+              }
+            }
+          }
+        }
+      }
+      const copyBtn = JSON.parse(JSON.stringify(btn));
+      if (this.isJSON(copyBtn.setting)) {
+        const btnSetting = JSON.parse(copyBtn.setting);
+        if (Array.isArray(btnSetting)) {
+          const settingObj = btnSetting[0] || {};
+          copyBtn.settingObj = {
+            ...settingObj
+          };
+          copyBtn.setting = JSON.stringify(settingObj);
+          return copyBtn;
+        } else {
+          return copyBtn;
+        }
+      }
+      return btn;
+    },
+    getAlphafloat(a, alpha) {
+      if (typeof a !== "undefined") {
+        return parseFloat((a / 256).toFixed(2));
+      }
+      if (typeof alpha !== "undefined") {
+        if (1 < alpha && alpha <= 100) {
+          return parseFloat((alpha / 100).toFixed(2));
+        }
+        if (0 <= alpha && alpha <= 1) {
+          return parseFloat(alpha.toFixed(2));
+        }
+      }
+      return 1;
+    },
+    hexToRGBA(hex, alpha) {
+      const isValidHex = (hex2) => /^#([A-Fa-f0-9]{3,4}){1,2}$/.test(hex2);
+      const getChunksFromString = (st, chunkSize2) => st.match(new RegExp(`.{${chunkSize2}}`, "g"));
+      const convertHexUnitTo256 = (hexStr) => parseInt(hexStr.repeat(2 / hexStr.length), 16);
+      if (!isValidHex(hex)) {
+        console.log("Invalid HEX");
+        return "";
+      }
+      const chunkSize = Math.floor((hex.length - 1) / 3);
+      const hexArr = getChunksFromString(hex.slice(1), chunkSize);
+      const [r, g, b, a] = hexArr.map(convertHexUnitTo256);
+      return {
+        r,
+        g,
+        b,
+        a: this.getAlphafloat(a, alpha)
+      };
+    },
+    handleLabelColor(item, isSelect) {
+      var _a;
+      let tempColor = "#5585f5";
+      const oldColorMap = {
+        blue: "#0000ff",
+        sky: "#87ceeb",
+        azure: "#f0ffff",
+        palegreen: "#98fb98",
+        yellow: "#ffff00",
+        darkorange: "#ff8c00",
+        magenta: "#ff00ff",
+        purple: "#800080",
+        maroon: "#800000",
+        orange: "#ffa500",
+        green: "#008000",
+        red: "#ff0000",
+        grey: "#808080"
+      };
+      if ((_a = item == null ? void 0 : item.color) == null ? void 0 : _a.includes("-")) {
+        const str = item.color.split("-")[1];
+        tempColor = oldColorMap[str] || "#5585f5";
+      } else {
+        tempColor = item.color || "#5585f5";
+      }
+      const tempRgba = this.hexToRGBA(tempColor) || {
+        r: 85,
+        g: 133,
+        b: 245,
+        a: 1
+      };
+      if (isSelect) {
+        return {
+          color: "#fff",
+          background: `rgba(${tempRgba.r}, ${tempRgba.g}, ${tempRgba.b})`,
+          borderColor: `rgba(${tempRgba.r}, ${tempRgba.g}, ${tempRgba.b})`
+        };
+      }
+      if (item.isSelect) {
+        return {
+          color: "#fff",
+          background: `rgba(${tempRgba.r}, ${tempRgba.g}, ${tempRgba.b})`,
+          borderColor: `rgba(${tempRgba.r}, ${tempRgba.g}, ${tempRgba.b})`
+        };
+      } else {
+        const isSys = !(item.isPublic && item.isPublic == 1);
+        const color = isSys ? "rgba(28, 28, 28, 1)" : "rgba(33, 33, 33, 0.6)";
+        return {
+          color,
+          background: "rgba(250, 250, 250, 1)",
+          borderColor: "rgba(213, 213, 213, 0.8)"
+        };
+      }
+    },
+    formatTime(type, time) {
+      let format = "";
+      if (!time)
+        return "";
+      switch (type) {
+        case "DATE":
+          format = "yyyy-MM-dd";
+          break;
+        case "DATETIME":
+          format = "yyyy-MM-dd HH:mm:ss";
+          break;
+        case "TIME":
+          format = "HH:mm:ss";
+          break;
+        case "MOUTH":
+          format = "MM-dd";
+          break;
+        case "DATETIMESTR":
+          format = "yyyy\u5E74M\u6708dd\u65E5 HH:mm";
+          break;
+        case "MOUTHTIME":
+          format = "M\u6708d\u65E5 HH:mm";
+          break;
+        case "HM":
+          format = " HH:mm";
+          break;
+      }
+      return moment(time).format(format);
+    },
+    isJSON(str) {
+      if (typeof str == "string") {
+        try {
+          const obj = JSON.parse(str);
+          if (typeof obj == "object" && obj) {
+            return true;
+          } else {
+            return false;
+          }
+        } catch (e) {
+          return false;
+        }
+      }
+      return false;
+    },
+    isArray(val) {
+      return Array.isArray(val);
+    },
+    isEmpty(val) {
+      for (const key in val) {
+        return false;
+      }
+      return true;
+    },
+    isString(val) {
+      return typeof val === "string";
+    },
+    isPlainObject(val) {
+      return typeof val === "object";
+    }
+  };
+  const outQuickSearchFn = {
+    handleRequestedLabel(v) {
+      const params = { type: v, pageSize: 1e4 };
+      return axios.get("/label/list", { params });
+    },
+    handlerInitSearchItem(arr, searchFieldLimit) {
+      if (!Array.isArray(arr))
+        return;
+      arr.forEach((el) => {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j;
+        if (initRenderWidgetCfg(el))
+          return;
+        el.setting = typeof el.setting == "string" ? JSON.parse(el.setting) : el.setting;
+        const attr = ((_a = el == null ? void 0 : el.settingObj) == null ? void 0 : _a.attr) || "";
+        const isPreciseSearch = ((_b = el == null ? void 0 : el.settingObj) == null ? void 0 : _b.isPreciseSearch) || "";
+        const showSetting = ((_c = el == null ? void 0 : el.setting) == null ? void 0 : _c.showSetting) || [];
+        const textCon = el.fieldType == "TEXT" && isPreciseSearch == 1 ? "EQ" : "CL";
+        const advanceOptionSetting = el.advanceOptionSetting;
+        const wordbookId = (_e = (_d = el == null ? void 0 : el.setting) == null ? void 0 : _d.wordbook) == null ? void 0 : _e.id;
+        if (showSetting == null ? void 0 : showSetting.length) {
+          let tvalue = [];
+          const df = el.explicitDefaultVal;
+          if (df) {
+            if (df == "firstOption") {
+              tvalue = String(advanceOptionSetting) === "0" ? 0 : [0];
+            } else {
+              if (String(advanceOptionSetting) === "0") {
+                const index = showSetting.findIndex((v) => v.change_text == df);
+                if (index > -1)
+                  tvalue = index;
+              } else {
+                if (Array.isArray(tvalue)) {
+                  const dfs = df.split(",");
+                  dfs.forEach((d) => {
+                    const index = showSetting.findIndex((v) => v.change_text == d);
+                    if (index > -1)
+                      tvalue.push(index);
+                  });
+                }
+              }
+            }
+          }
+          el.con = "CONVERT";
+          el.com = "SelectMui";
+          el.comType = "SelectMui";
+          el.value = tvalue;
+          const labelList = (_f = el.setting) == null ? void 0 : _f.showSetting.map((i) => {
+            i.labelName = i.change_text;
+            return i;
+          });
+          el.labelList = labelList;
+        } else if (!$utils.isEmpty((_g = el.setting) == null ? void 0 : _g.wordbook) && wordbookId) {
+          const isTree = "tree" === ((_i = (_h = el == null ? void 0 : el.setting) == null ? void 0 : _h.wordbook) == null ? void 0 : _i.showType);
+          const comType = isTree ? "treeSelect" : "SelectMuiWordBook";
+          const defVal = isTree ? [] : [];
+          el.con = "QUOTE";
+          el.com = "SelectMui";
+          el.comType = comType;
+          el.value = defVal;
+          el.dataSource = [];
+          el.searchPageConfig = {
+            keyword: void 0,
+            isRequest: false,
+            page: 1,
+            total: 1,
+            hasNextPage: false
+          };
+        } else {
+          if (["MONEY", "PERCENTAGE", "AGE", "NUMBER"].includes(attr) || el.fieldType == "NUMBER") {
+            el.con = "BIGANDLESS";
+            el.com = "Number";
+            el.lessValue = "";
+            el.bigValue = "";
+            if (attr == "AGE" && el.fieldType != "NUMBER") {
+              el.AGEAttr = true;
+              el.inputUnit = "\u5C81";
+            }
+            if (el.fieldType == "NUMBER" && attr == "PERCENTAGE") {
+              el.inputUnit = "%";
+            }
+          } else if (["BIRTHDAY", "DATE", "TASKDATE"].includes(attr) || ["DATETIME", "DATE"].includes((el == null ? void 0 : el.fieldType) || "")) {
+            let value = getSearchDefValueByLimit(el, searchFieldLimit) || [];
+            if (el.explicitDefaultVal) {
+              const t = timeDomain.getTimeDomain(el.explicitDefaultVal);
+              if (t.length > 0) {
+                value = t;
+              }
+            }
+            el.con = "IN";
+            el.com = "DatePicker";
+            el.value = value;
+            if (attr === "BIRTHDAY") {
+              el.showFormat = "MM-DD";
+              el.showTime = false;
+            } else if (["TODAY", "TOMORROW", "YESTERDAY"].includes((el == null ? void 0 : el.explicitDefaultVal) || "")) {
+              const [v] = value;
+              el.showFormat = "YYYY-MM-DD";
+              el.showTime = false;
+              el.com = "DayPicker";
+              el.value = v || moment();
+            } else {
+              el.showFormat = "YYYY-MM-DD HH:mm:ss";
+              el.showTime = true;
+            }
+          } else if (["LABEL", "EVALUATE"].includes(attr)) {
+            el.con = "CL";
+            el.com = "SelectMui";
+            el.value = [];
+            if (attr == "EVALUATE") {
+              const list = EVALUATEList.map((i) => {
+                i.labelName = i.label;
+                return i;
+              });
+              el.labelList = list;
+            } else {
+              this.handleSetLabelOptions((_j = el.setting) == null ? void 0 : _j.labelType, el);
+            }
+          } else if ("PASSWORD" === attr) {
+            el.con = el.fieldType === "NUMBER" ? "EQ" : textCon;
+            el.comAttr = "PASSWORD";
+            el.PASSWORDTYPE = true;
+            el.value = "";
+            el.com = "Text";
+          } else if (["DURATION"].includes(attr)) {
+            el.con = "EQ";
+            el.value = "";
+            el.com = "Text";
+            el.attr = "DURATION";
+          } else {
+            el.con = textCon;
+            el.isPreciseSearch = isPreciseSearch == 1;
+            el.value = "";
+            el.com = "Text";
+          }
+        }
+      });
+    },
+    handleSetLabelOptions(labelType, el) {
+      this.handleRequestedLabel(labelType || "").then(({ data }) => {
+        if (data.result === "SUCCESS") {
+          const labelList = data.map.rows || [];
+          el.labelList = labelList;
+        }
+      }).catch((err) => console.log(err));
+    },
+    getConObj(arr) {
+      if (!Array.isArray(arr)) {
+        return [];
+      }
+      const conObj = [];
+      arr.forEach((item) => {
+        var _a, _b, _c;
+        const renderConObj = getRenderSearchConObj(item);
+        if (renderConObj) {
+          conObj.push(renderConObj);
+          return;
+        }
+        const temp = {
+          field_key: item.columnName,
+          con: item.con,
+          value: "",
+          limit_date: "",
+          start_val: item.start_val || "",
+          end_val: item.end_val || "",
+          unit: item.unit || "",
+          id: item.id
+        };
+        if (item.com === "Text" && item.value) {
+          temp.value = item.value;
+          conObj.push(temp);
+        }
+        const advanceOptionSetting = item.advanceOptionSetting;
+        if (item.com === "SelectMui" && XEUtils.anyNotEmpty(item.value)) {
+          const single = String(advanceOptionSetting) === "0";
+          if (single) {
+            if (!Array.isArray(item.value)) {
+              item.value = [item.value];
+            }
+          }
+          const hasArr = Array.isArray(item.value) && item.value.length > 0;
+          if (item.comType == "SelectMuiWordBook" && hasArr) {
+            temp.value = item.value.join("|#|");
+          } else if (item.comType == "treeSelect") {
+            let value = item.value;
+            if (typeof value === "string") {
+              [value] = value.split("<&=&>");
+            } else if (Array.isArray(value)) {
+              value = value.map((v) => {
+                const [k] = typeof v === "string" ? v.split("<&=&>") : [];
+                return k;
+              });
+              value = value.join("|#|");
+            }
+            temp.value = value;
+          } else {
+            if (hasArr) {
+              if (item.con == "CONVERT") {
+                let value = [];
+                value = item.value.map((i) => {
+                  return item.labelList[i].filter;
+                });
+                temp.value = value;
+              } else {
+                let value = [];
+                value = item.value.map((i) => {
+                  return item.labelList[i].labelName;
+                });
+                temp.value = value.join("|#|");
+              }
+            }
+          }
+          conObj.push(temp);
+        }
+        if (item.com === "DatePicker" && item.value.length) {
+          const start_val = item.value[0].format(item.showFormat);
+          const end_val = item.value[1].format(item.showFormat);
+          if (item.settingObj.attr === "BIRTHDAY") {
+            temp.limit_date = `${start_val}~${end_val}`;
+          } else {
+            temp.start_val = start_val;
+            temp.end_val = end_val;
+          }
+          conObj.push(temp);
+        }
+        if (item.com === "DayPicker" && item.value) {
+          const start_val = item.value.startOf("day").format("YYYY-MM-DD HH:mm:ss");
+          const end_val = item.value.endOf("day").format("YYYY-MM-DD HH:mm:ss");
+          if (item.settingObj.attr === "BIRTHDAY") {
+            temp.limit_date = `${start_val}~${end_val}`;
+          } else {
+            temp.start_val = start_val;
+            temp.end_val = end_val;
+          }
+          conObj.push(temp);
+        }
+        if (item.AGEAttr) {
+          temp.value = "";
+          temp.con = "IN";
+          const start_val = Number(item.lessValue) * 365;
+          const end_val = Number(item.bigValue) * 365;
+          if ((start_val || start_val === 0) && end_val) {
+            temp.start_val = start_val;
+            temp.end_val = end_val;
+            conObj.push(JSON.parse(JSON.stringify(temp)));
+          }
+        } else if (item.com === "Number") {
+          let lessValue = (_a = item.lessValue) != null ? _a : "";
+          let bigValue = (_b = item.bigValue) != null ? _b : "";
+          if (lessValue || bigValue) {
+            if (((_c = item.settingObj) == null ? void 0 : _c.attr) === "PERCENTAGE") {
+              lessValue = (lessValue || lessValue === 0) && Number(lessValue) / 100 || "";
+              bigValue = (bigValue || bigValue === 0) && Number(bigValue) / 100;
+            }
+            temp.value = `${lessValue}~${bigValue}`;
+          }
+          temp.con = "EQ";
+          conObj.push(JSON.parse(JSON.stringify(temp)));
+        }
+        if (item.com === "SelectQuote" && item.value.length) {
+          temp.value = item.value.join("|#|");
+          conObj.push(temp);
+        }
+      });
+      const res = conObj.filter(
+        (item) => item.value || item.limit_date || item.start_val || item.end_val
+      );
+      return res;
+    }
+  };
+  return { filterApiConfig, handleGetConfigApi, $utils, outQuickSearchFn };
+}
+
+export { useMixins as default };

package/es/components/table-filter/src/hooks/useRenderWidget.d.ts

@@ -0,0 +1,15 @@
+import { ISearchType, ISearchConfigType } from '../../../../../es/components/table-filter/src/types';
+export default function (): {
+    isRender: (cfg: ISearchType) => any;
+    getDefValByRenderWidget: (cfg: ISearchType) => any;
+    initRenderWidgetCfg: (cfg: ISearchType) => any;
+    getRenderSearchConObj: (cfg: ISearchType) => {
+        field_key: string;
+        con: string | undefined;
+        value: any[] | null;
+        unit: null;
+    } | null;
+    getDefValByRenderConObj: (conObj: ISearchConfigType, cfg: ISearchType) => any;
+    isExistDefValByRenderWidget: (cfg: ISearchType) => boolean;
+    resetRenderWidgetValue: (cfg: ISearchType) => any;
+};

package/es/components/table-filter/src/hooks/useRenderWidget.js

@@ -0,0 +1,94 @@
+import { WidgetCfgMaps } from '../components/render-widget/widgetCfgMaps.js';
+import { WidgetTypeEnums, DatePresetValEnums } from '../components/render-widget/enums.js';
+
+function randomkey() {
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+    const r = Math.random() * 16 | 0;
+    const v = c === "x" ? r : r & 3 | 8;
+    return v.toString(16);
+  });
+}
+const BlockEle = [WidgetTypeEnums.CHECKBOX_GROUP];
+function useRenderWidget() {
+  function isRenderFunc(cfg) {
+    var _a;
+    return (_a = cfg.widgetCfg) == null ? void 0 : _a.isRender;
+  }
+  function getDefValByRenderWidget(cfg) {
+    const { widgetType, defaultValue, defValueUnit } = cfg.widgetCfg || {};
+    const Widget = WidgetCfgMaps.get(widgetType);
+    let defVal;
+    if (Widget) {
+      const { setDefaultValue } = Widget;
+      if (setDefaultValue)
+        defVal = setDefaultValue(defaultValue, defValueUnit);
+    }
+    return defVal;
+  }
+  function initRenderWidgetCfg(cfg) {
+    const isRender = isRenderFunc(cfg);
+    if (!isRender)
+      return isRender;
+    const { widgetType } = cfg.widgetCfg || {};
+    cfg._frontId = randomkey();
+    cfg.isRender = isRender;
+    cfg.widgetType = widgetType;
+    cfg.con = "EQ";
+    if (BlockEle.includes(widgetType)) {
+      cfg._isBlock = true;
+    }
+    cfg.value = getDefValByRenderWidget(cfg);
+    return isRender;
+  }
+  function getRenderSearchConObj(cfg) {
+    const isRender = isRenderFunc(cfg);
+    if (!isRender)
+      return null;
+    const { columnName, con, value, widgetType } = cfg;
+    let unit = null;
+    const dateWidgetTypes = [WidgetTypeEnums.DATE, WidgetTypeEnums.DATE_TIME];
+    if (dateWidgetTypes.includes(widgetType)) {
+      unit = DatePresetValEnums.CUSTOM;
+    }
+    const val = Array.isArray(value) ? value : value ? [value] : [];
+    return {
+      field_key: columnName,
+      con,
+      value: val.length > 0 ? val : null,
+      unit
+    };
+  }
+  function getDefValByRenderConObj(conObj, cfg) {
+    const isRender = isRenderFunc(cfg);
+    if (!isRender)
+      return null;
+    const { widgetType, multiple } = cfg.widgetCfg || {};
+    const { value } = conObj;
+    if ((widgetType === WidgetTypeEnums.SELECT || widgetType === WidgetTypeEnums.CHECKBOX_GROUP) && multiple) {
+      return Array.isArray(value) ? value : value ? [value] : [];
+    }
+    return !Array.isArray(value) ? value : value[0];
+  }
+  function isExistDefValByRenderWidget(cfg) {
+    const { defaultValue, defValueUnit } = cfg.widgetCfg || {};
+    return !!(defaultValue || defValueUnit);
+  }
+  function resetRenderWidgetValue(cfg) {
+    const isRender = isRenderFunc(cfg);
+    if (!isRender)
+      return isRender;
+    cfg.value = void 0;
+    return isRender;
+  }
+  return {
+    isRender: isRenderFunc,
+    getDefValByRenderWidget,
+    initRenderWidgetCfg,
+    getRenderSearchConObj,
+    getDefValByRenderConObj,
+    isExistDefValByRenderWidget,
+    resetRenderWidgetValue
+  };
+}
+
+export { useRenderWidget as default };

package/es/components/table-filter/src/hooks/useTableSearchCon.d.ts

@@ -0,0 +1,8 @@
+import moment from 'moment';
+import 'moment/locale/zh-cn';
+import { ISearchType } from '../../../../../es/components/table-filter/src/types';
+export default function (): {
+    validConObj: (conObj: any, fieldList: ISearchType[], fieldSearchLimit: any) => any;
+    getSearchDefValueByLimit: (field: ISearchType, searchLimit?: any) => "" | moment.Moment[];
+    formatSearchLimit: (limitList: any, freeze?: boolean) => any;
+};