cnhis-design-vue 3.1.40-beta.0 → 3.1.40-beta.10

package/es/components/table-filter/src/components/classify-filter/hooks/useDisplayCategory.js

@@ -0,0 +1,87 @@
+import { reactive, computed } from 'vue';
+import { useMessage } from 'naive-ui';
+
+const $message = useMessage();
+const useDisplayCategory = (selectedDisplayCategory, { conditionList }) => {
+  const State = reactive({
+    displayCategories: [],
+    displayCategoryOriginLen: 0,
+    showAdd: false,
+    addDisplayCategory: ""
+  });
+  const isEnableAddDisplayCategory = computed(() => {
+    return State.displayCategories.length === State.displayCategoryOriginLen;
+  });
+  const editDisplayCategory = (e, item) => {
+    item.disabled = false;
+    setTimeout(() => {
+      e.target.focus();
+    }, 0);
+  };
+  const handleDisplayCategorySelect = (item) => {
+    if (!item.disabled)
+      return;
+    if (selectedDisplayCategory.value === item.value) {
+      selectedDisplayCategory.value = "";
+    } else {
+      selectedDisplayCategory.value = item.value;
+    }
+  };
+  const handleDisplayCategoryRemove = (index, item) => {
+    if (!conditionList.value || !conditionList.value.length) {
+      State.displayCategories.splice(index, 1);
+      return;
+    }
+    const hasItem = conditionList.value.filter((v) => v.displayCategory === item.value);
+    if (!hasItem || !hasItem.length) {
+      State.displayCategories.splice(index, 1);
+      return;
+    }
+    $message.error("\u8BE5\u5206\u7C7B\u4E0B\u6709\u5DF2\u6709\u6570\u636E\uFF0C\u8BF7\u5220\u9664\u8BE5\u5206\u7C7B\u4E0B\u7684\u7B5B\u9009\u96C6\u540E\u91CD\u8BD5\uFF01");
+  };
+  const handleDisplayCategoryAdd = (e) => {
+    var _a;
+    const nextInput = (_a = e == null ? void 0 : e.target) == null ? void 0 : _a.nextElementSibling;
+    setTimeout(() => {
+      nextInput && nextInput.focus();
+    });
+    State.showAdd = true;
+  };
+  const handlerBlur = () => {
+    State.showAdd = false;
+    if (!State.addDisplayCategory)
+      return;
+    State.displayCategories.push({
+      disabled: true,
+      value: State.addDisplayCategory
+    });
+    selectedDisplayCategory.value = State.addDisplayCategory;
+    State.addDisplayCategory = "";
+  };
+  const initDisplayCategories = (rawDataDisplayCategories, displayCategory) => {
+    const displayCategories = [];
+    rawDataDisplayCategories.forEach((item) => {
+      if (item !== "\u672A\u5206\u7C7B") {
+        displayCategories.push({
+          disabled: true,
+          value: item
+        });
+      }
+    });
+    State.displayCategories = displayCategories;
+    State.displayCategoryOriginLen = State.displayCategories.length;
+    selectedDisplayCategory.value = displayCategory;
+  };
+  return {
+    State,
+    isEnableAddDisplayCategory,
+    editDisplayCategory,
+    handleDisplayCategorySelect,
+    handleDisplayCategoryRemove,
+    handleDisplayCategoryAdd,
+    handlerBlur,
+    initDisplayCategories
+  };
+};
+
+export { useDisplayCategory };

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

