标签模板，主页，默认工艺路线更新

Ben Lin

2024-11-08 3d2c48733b86a03fc2e5a1f12ac3667ab0863b80

 src/views/tigerprojects/system/lowcode/entityts/BAS_LABEL_VAR.ts

@@ -1,23 +1,37 @@
/*
 * @Description: 产品工艺路线相关
 * @Description: 模板变量相关
 * @Author: Ben Lin
 * @version:
 * @Date: 2024-06-19 20:34:27
 * @LastEditors: Ben Lin
 * @LastEditTime: 2024-06-28 10:53:28
 * @LastEditTime: 2024-10-22 11:40:44
 */

import { Tag, Tooltip } from 'ant-design-vue';
import { ActionItem, BasicColumn } from '/@/components/Table';
import { ActionItem, BasicColumn, FormSchema, useTable } from '/@/components/Table';
import { useI18n } from '/@/hooks/web/useI18n';
import { h, unref } from 'vue';
import { GetEnum } from '/@/api/tigerapi/system';
import { h, ref, Ref, unref } from 'vue';
import { AddAfterDelete, getEntity, GetEnum } from '/@/api/tigerapi/system';
import { useLocale } from '/@/locales/useLocale';
import { useDrawer } from '/@/components/Drawer';
import { custDel, EditOperation, Search } from '../data';
import { buildUUID } from '/@/utils/uuid';
import { CustModalParams, FunctionType } from '/@/api/tigerapi/model/systemModel';
import { useModal } from '/@/components/Modal';
import { SaveLabelTemplate } from '/@/api/tigerapi/mes/label';
import {
  BAS_LABEL_TEMP,
  BAS_LABEL_VAR,
  BAS_LABEL_VAR_WO,
  BasLabelTempInput,
} from '/@/api/tigerapi/model/mesModel';
import { useUserStore } from '/@/store/modules/user';
import { cloneDeep } from 'lodash-es';

const { getLocale } = useLocale();

const { t } = useI18n();