@@ -0,0 +1,59 @@
+import { Ref } from 'vue';
+import { ISearchConfigType } from '../../../../../../../es/components/table-filter/src/types';
+export declare const getTableAdvancedFilterCfg: (tableListId: string) => Promise<({
+    name: string;
+    title: string;
+    dataType: string;
+    type: string;
+    isShowSearch: boolean;
+    filterExplicit: boolean;
+    explicitRequired: boolean;
+    optionType?: undefined;
+    optionInfo?: undefined;
+    defaultValue?: undefined;
+} | {
+    name: string;
+    title: string;
+    dataType: string;
+    type: string;
+    optionType: string;
+    isShowSearch: boolean;
+    filterExplicit: boolean;
+    explicitRequired: boolean;
+    optionInfo: {
+        list: {
+            name: string;
+            value: string;
+        }[];
+    };
+    defaultValue?: undefined;
+} | {
+    name: string;
+    title: string;
+    dataType: string;
+    type: string;
+    isShowSearch: boolean;
+    filterExplicit: boolean;
+    explicitRequired: boolean;
+    defaultValue: {
+        unit: string;
+    };
+    optionType?: undefined;
+    optionInfo?: undefined;
+})[]>;
+export declare const useFilterConditions: (filterConditions: Ref, dataType: string) => {
+    State: any;
+    paramOptions: import("vue").ComputedRef<any>;
+    addFilterCondition: () => void;
+    delFilterCondition: (index: number) => void;
+    updateKey: (index: number, val: any) => void;
+    updateCondition: (index: number, val: any) => void;
+    getParamCfg: (key: string) => any;
+    initFilterConditions: (tableId: string, rawConditions: ISearchConfigType) => Promise<void>;
+    getRawFilterConditions: () => {
+        field_key: any;
+        con: any;
+        value: any;
+        unit: any;
+    }[];
+};

package/es/components/table-filter/src/components/classify-filter/hooks/useFilterConditions.js

@@ -0,0 +1,147 @@
+import { reactive, computed, toRaw, unref } from 'vue';
+import { ConditionEnums, WidgetTypeEnums, WidgetOptionEnums } from '../../../types/enums.js';
+import { transformConditions, transformRawConditions, transformDataToFront } from '../../../tool/transformData.js';
+
+const getTableAdvancedFilterCfg = async (tableListId) => {
+  return await [
+    {
+      "name": "ruleCode",
+      "title": "\u89C4\u5219\u6807\u8BC6",
+      "dataType": "TEXT",
+      "type": "TEXT",
+      "isShowSearch": true,
+      "filterExplicit": false,
+      "explicitRequired": false
+    },
+    {
+      "name": "batchNumber",
+      "title": "\u6279\u6B21\u53F7",
+      "dataType": "TEXT",
+      "type": "TEXT",
+      "isShowSearch": true,
+      "filterExplicit": true,
+      "explicitRequired": false
+    },
+    {
+      "name": "result",
+      "title": "\u6267\u884C\u7ED3\u679C",
+      "dataType": "TEXT",
+      "type": "SELECT",
+      "optionType": "SELECT_SINGLE",
+      "isShowSearch": true,
+      "filterExplicit": true,
+      "explicitRequired": false,
+      "optionInfo": {
+        "list": [
+          {
+            "name": "\u6210\u529F\u4E0B\u62C9\u6846",
+            "value": "true"
+          },
+          {
+            "name": "\u5931\u8D25\u4E0B\u62C9\u6846",
+            "value": "false"
+          }
+        ]
+      }
+    },
+    {
+      "name": "startTime",
+      "title": "\u5F00\u59CB\u65F6\u95F4",
+      "dataType": "DATE",
+      "type": "DATE",
+      "isShowSearch": true,
+      "filterExplicit": true,
+      "explicitRequired": false,
+      "defaultValue": {
+        "unit": "THIS_WEEK_START"
+      }
+    },
+    {
+      "name": "endTime",
+      "title": "\u7ED3\u675F\u65F6\u95F4",
+      "dataType": "DATETIME",
+      "type": "DATETIME",
+      "isShowSearch": true,
+      "filterExplicit": true,
+      "explicitRequired": false,
+      "defaultValue": {
+        "unit": "THIS_WEEK_END"
+      }
+    },
+    {
+      "name": "keyword",
+      "title": "\u5173\u952E\u5B57",
+      "dataType": "TEXT",
+      "type": "TEXT",
+      "isShowSearch": true,
+      "filterExplicit": true,
+      "explicitRequired": false
+    }
+  ];
+};
+const useFilterConditions = (filterConditions, dataType) => {
+  const State = reactive({
+    params: []
+  });
+  const paramOptions = computed(
+    () => State.params.map(({ p_name, title }) => ({ label: title || p_name, value: p_name }))
+  );
+  const getParamCfg = (key) => {
+    const item = State.params.find((i) => i.p_name === key);
+    return item;
+  };
+  const clearByCondition = (filterCondition) => {
+    const cfg = getParamCfg(filterCondition.key);
+    filterCondition.value = (cfg == null ? void 0 : cfg.type) === WidgetTypeEnums.SELECT && (cfg == null ? void 0 : cfg.optionSetting) === WidgetOptionEnums.MULTIPLE ? [] : null;
+    filterCondition.timeVal = null;
+  };
+  const updateCondition = (index, val) => {
+    const filterCondition = filterConditions.value[index];
+    if (filterCondition) {
+      filterCondition.condition = val;
+      clearByCondition(filterCondition);
+    }
+  };
+  const updateKey = (index, val) => {
+    const filterCondition = filterConditions.value[index];
+    if (filterCondition) {
+      filterCondition.key = val;
+      updateCondition(index, ConditionEnums.EQUAL);
+    }
+  };
+  const addFilterCondition = () => {
+    filterConditions.value.push({ key: null, condition: null, value: null, presetVal: null });
+  };
+  const delFilterCondition = (index) => {
+    filterConditions.value.splice(index, 1);
+  };
+  const getParamsData = async (tableId) => {
+    try {
+      const advancedFilterRawData = await getTableAdvancedFilterCfg(tableId);
+      return transformDataToFront(dataType, advancedFilterRawData);
+    } catch (e) {
+      return [];
+    }
+  };
+  const initFilterConditions = async (tableId, rawConditions) => {
+    const params = await getParamsData(tableId);
+    State.params = params;
+    filterConditions.value = transformConditions(rawConditions, toRaw(State.params));
+  };
+  const getRawFilterConditions = () => {
+    return transformRawConditions(unref(filterConditions));
+  };
+  return {
+    State,
+    paramOptions,
+    addFilterCondition,
+    delFilterCondition,
+    updateKey,
+    updateCondition,
+    getParamCfg,
+    initFilterConditions,
+    getRawFilterConditions
+  };
+};
+
+export { getTableAdvancedFilterCfg, useFilterConditions };

package/es/components/table-filter/src/components/classify-filter/index.vue.d.ts