let newRow = {};
function _default() {
  const ActionColumn: BasicColumn = {
    width: 80,
@@ -30,93 +44,209 @@
  /**
   * @description: 一些自定义方法
   * @return {*}
   */  
   */
  const methods = {
    /**
     * @description: 获取新增按钮的行为，必需要有的方法
     * @return {*}
     */
    CreateAction: (fnName: string) => {
      return {
        action: 'drawer', //drawer(打开左侧抽屉框) | go(跳转到新的页面)
      };
    CreateAction: (type: string) => {
      let action = {} as any;
      switch (type) {
        case 'BAS_LABEL_VAR':
        case 'BAS_LABEL_VAR_WO':
          action = {
            action: 'edit', //drawer(打开左侧抽屉框) | go(跳转到新的页面) | edit(如果是表格可编辑页面就是自定义方法)
          };
          break;
      }
      return action;
    },
    /**
     * @description: 产品绑定工艺路线操作字段自定义按钮，必需要有的方法
     * @description: 操作字段自定义按钮，必需要有的方法
     * @return {*}
     */
    ActionItem: (params: Recordable<any>, data, ...args): ActionItem[] => {
      data.map((x) => {
        if (x.name == 'Delete') {
          x.popConfirm.confirm = custDel.bind(null, args, params);
          x.tooltip = '删除';
        }
      });
      return data;
    },
    /**
     * @description: 高级表单和详情页面返回主页面的url
     * @return {*}
     */    
    GetHomeUrl: () => {
      return `/BAS_LABEL_TEMP/LC/${encodeURI(JSON.stringify({ ID: 'BAS_LABEL_TEMP', colSlots: [], crudColSlots: [] }))}`;
     */
    GetHomeUrl: (params: {}) => {
      return `/BAS_LABEL_TEMP/LC/${encodeURI(JSON.stringify({ ID: 'BAS_LABEL_TEMP', colSlots: params['colSlots'], crudColSlots: [] }))}`;
    },
    GetBaseColumns: () => {
    /**
     * @description: 获取主信息
     * @return {*}
     */
    GetBaseForm: (type, ...args) => {
      return [
        {
          dataIndex: 'LABEL_ID',
          title: '标签模板ID',
          ifShow: false,
          sorter: true,
          resizable: true,
          field: 'LABEL_CODE',
          label: '标签模板编码',
          component: 'Input',
          required: true,
          isexist: 'Y',
          colProps: {
            span: 8,
          },
          dynamicDisabled: true,
        },
        {
          dataIndex: 'VAR_NAME',
          title: '变量名称',
          ifShow: true,
          sorter: true,
          resizable: true,
          customRender: () => {},
        },
        {
          dataIndex: 'VAR_TYPE',
          title: '变量类型',
          ifShow: true,
          sorter: true,
          resizable: true,
          customRender: ({ record }) => {
            let color = '';
            let text = '';
            switch (record.VAR_TYPE) {
              case 0:
                text = '常量';
                color = 'green';
                break;
              case 1:
                text = '过程变量';
                color = 'orange';
                break;
              case 2:
                text = '日期变量';
                color = '#4f68b0';
                break;
              case 3:
                text = '自定义变量';
                color = '#bfbfbf';
                break;
            }
            return h(Tooltip, { title: text }, () => h(Tag, { color: color }, () => text));
          label: '标签模板名称',
          field: 'LABEL_NAME',
          required: true,
          component: 'Input',
          colProps: {
            span: 8,
          },
        },
        {
          dataIndex: 'VAR_VALUE',
          title: '变量值',
          ifShow: true,
          sorter: true,
          resizable: true,
          label: '模板类型',
          field: 'TEMP_TYPE',
          required: true,
          component: 'ApiSelect',
          colProps: {
            span: 8,
          },
          componentProps: {
            api: GetEnum,
            params: { name: 'BAS_LABEL_TEMP+TEMP_TYPEs' },
            resultField: 'Data',
            labelField: unref(getLocale) == 'zh_CN' ? 'Desc' : 'Name',
            valueField: 'Value',
          },
        },
        // {
        //   field: 'TEMP_PATH',
        //   label: '标签模板相对路径',
        //   component: 'Upload',
        //   isexist: 'N',
        //   show: true,
        //   required: true,
        //   colProps: {
        //     span: 8,
        //   },
        //   componentProps: ({ formModel }) => {
        //     return {
        //       resultField: 'data3.url',
        //       multiple: false,
        //       uploadParams: { entityName: type },
        //       api: (file, progress) => {
        //         console.log(formModel);
        //         return new Promise((resolve) => {
        //           uploadApi(file, progress).then((uploadApiResponse) => {
        //             const webSocketStore = useWebSocketStore();
        //             if (webSocketStore.GetSocketState == 1) {
        //               webSocketStore.sendMessage(
        //                 `wsSubStrings ${formModel['ID']}_#_${uploadApiResponse.data.url}`,
        //               );
        //             }
        //             resolve({
        //               code: 200,
        //               data3: {
        //                 url: uploadApiResponse.data.url,
        //               },
        //             });
        //           });
        //         });
        //       },
        //     };
        //   },
        // },
        {
          field: 'PROD_CODE',
          label: '产品编码',
          component: 'Input',
          isexist: 'N',
          show: true,
          // required: true,
          colProps: {
            span: 7,
          },
        },
        {
          dataIndex: 'REMARK',
          title: '备注',
          ifShow: true,
          sorter: true,
          resizable: true,
          field: 'BAS_LABEL_VAR1PSelect_0', //按低代码配置的规则，实体名+序号+PSelect_0，序号用来区分多个的时候，PSelect_0这是个固定后缀
          label: '1',
          defaultValue: 'BAS_LABEL_VAR',
          component: 'Input',
          colProps: { span: 1 },
          colSlot: 'BAS_LABEL_VAR1add', //按低代码配置的规则，实体名+序号+add，序号用来区分多个的时候，add这是个固定后缀
        },
        {
          field: 'CUST_CODE',
          label: '客户编码',
          component: 'Input',
          isexist: 'N',
          show: true,
          // required: true,
          colProps: {
            span: 7,
          },
        },
        {
          field: 'BAS_LABEL_VAR2PSelect_0', //按低代码配置的规则，实体名+序号+PSelect_0，序号用来区分多个的时候，PSelect_0这是个固定后缀
          label: '1',
          defaultValue: 'BAS_CUSTOMER',
          component: 'Input',
          colProps: { span: 1 },
          colSlot: 'BAS_LABEL_VAR2add', //按低代码配置的规则，实体名+序号+add，序号用来区分多个的时候，add这是个固定后缀
        },
        {
          label: '备注',
          field: 'REMARK',
          component: 'Input',
          colProps: {
            span: 8,
          },
        },
        {
          label: '标签模板相对路径',
          field: 'TEMP_PATH',
          required: true,
          component: 'Input',
          colProps: {
            span: 16,
          },
        },
        {
          label: 'ID',
          field: 'ID',
          component: 'Input',
          colProps: {
            span: 8,
          },
          show: false,
        },
      ];
    },
    /**
     * @description: 弹出选择框成功返回赋值方法
     * @param {*} d
     * @param {*} u
     * @return {*}
     */
    GetSelectSuccess: (d, u) => {
      return {
        PROD_CODE: d.values['val'],
      };
    },
    /**
     * @description: 获取模态框应用列表
     * @return {*}
     */
    GetUseModals: () => {
      return {
        BAS_LABEL_VAR1add: useModal(),
        BAS_LABEL_VAR2add: useModal(),
      };
    },
    GetSearchForm: () => {
      return [
@@ -209,9 +339,1024 @@
        },
      ];
    },
    OthersValues: (val: string, id: string) => {
    /**
     * @description: 获取新增行的数据
     * @param {string} type
     * @return {*}
     */
    GetNewRow: (type: string) => {
      let values = {};
      switch (type) {
        case 'BAS_LABEL_VAR':
          values = {
            VAR_NAME: '',
            VAR_TYPE: '',
            VAR_VALUE: '',
            BARCODE_RULE: '',
            REMARK: '',
          };
          break;
        case 'BAS_LABEL_VAR_WO':
          values = newRow;
          break;
      }
      return values;
    },
    KeyFieldValues: (val: string, id: string) => {
      return { LABEL_ID: id };
    },
    GetUseForm: () => {
      return {};
    },
    /**
     * @description: 获取标题信息
     * @param {string} type
     * @return {*}
     */
    GetTitle: () => {
      return {
        pageTitle: '打印模板管理',
        pageContent: '这里可以添加和修改模板和模板变量及工单模板变量。',
        tableTitle: {
          BAS_LABEL_VAR: '模板变量管理',
          BAS_LABEL_VAR_WO: '工单模板变量管理',
        },
      };
    },
    /**
     * @description: 获取卡片内配置列表，以循环显示多个卡片并配置多个插槽
     * @return {*}
     */
    GetBaseCards: (type: string) => {
      return [
        {
          name: 'BaseForm', //第一个卡片名称必需是BaseForm
          slots: [],
          preIcons: {},
          title: '模板信息',
          entityName: 'BAS_LABEL_TEMP',
        },
      ];
    },
    /**
     * @description: 获取右侧边框use方法
     * @return {*}
     */
    GetUseDrawers: () => {
      return [
        {
          BAS_LABEL_VAR: useDrawer(),
        },
        // { BAS_LABEL_VAR_WO: useDrawer() },
      ];
    },
    /**
     * @description: 获取表格use列表
     * @param {string} type
     * @param {array} args
     * @return {*}
     */
    GetUseTables: (data: Ref<{}>, ...args) => {
      // _data = data;
      return {
        BAS_LABEL_VAR: useTable({
          title: '列表信息',
          dataSource: data.value['BAS_LABEL_VAR'],
          columns: GetBaseColumns('BAS_LABEL_VAR', args[0], data),
          maxHeight: 520,
          formConfig: {
            labelWidth: 140,
            schemas: searchForms['BAS_LABEL_VAR'],
            submitFunc: () => Search('BAS_LABEL_VAR', data, args[0]), //自定义查询提交按钮的方法，触发查询提交事件
          },
          useSearchForm: false,
          showTableSetting: false,
          bordered: true,
          canResize: true,
          showIndexColumn: false,
          // rowSelection: {
          //   type: 'radio', //'checkbox'
          // },
          actionColumn: {
            width: 130,
            title: '操作',
            dataIndex: 'action',
            slots: { customRender: 'action' },
            fixed: 'right',
          }, //自定义操作列
        }),
        BAS_LABEL_VAR_WO: useTable({
          title: '列表信息',
          dataSource: data.value['BAS_LABEL_VAR_WO'],
          columns: GetBaseColumns('BAS_LABEL_VAR_WO', args[0], data),
          scroll: { y: 500 },
          formConfig: {
            labelWidth: 140,
            schemas: searchForms['BAS_LABEL_VAR_WO'],
            submitFunc: () => Search('BAS_LABEL_VAR_WO', data, args[0]), //自定义查询提交按钮的方法，触发查询提交事件
          },
          useSearchForm: false,
          showTableSetting: false,
          bordered: true,
          canResize: false,
          showIndexColumn: false,
          actionColumn: {
            width: 130,
            title: '操作',
            dataIndex: 'action',
            slots: { customRender: 'action' },
            fixed: 'right',
          }, //自定义操作列
        }),
      };
    },
    /**
     * @description: 自定义初始化方法
     * @param {Ref} data
     * @param {Ref} keyFieldValues
     * @param {string} type
     * @param {any} useTables
     * @return {*}
     */
    CustInitData: (data: Ref<any[]>, keyFieldValues: Ref<{}>, type: string, useTables: any) => {
      if (type == 'BAS_LABEL_VAR_WO') {
        if (data.value['BAS_LABEL_VAR_WO'].length > 0) {
          /* 初始化数据，行转列 */
          let varwos: any[] = [];
          const map = new Map<string, any>();
          data.value['BAS_LABEL_VAR_WO'].map((curr) => {
            if (!map.has(curr.WORK_ORDER)) {
              const newObj = {};
              newObj['WORK_ORDER'] = curr.WORK_ORDER;
              map.set(curr.WORK_ORDER, newObj);
            }
            const acc = map.get(curr.WORK_ORDER);
            Object.keys(curr).forEach((key) => {
              if (key != 'VAR_NAME' && key != 'VAR_VALUE') {
                acc[key] = curr[key];
              } else if (key == 'VAR_NAME') {
                acc[`DEFAULT_VALUE_${curr.VAR_NAME}`] = curr.DEFAULT_VALUE;
                acc[`VAR_N_${curr.VAR_NAME}`] = curr.VAR_VALUE;
              }
            });
            // varwos.push(acc);
          });
          map.forEach((x) => {
            varwos.push(x);
          });
          data.value['BAS_LABEL_VAR_WO'] = varwos;
        }
        useTables[type][1].setProps({
          dataSource: data.value['BAS_LABEL_VAR_WO'],
          columns: GetBaseColumns('BAS_LABEL_VAR_WO', null, data),
          scroll: { y: 500 },
          useSearchForm: false,
          showTableSetting: false,
          bordered: true,
          canResize: true,
          showIndexColumn: false,
          actionColumn: {
            width: 130,
            title: '操作',
            dataIndex: 'action',
            slots: { customRender: 'action' },
            fixed: 'right',
          },
        });
        useTables[type][1].reload();
      }
    },
    /**
     * @description: 提交所有
     * @return {*}
     */
    SubmitAll: (data: Ref<any[]>, keyFieldValues: Ref<{}>, ...args) => {
      const cancel = args[0];
      const drawers = args[1];
      const label = args[2]['BaseForm'];
      // const input: BasLabelTempInput ={
      //   Label: undefined,
      //   LabelVar: undefined,
      //   LabelVarWo: undefined
      // };
      const input: BasLabelTempInput = {
        Label: {
          ID: buildUUID(),
          CREATE_USER: useUserStore().getUserInfo.userId as string,
          UPDATE_USER: useUserStore().getUserInfo.userId as string,
          GHOST_ROW: false,
          AUTH_ORG: useUserStore().getUserInfo.orgCode,
          AUTH_PROD: useUserStore().getUserInfo.prodCode,
          AUTH_WH: '',
          LABEL_CODE: label.LABEL_CODE,
          LABEL_NAME: label.LABEL_NAME,
          TEMP_TYPE: label.TEMP_TYPE,
          TEMP_PATH: label.TEMP_PATH,
          CUST_CODE: label.CUST_CODE,
          PROD_CODE: label.PROD_CODE,
          REMARK: '',
        } as unknown as BAS_LABEL_TEMP,
        LabelVars: [] as unknown as BAS_LABEL_VAR[],
        LabelVarWos: [] as unknown as BAS_LABEL_VAR_WO[],
      };
      drawers.forEach((d) => {
        let where = `${d['code']} = '${keyFieldValues.value[d['code']]}'`;
        /* type: all-表示需要code的所有的值 */
        if (d['type'] == 'all' && data.value[d['keyName']].length > 0) {
          where = `${d['code']} in (${data.value[d['keyName']].map((value) => `'${value[d['code']]}'`).join(',')})`;
        }
        data.value[d['name']].map((item) => {
          item.ID = buildUUID();
        });
        if (d.name == 'BAS_LABEL_VAR') {
          input.LabelVars = data.value[d['name']];
        }
        if (d.name == 'BAS_LABEL_VAR_WO') {
          let varwos: any[] = [];
          data.value[d['name']].map((curr) => {
            const vKeys: any[] = [];
            Object.keys(curr).forEach((key) => {
              if (key.startsWith('VAR_N_')) {
                vKeys.push(key);
              }
              // if (key.startsWith('VAR_N_')) {
              //   acc['VAR_NAME'] = key.replace('VAR_N_', '');
              //   acc['VAR_VALUE'] = curr[key];
              // } else if (key.startsWith('DEFAULT_VALUE_')) {
              //   acc['DEFAULT_VALUE'] = curr[key]; acc[key] = curr[key];
              // }
            });
            vKeys.forEach((k) => {
              let acc = {};
              Object.keys(curr).forEach((key) => {
                if (key == k) {
                  acc['VAR_NAME'] = key.replace('VAR_N_', '');
                  acc['VAR_VALUE'] = curr[key];
                } else if (key == `DEFAULT_VALUE_${k.replace('VAR_N_', '')}`) {
                  acc['DEFAULT_VALUE'] = curr[key];
                } else if (
                  !key.startsWith('VAR_N_') &&
                  !key.startsWith('DEFAULT_VALUE_') &&
                  key != 'DEFAULT_VALUE'
                ) {
                  acc[key] = curr[key];
                }
              });
              acc['ID'] = buildUUID();
              varwos.push(acc);
            });
          });
          input.LabelVarWos = varwos;
        }
      });
      SaveLabelTemplate(input).then((action) => {
        if (action.IsSuccessed) {
          cancel();
        }
      });
    },
    /**
     * @description: 自定义方法
     * @param {string} type
     * @param {array} args
     * @return {*}
     */
    CustFunc: (param: CustModalParams) => {
      switch (param.cType) {
        case 'BAS_LABEL_VAR':
        case 'BAS_LABEL_VAR_WO':
          return getFns[param.FnName](param) as Promise<any>;
        // break;
        default:
          return new Promise((resolve, reject) => {
            try {
              (e) => {};
              resolve(true);
            } catch {
              reject(false);
            } finally {
              // args[0][0]({ confirmLoading: false });
            }
          });
        // break;
      }
    },
    /**
     * @description: 编辑单元格完成后自定义方法
     * @param {Recordable} param1
     * @param {*} type
     * @param {any} useTables
     * @return {*}
     */
    CustEditEnd: ({ record, index, key, value }: Recordable, type, ...args) => {
      console.log(key, value);
      const useTables = args[0];
      const data = args[1];
      let varWodata: any[] = [];
      if (
        (record['VAR_TYPE'] == 1 && record['VAR_VALUE'] != 'PV-WorkOrder-Plan') ||
        record['VAR_TYPE'] != 1
      ) {
        data.value['BAS_LABEL_VAR_WO'].forEach((x) => {
          let acc: any = {};
          Object.keys(x).map((key) => {
            if (key != `VAR_N_${record['VAR_NAME']}`) {
              acc[key] = x[key];
            }
          });
          varWodata.push(acc);
        });
        data.value['BAS_LABEL_VAR_WO'] = varWodata;
      } else {
        varWodata = data.value['BAS_LABEL_VAR_WO'];
      }
      switch (type) {
        case 'BAS_LABEL_VAR':
          useTables['BAS_LABEL_VAR_WO'][1].setProps({
            dataSource: varWodata,
            columns: GetBaseColumns('BAS_LABEL_VAR_WO', null, data),
            scroll: { y: 500 },
            useSearchForm: false,
            showTableSetting: false,
            bordered: true,
            canResize: true,
            showIndexColumn: false,
            actionColumn: {
              width: 130,
              title: '操作',
              dataIndex: 'action',
              slots: { customRender: 'action' },
              fixed: 'right',
            },
          });
          useTables['BAS_LABEL_VAR_WO'][1].reload();
          break;
        default:
          break;
      }
    },
  };

  /* 以下是内部方法，不export */

  /**
   * @description: 自定义方法
   * @return {*}
   */
  const getFns: Record<string, FunctionType> = {
    /**
     * @description: 新增行方法
     * @param {*} e
     * @param {array} args
     * @return {*}
     */
    AddRow: (param: CustModalParams) => {
      return new Promise((resolve, reject) => {
        try {
          console.log('AddRow');
          EditOperation(
            param.data,
            { ...param.values, ...param.others },
            { isUpdate: false },
            param.cType,
            {},
          );
        } catch {
          reject(false);
        }
      });
    },
    /**
     * @desc 保存方法
     */
    SaveRow: (param: CustModalParams) => {
      return new Promise((resolve, reject) => {
        try {
          param.data.value[param.cType] = param.data.value[param.cType].map((d) => {
            if (d.ID == param.values['ID']) {
              d.VAR_NAME = param.values['VAR_NAME'];
              d.VAR_TYPE = param.values['VAR_TYPE'];
              d.VAR_VALUE = param.values['VAR_VALUE'];
              d.BARCODE_RULE = param.values['BARCODE_RULE'];
              d.REMARK = param.values['REMARK'];
            }
            return d;
          });
        } catch {
          reject(false);
        }
      });
    },
  };

  let columns: BasicColumn[] = [];
  /**
   * @description: 获取表格字段Json
   * @param {string} type
   * @return {*}
   */
  function GetBaseColumns(type: string, emit, data: Ref<{}>) {
    columns = [
      {
        dataIndex: 'LABEL_ID',
        title: '标签模板ID',
        ifShow: false,
        sorter: true,
        resizable: true,
      },
      {
        dataIndex: 'VAR_NAME',
        title: '变量名称',
        ifShow: true,
        sorter: true,
        editRow: true,
        resizable: true,
        customRender: () => {},
      },
      {
        dataIndex: 'VAR_TYPE',
        title: '变量类型',
        editRow: true,
        editRule: true,
        ifShow: true,
        sorter: true,
        resizable: true,
        editComponent: 'ApiSelect',
        editComponentProps: (column) => {
          return {
            api: GetEnum,
            params: { name: 'BAS_LABEL_VAR+VAR_TYPEs' },
            resultField: 'Data',
            labelField: unref(getLocale) == 'zh_CN' ? 'Desc' : 'Name',
            valueField: 'Value',
            onChange: (e, v) => {
              if (e == 1 || e == 4) {
                const where =
                  e == 1
                    ? { TABLE_NAME: 'BAS_LABEL_PV', VAR_TYPE: 0 }
                    : { TABLE_NAME: 'BAS_LABEL_PV', VAR_TYPE: 1 };
                emit('opencust', {
                  data: column.record,
                  name: 'BAS_LABEL_VAR',
                  modalSchema: {
                    title: '过程变量列表',
                    schemas: [
                      {
                        field: 'VAR_CODE',
                        component: 'Input',
                        label: '过程变量编码',
                        colProps: {
                          span: 12,
                        },
                      },
                    ],
                    ItemColumns: [
                      {
                        title: t('过程变量编码'),
                        dataIndex: 'VAR_CODE',
                        resizable: true,
                        sorter: true,
                        width: 200,
                      },
                      {
                        title: t('过程变量名称'),
                        dataIndex: 'VAR_NAME',
                        resizable: true,
                        sorter: true,
                        width: 180,
                      },
                    ],
                    tableName: 'BAS_LABEL_PV',
                    rowKey: 'VAR_CODE',
                    searchInfo: where,
                  },
                });
              }
            },
          };
        },
        editRender: ({ record }) => {
          let color = '';
          let text = '';
          switch (record.VAR_TYPE) {
            case 0:
              text = '常量';
              color = 'green';
              break;
            case 1:
              text = '过程变量';
              color = 'orange';
              break;
            case 2:
              text = '日期变量';
              color = '#4f68b0';
              break;
            case 3:
              text = '自定义变量';
              color = '#bfbfbf';
              break;
            case 4:
              text = '条码生成';
              color = '#b442df';
              break;
          }
          return h(Tooltip, { title: text }, () => h(Tag, { color: color }, () => text));
        },
      },
    ];
    switch (type) {
      case 'BAS_LABEL_VAR':
        columns = [
          ...columns,
          ...[
            {
              dataIndex: 'VAR_VALUE',
              title: '变量值',
              editRow: true,
              // editable: true,
              editRule: true,
              ifShow: (column) => true,
              sorter: true,
              resizable: true,
            },
            {
              dataIndex: 'BARCODE_RULE',
              title: '条码生成规则',
              ifShow: true,
              editRow: true,
              editRule: true,
              sorter: true,
              resizable: true,
              editComponent: 'ApiSelect',
              editComponentProps: (column) => {
                return {
                  api: getEntity,
                  params: { entityName: 'BAS_CODE_RULE', sqlcmd: ' 1=1 ' },
                  resultField: 'Data.Items',
                  labelField: 'RULE_NAME',
                  valueField: 'RULE_CODE',
                };
              },
            },
            {
              dataIndex: 'REMARK',
              title: '备注',
              ifShow: true,
              editRow: true,
              sorter: true,
              resizable: true,
            },
          ],
        ] as BasicColumn[];
        break;
      case 'BAS_LABEL_VAR_WO':
        const _columns = [
          {
            dataIndex: 'LABEL_ID',
            title: '标签模板ID',
            ifShow: false,
            sorter: true,
            resizable: true,
          },
          {
            title: '工单号',
            dataIndex: 'WORK_ORDER',
            width: 280,
            edit: true,
            editRule: true,
            // editable: true,
            ifShow: true,
          },
        ] as BasicColumn[];
        newRow = {
          ID: buildUUID(),
          LABEL_ID:
            data.value['BAS_LABEL_VAR'].length > 0 ? data.value['BAS_LABEL_VAR'][0].LABEL_ID : '',
          WORK_ORDER: '',
        };
        data.value['BAS_LABEL_VAR'].map((x) => {
          if (x.VAR_TYPE == 1 && x.VAR_VALUE == 'PV-WorkOrder-Plan') {
            newRow[`${x.VAR_NAME}_DEFAULT_VALUE`] = '';
            newRow[x.VAR_NAME] = '';
            _columns.push(
              {
                title: `（变量）${x.VAR_NAME}默认值`,
                dataIndex: `DEFAULT_VALUE_${x.VAR_NAME}`,
                width: 280,
                // edit: true,
                // editRule: true,
                resizable: true,
                ifShow: true,
              },
              {
                title: `（变量）${x.VAR_NAME}`,
                dataIndex: `VAR_N_${x.VAR_NAME}`,
                width: 280,
                edit: true,
                editRule: true,
                resizable: true,
                ifShow: true,
              },
            );
          }
        });
        _columns.push({
          title: `备注`,
          dataIndex: 'REMARK',
          width: 280,
          edit: true,
          editRule: true,
          resizable: true,
          ifShow: true,
        });
        columns = _columns;
        break;
    }
    return columns;
  }

  /**
   * @description: 表格基本字段
   * @return {*}
   */
  const baseColumns = {
    BAS_LABEL_VAR: [],
    BAS_LABEL_VAR_WO: [
      {
        dataIndex: 'LABEL_ID',
        title: '标签模板ID',
        ifShow: false,
        sorter: true,
        resizable: true,
      },
      {
        title: '工单号',
        dataIndex: 'WORK_ORDER',
        edit: true,
        editRule: true,
        // editable: true,
        ifShow: true,
      },
      {
        dataIndex: 'VAR_NAME',
        title: '变量名称',
        edit: true,
        editRule: true,
        // editable: true,
        ifShow: true,
        sorter: true,
        resizable: true,
        customRender: () => {},
      },
      {
        dataIndex: 'VAR_VALUE',
        title: '变量值',
        edit: true,
        editRule: true,
        // editable: true,
        ifShow: true,
        sorter: true,
        resizable: true,
      },
      {
        title: '标签模板预览地址',
        dataIndex: 'LABEL_VIEW_PATH',
        ifShow: false,
      },
      {
        title: '备注',
        dataIndex: 'REMARK',
      },
      // {
      //   title: '更新时间',
      //   dataIndex: 'UPDATE_TIME',
      // },
      // {
      //   title: '更新人',
      //   dataIndex: 'UPDATE_USER',
      // },
    ] as BasicColumn[],
  };

  /**
   * @description: 查询字段
   * @return {*}
   */
  const searchForms = {
    MES_SHIFT: [
      {
        field: 'SFT_CODE',
        label: '班次编码',
        component: 'Input',
        colProps: {
          span: 8,
        },
      },
      {
        label: '班次名称',
        field: 'SFT_NAME',
        component: 'Input',
        colProps: {
          span: 8,
        },
      },
    ] as FormSchema[],
    MES_SHIFT_PRD: [
      {
        field: 'PRD_CODE',
        label: '时段编码',
        component: 'Input',
        colProps: {
          span: 8,
        },
      },
      {
        label: '时段名称',
        field: 'PRD_NAME',
        component: 'Input',
        colProps: {
          span: 8,
        },
      },
    ] as FormSchema[],
  };

  const crudForms = {
    MES_SHIFT: [
      {
        field: 'SFT_CODE',
        label: '班次编码',
        component: 'Input',
        required: true,
        colProps: {
          span: 24,
        },
      },
      {
        label: '班次名称',
        field: 'SFT_NAME',
        component: 'Input',
        required: true,
        colProps: {
          span: 24,
        },
      },
      {
        label: '班制编码',
        field: 'SFTS_CODE',
        component: 'ApiSelect',
        required: true,
        colProps: {
          span: 24,
        },
        componentProps: {
          api: getEntity,
          params: { entityName: 'MES_SHIFT_SYS', sqlcmd: ' 1=1 ' },
          resultField: 'Data.Items',
          labelField: 'SFTS_NAME',
          valueField: 'SFTS_CODE',
        },
        dynamicDisabled: ({ values }) => {
          return true;
        },
      },
      // {
      //   label: '班次时间范围',
      //   field: '[SFT_BEGIN, SFT_END]',
      //   component: 'TimeRangePicker',
      //   colProps: {
      //     span: 24,
      //   },
      //   componentProps: ({ formModel }) => {
      //     return {
      //       format: 'HH:mm',
      //       placeholder: ['开始时间', '结束时间'],
      //       onChange: (e) => {
      //         const timeRange: any = e;
      //         console.log(e);
      //         // if (timeRange) {
      //         //   formModel.SFT_BEGIN = Number(`${tsToHHmm(timeRange[0].$d)}`);
      //         //   formModel.SFT_END = Number(`${tsToHHmm(timeRange[1].$d)}`);
      //         // }
      //       },
      //     };
      //   },
      // },
      {
        label: '班次开始时间',
        field: 'SFT_BEGIN',
        component: 'TimePicker',
        colProps: {
          span: 12,
        },
        componentProps: ({ formModel }) => {
          return {
            format: 'HH:mm',
          };
        },
        // show: false,
      },
      {
        label: '结束时间',
        field: 'SFT_END',
        component: 'TimePicker',
        colProps: {
          span: 12,
        },
        componentProps: ({ formModel }) => {
          return {
            format: 'HH:mm',
          };
        },
        // show: false,
      },
      {
        label: '是否跨天',
        field: 'IS_ACROSS_DAY',
        component: 'Select',
        required: true,
        colProps: {
          span: 24,
        },
        componentProps: {
          options: [
            {
              label: '是',
              value: 'Y',
              key: 'Y',
            },
            {
              label: '否',
              value: 'N',
              key: 'N',
            },
          ],
        },
      },
      // {
      //   field: 'LOGIN_TIME',
      //   label: '登录时间',
      //   defaultValue: '',
      //   component: 'RangePicker',
      //   ifShow: true,
      //   colProps: { span: 8 },
      // },
      {
        label: '备注',
        field: 'REMARK',
        component: 'Input',
        colProps: {
          span: 24,
        },
      },
      {
        label: 'ID',
        field: 'ID',
        component: 'Input',
        colProps: {
          span: 24,
        },
        show: false,
      },
    ] as FormSchema[],
    MES_SHIFT_PRD: [
      {
        field: 'PRD_CODE',
        label: '时段编码',
        component: 'Input',
        required: true,
        colProps: {
          span: 24,
        },
      },
      {
        label: '时段名称',
        field: 'PRD_NAME',
        component: 'Input',
        required: true,
        colProps: {
          span: 24,
        },
      },
      {
        label: '班次编码',
        field: 'SFT_CODE',
        component: 'Select',
        required: true,
        colProps: {
          span: 24,
        },
        componentProps: () => {
          const options = _data['MES_SHIFT'].map((entity) => ({
            value: entity.SFT_CODE,
            label: entity.SFT_NAME,
          }));
          return {
            options: options,
          };
        },
        // dynamicDisabled: ({ values }) => {
        //   return true;
        // },
      },
      {
        label: '时段开始时间',
        field: 'PRD_BEGIN',
        component: 'TimePicker',
        colProps: {
          span: 12,
        },
        componentProps: ({ formModel }) => {
          return {
            format: 'HH:mm',
          };
        },
      },
      {
        label: '结束时间',
        field: 'PRD_END',
        component: 'TimePicker',
        colProps: {
          span: 12,
        },
        componentProps: ({ formModel }) => {
          return {
            format: 'HH:mm',
          };
        },
      },
      {
        label: '时段排序',
        field: 'SEQ',
        component: 'InputNumber',
        colProps: {
          span: 24,
        },
      },
      {
        label: '是否跨天',
        field: 'IS_ACROSS',
        component: 'Select',
        required: true,
        colProps: {
          span: 24,
        },
        componentProps: {
          options: [
            {
              label: '是',
              value: 'Y',
              key: 'Y',
            },
            {
              label: '否',
              value: 'N',
              key: 'N',
            },
          ],
        },
      },
      {
        label: '是否休息时段',
        field: 'IS_REST',
        component: 'Select',
        required: true,
        colProps: {
          span: 24,
        },
        componentProps: {
          options: [
            {
              label: '是',
              value: 'Y',
              key: 'Y',
            },
            {
              label: '否',
              value: 'N',
              key: 'N',
            },
          ],
        },
      },
      {
        label: '备注',
        field: 'REMARK',
        component: 'Input',
        colProps: {
          span: 24,
        },
      },
      {
        label: 'ID',
        field: 'ID',
        component: 'Input',
        colProps: {
          span: 24,
        },
        show: false,
      },
    ] as FormSchema[],
  };

  return [methods, ActionColumn];