@@ -0,0 +1,278 @@
+import { PropType } from 'vue';
+import { IClassifyListType, ICategoryItemType } from '../../../../../../es/components/table-filter/src/types';
+declare const _default: import("vue").DefineComponent<{
+    actionList_prop: {
+        type: PropType<IClassifyListType>;
+        default: () => {};
+    };
+    conditionList: {
+        type: ArrayConstructor;
+        default: () => never[];
+    };
+    tableId: {
+        type: StringConstructor;
+        default: string;
+    };
+}, {
+    $message: import("naive-ui").MessageApi;
+    props: Readonly<import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
+        actionList_prop: {
+            type: PropType<IClassifyListType>;
+            default: () => {};
+        };
+        conditionList: {
+            type: ArrayConstructor;
+            default: () => never[];
+        };
+        tableId: {
+            type: StringConstructor;
+            default: string;
+        };
+    }>> & {
+        onSaveAdd?: ((...args: any[]) => any) | undefined;
+        onCancelSaveAdd?: ((...args: any[]) => any) | undefined;
+    }>>;
+    emit: (event: "saveAdd" | "cancelSaveAdd", ...args: any[]) => void;
+    $attrs: {
+        [x: string]: unknown;
+    };
+    FormState: {
+        className: string;
+        displayCategory: string;
+        filterConditions: {
+            value: string;
+            key: string;
+            condition: string;
+            presetVal: string;
+        }[];
+    };
+    loading: import("vue").Ref<boolean>;
+    DisplayCategoryState: {
+        addDisplayCategory: string;
+        displayCategories: {
+            disabled: boolean;
+            value: string;
+        }[];
+        displayCategoryOriginLen: number;
+        showAdd: boolean;
+    };
+    isEnableAddDisplayCategory: import("vue").ComputedRef<boolean>;
+    editDisplayCategory: (e: any, item: ICategoryItemType) => void;
+    handleDisplayCategorySelect: (item: ICategoryItemType) => void;
+    handleDisplayCategoryRemove: (index: number, item: ICategoryItemType) => void;
+    handleDisplayCategoryAdd: (e: any) => void;
+    handlerBlur: () => void;
+    initDisplayCategories: (rawDataDisplayCategories: any, displayCategory: any) => void;
+    FilterConditionsState: any;
+    paramOptions: import("vue").ComputedRef<any>;
+    addFilterCondition: () => void;
+    delFilterCondition: (index: number) => void;
+    updateKey: (index: number, val: any) => void;
+    updateCondition: (index: number, val: any) => void;
+    getParamCfg: (key: string) => any;
+    initFilterConditions: (tableId: string, rawConditions: import("../../../../../../es/components/table-filter/src/types").ISearchConfigType) => Promise<void>;
+    getRawFilterConditions: () => {
+        field_key: any;
+        con: any;
+        value: any;
+        unit: any;
+    }[];
+    findConditionByDisplayCategory: (displayCategory: string) => unknown;
+    handleDisplayCategorySelectProxy: (item: ICategoryItemType) => void;
+    clearFormData: () => void;
+    handleInitConditions: () => Promise<void>;
+    validate: () => Promise<unknown>;
+    saveAdd: () => void;
+    cancelSaveAdd: () => void;
+    NSpin: any;
+    NIcon: any;
+    NInput: any;
+    NButton: any;
+    NTooltip: any;
+    NSelect: any;
+    AddOutline: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, import("vue").EmitsOptions, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{}>>, {}>;
+    AddCircleSharp: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, import("vue").EmitsOptions, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{}>>, {}>;
+    CloseOutline: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, import("vue").EmitsOptions, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{}>>, {}>;
+    SvgIcon: import("vue").DefineComponent<{
+        iconClass: {
+            type: StringConstructor;
+            required: true;
+            default: string;
+        };
+        title: {
+            type: StringConstructor;
+            required: false;
+            default: string;
+        };
+        className: {
+            type: StringConstructor;
+            required: false;
+        };
+    }, {
+        props: {
+            iconClass: string;
+            title: string;
+            className?: string | undefined;
+        };
+        iconName: import("vue").ComputedRef<string>;
+        svgClass: import("vue").ComputedRef<string>;
+    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+        iconClass: {
+            type: StringConstructor;
+            required: true;
+            default: string;
+        };
+        title: {
+            type: StringConstructor;
+            required: false;
+            default: string;
+        };
+        className: {
+            type: StringConstructor;
+            required: false;
+        };
+    }>>, {
+        title: string;
+        iconClass: string;
+    }>;
+    ValueCfg: import("vue").DefineComponent<{
+        paramCfg: {
+            type: ObjectConstructor;
+            default: null;
+        };
+        modelValue: {
+            type: (ArrayConstructor | NumberConstructor | StringConstructor)[];
+            default: null;
+        };
+        presetVal: {
+            type: StringConstructor;
+            default: null;
+        };
+    }, {
+        props: Readonly<import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
+            paramCfg: {
+                type: ObjectConstructor;
+                default: null;
+            };
+            modelValue: {
+                type: (ArrayConstructor | NumberConstructor | StringConstructor)[];
+                default: null;
+            };
+            presetVal: {
+                type: StringConstructor;
+                default: null;
+            };
+        }>> & {
+            "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+            "onUpdate:presetVal"?: ((...args: any[]) => any) | undefined;
+        }>>;
+        emit: (event: "update:modelValue" | "update:presetVal", ...args: any[]) => void;
+        valueCp: import("vue").WritableComputedRef<unknown>;
+        presetValCp: import("vue").WritableComputedRef<unknown>;
+        widgetType: import("vue").ComputedRef<any>;
+        optionSetting: import("vue").ComputedRef<any>;
+        mappingConfig: import("vue").ComputedRef<any>;
+        widgetOptions: import("vue").ComputedRef<{
+            label: string;
+            value: string;
+        }[]>;
+        NInputNumber: any;
+        NInput: any;
+        NSelect: any;
+        NDatePicker: any;
+        WidgetTypeEnums: {
+            INPUT_NUMBER: string;
+            INPUT: string;
+            SELECT: string;
+            DATE: string;
+            DATE_TIME: string;
+        };
+        WidgetValEnums: {
+            CUSTOM: string;
+            FIRST_VAL: string;
+            NOW: string;
+            TODAY: string;
+            TODAY_START: string;
+            TODAY_END: string;
+            TOMORROW: string;
+            TOMORROW_START: string;
+            TOMORROW_END: string;
+            YESTERDAY: string;
+            YESTERDAY_START: string;
+            YESTERDAY_END: string;
+            THIS_WEEK: string;
+            WEEK_START: string;
+            WEEK_END: string;
+            NEXT_WEEK: string;
+            LAST_WEEK: string;
+            THIS_MONTH: string;
+            MONTH_START: string;
+            MONTH_END: string;
+            NEXT_MONTH: string;
+            LAST_MONTH: string;
+            THIS_QUARTER: string;
+            NEXT_QUARTER: string;
+            LAST_QUARTER: string;
+            THIS_YEAR: string;
+            NEXT_YEAR: string;
+            LAST_YEAR: string;
+        };
+        WidgetOptionEnums: {
+            RADIO: string;
+            MULTIPLE: string;
+            ALL: string;
+            SELECT_TIME: string;
+            PAST_TIME: string;
+            FUTURE_TIME: string;
+        };
+    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("update:modelValue" | "update:presetVal")[], "update:modelValue" | "update:presetVal", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+        paramCfg: {
+            type: ObjectConstructor;
+            default: null;
+        };
+        modelValue: {
+            type: (ArrayConstructor | NumberConstructor | StringConstructor)[];
+            default: null;
+        };
+        presetVal: {
+            type: StringConstructor;
+            default: null;
+        };
+    }>> & {
+        "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+        "onUpdate:presetVal"?: ((...args: any[]) => any) | undefined;
+    }, {
+        modelValue: string | number | unknown[];
+        presetVal: string;
+        paramCfg: Record<string, any>;
+    }>;
+    ConditionEnums: {
+        NULL: string;
+        EQUAL: string;
+    };
+    conditionOptions: {
+        label: string;
+        value: string;
+    }[];
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("saveAdd" | "cancelSaveAdd")[], "saveAdd" | "cancelSaveAdd", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    actionList_prop: {
+        type: PropType<IClassifyListType>;
+        default: () => {};
+    };
+    conditionList: {
+        type: ArrayConstructor;
+        default: () => never[];
+    };
+    tableId: {
+        type: StringConstructor;
+        default: string;
+    };
+}>> & {
+    onSaveAdd?: ((...args: any[]) => any) | undefined;
+    onCancelSaveAdd?: ((...args: any[]) => any) | undefined;
+}, {
+    tableId: string;
+    actionList_prop: IClassifyListType;
+    conditionList: unknown[];
+}>;
+export default _default;