一些更新

Ben Lin

2025-03-08 21a4e09672b1177d40c2bb5b937a8780c5eaa7fb

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

@@ -4,310 +4,168 @@
 * @version:
 * @Date: 2024-06-19 20:34:27
 * @LastEditors: Ben Lin
 * @LastEditTime: 2024-07-16 16:38:43
 * @LastEditTime: 2024-10-23 20:48:14
 */

import { Ref, h, ref, render, unref } from 'vue';
import { GetRoutePTree, RouteToCust, RouteToProd } from '/@/api/tigerapi/mes/router';
import { GetEnum, SaveEntity, convertToTree, getEntity } from '/@/api/tigerapi/system';
import { useLocale } from '/@/locales/useLocale';
import { isNullOrEmpty, isNullOrUnDef } from '/@/utils/is';
import { useI18n } from '/@/hooks/web/useI18n';
import { NavItem } from '/@/api/tigerapi/model/basModel';
import { useMessage } from '/@/hooks/web/useMessage';
import { useModal } from '/@/components/Modal';
import { FormSchema } from '/@/components/Table';
import { ActionItem, BasicColumn, FormSchema } from '/@/components/Table';
import { useUserStore } from '/@/store/modules/user';
import { buildUUID } from '/@/utils/uuid';
import { SaveWoBatchInput } from '/@/api/tigerapi/model/mesModel';
import { CustModalParams, FunctionType } from '/@/api/tigerapi/model/systemModel';
import { SaveMesBatchWo } from '/@/api/tigerapi/mes/wo';
import { useForm } from '/@/components/Form/index';
import { uploadApi } from '/@/api/sys/upload';
import { cloneDeep } from 'lodash-es';
import { useProdRouteStore } from '/@/store/modules/prodRoute';
import { Tag, Tooltip } from 'ant-design-vue';

const { t } = useI18n();
const { createErrorModal } = useMessage();
const { getLocale } = useLocale();
function _default() {
  /* 定义变量 */
  const isNormal = (type: number) => type === 0;
  const isScan = (type: number) => type === 1;
  const isAssy = (type: number) => type === 2;
  const isTest = (type: number) => type === 3;
  const isAudit = (type: number) => type === 4;
  const isPrint = (type: number) => type === 5;
  const isPackage = (type: number) => type === 6;
  const ActionColumn: BasicColumn = {
    width: 180,
    title: '操作',
    dataIndex: 'action',
    slots: { customRender: 'action' },
    fixed: 'right',
  };
  /**
   * @description: 工单管理的一些自定义方法
   * @return {*}
   */
  const methods = {
    /**
     * @description: 获取树形图标
     * @param {Recordable} params
     * @description: 获取新增按钮的行为
     * @return {*}
     */
    CreateIcon: (params: Recordable<any>) => {
      let icon = '';
      switch (params['type']) {
        case 'Product':
          icon = 'similar-product|svg';
    CreateAction: (type: string, fnName: string) => {
      let action = {} as any;
      switch (fnName) {
        case 'ImportExcel':
          action = {
            action: 'importModal', //drawer(打开左侧抽屉框) | go(跳转到新的页面) | modal(打开模态窗口) | importModal(打开导入模态窗口) | ToPrint(打印功能)
            params: {
              tmpHeader: ['工单号', '计划日期', '计划数量'] /* 下载模板的标题字段 */,
              filename: '工单计划模板.xlsx' /* 下载模板的文件名 */,
              entityName: 'BIZ_MES_WO_BATCH' /* 导入表的表名 */,
              checkJson: ['ORDER_NO', 'PLAN_DATE', 'PLAN_QTY'] /* 导入表需要检查的字段列表 */,
              where: ['ORDER_NO'] /* 导入表需要查询的字段列表 */,
              typeFullName:
                'Tiger.IBusiness.MES.IImportWoPlan,Tiger.IBusiness.MES' /* 导入的方法全名，通用导入用这个：Tiger.IBusiness.ICommonImportExcel,Tiger.IBusiness */,
              baseColumns: [
                /* 导入时界面显示数据的字段 */
                {
                  title: '工单号',
                  dataIndex: 'ORDER_NO',
                  ifShow: true,
                  width: 180,
                },
                // {
                //   title: '工单批次号',
                //   dataIndex: 'BATCH_NO',
                //   ifShow: true,
                //   width: 180,
                //   // customRender: ({ record }) => {
                //   //   record.BATCH_NO = record.ORDER_NO+'-01'
                //   //   return record.BATCH_NO
                //   // },
                // },
                {
                  title: '计划日期',
                  dataIndex: 'PLAN_DATE',
                  ifShow: true,
                  width: 180,
                },
                {
                  title: '计划数量',
                  dataIndex: 'PLAN_QTY',
                  ifShow: true,
                  width: 100,
                },
                {
                  title: '处理方式',
                  dataIndex: 'VALIDATION_TYPE',
                  ifShow: true,
                  width: 100,
                  customRender: ({ record }) => {
                    const status = record.VALIDATION_TYPE;
                    var text = '';
                    var color = 'green';
                    if (status == '异常') {
                      color = 'red';
                      text = status;
                    } else if (status == '更新') {
                      color = 'orange';
                      text = status;
                    } else {
                      text = status;
                    }
                    return h(Tooltip, { title: text }, () => h(Tag, { color: color }, () => text));
                  },
                },
                {
                  title: '处理提示',
                  dataIndex: 'VALIDATION_RESULT',
                  ifShow: true,
                  width: 280,
                  customRender: ({ record }) => {
                    const status = record.VALIDATION_TYPE;
                    var text = record.VALIDATION_RESULT;
                    var color = 'green';
                    if (status == '异常') {
                      color = 'red';
                    } else if (status == '更新') {
                      color = 'orange';
                    }
                    return h(Tooltip, { title: text }, () => h(Tag, { color: color }, () => text));
                  },
                },
              ],
            },
          };
          break;
        case 'Route':
          icon = 'route|svg';
          break;
        case 'Node':
          icon = 'node|svg';
          break;
        case 'Action':
          icon = 'rot_action|svg';
          break;
        case 'Customer':
          icon = 'customer|svg';
        case 'ToPrint':
          action = {
            action: 'ToPrint', //drawer(打开左侧抽屉框) | go(跳转到新的页面) | modal(打开模态窗口) | importModal(打开导入模态窗口) | ToPrint(打印功能)
          };
        break;
        default:
          action = {
            action: 'drawer', //drawer(打开左侧抽屉框) | go(跳转到新的页面) | modal(打开模态窗口) | importModal(打开导入模态窗口) | ToPrint(打印功能)
          };
          break;
      }
      return icon;
      return action;
    },
    /**
     * @description: 高级表单和详情页面返回主页面的url
     * @description: 操作字段自定义按钮
     * @return {*}
     */
    GetHomeUrl: () => {
      return `/V_BAS_PROD/LC/${encodeURI(JSON.stringify({ ID: 'V_BAS_PROD', colSlots: [], crudColSlots: [] }))}`;
    },
    /**
     * @description: 获取树形数据
     * @param {string} type
     * @return {*}
     */
    fetchTreeData: async (type: string, itemCode: string) => {
      let data = { title: '', treeData: [] as any[], fieldNames: {} };
      let prodTreeData = await GetRoutePTree(itemCode);
      // let uniqueArr = prodTreeData.reduce((acc, current) => {
      //   if (!acc.some((x) => x.pid == current.pid && x.id == current.id && x.seq == current.seq && x.type == current.type)) {
      //     acc.push(current);
      //   }
      //   return acc;
      // }, [] as V_MES_ROUTE_PTREE[]);
      data.treeData = convertToTree(prodTreeData, 'pid', 'tid', 'root');
      data.title = '工艺路线';
      data.fieldNames = { key: 'tid', title: 'name' };
    ActionItem: (params: Recordable<any>, data, ...args): ActionItem[] => {
      data.map((x) => {
        if (x.name == 'goDetail') {
          x.onClick = goDetail.bind(null, args[5], params);
          x.tooltip = '工单批次';
        }
        if (x.name == 'handleConfig') {
          x.onClick = handleConfig.bind(null, args, params);
          x.tooltip = '配置工艺';
        }
        if (x.name == 'handleRelease') {
          x.onClick = handleRelease.bind(null, args, params);
          x.tooltip = '下发';
        }
        if (x.name == 'ToPrint') {
          x.tooltip = '打印流程卡';
        }
      });
      return data;
    },
    /**
     * @description: 获取配置项表单字段，根据树形节点type不同而不同
     * @param {string} type
     * @return {*}
     */
    GetCrudForm: (type: string) => {
      let form: FormSchema[] = [];
      switch (type) {
        case 'Action':
          form = actionFormShema;
          break;
        case 'Node':
          form = nodeFormShema;
          break;
      }
      return form;
    },
    /**
     * @description: 获取表单中的字段插槽列表
     * @return {*}
     */
    GetCrudColSlots: () => {
      return ['scanadd', 'assyadd', 'testadd', 'auditadd', 'printadd', 'pkgadd'];
    },
    /**
     * @description: 切换节点时事件方法
     * @return {*}
     */
    nodeChange: (params: {
      resetFields: any;
      setFieldsValue: any;
      objParams: Ref<any>;
      selectedNodes: Ref<any[]>;
    }) => {
      let sqlcmd = ' 1=1 ';
      if (!isNullOrEmpty(params['objParams'].value['CODE'])) {
        sqlcmd += `And PROD_CODE = '${params['objParams'].value['CODE']}'`;
      }
      if (!isNullOrEmpty(params['selectedNodes'].value[0].cust)) {
        sqlcmd += `And CUST_CODE = '${params['selectedNodes'].value[0].cust}'`;
      }
      if (!isNullOrEmpty(params['selectedNodes'].value[0].id)) {
        sqlcmd +=
          params['selectedNodes'].value[0].type == 'Action'
            ? `And ACT_ID = '${params['selectedNodes'].value[0].id}'`
            : `And NODE_ID = '${params['selectedNodes'].value[0].id}'`;
      }
      getEntity({
        sqlcmd: sqlcmd,
        entityName:
          params['selectedNodes'].value[0].type == 'Action' ? 'MES_PROD_ACTION' : 'MES_PROD_OPER',
        order: '',
      }).then((res) => {
        params['resetFields']();
        if (params['selectedNodes'].value[0].type == 'Action') {
          params['setFieldsValue']({
            ID: res.Data.Items[0].ID,
            ACT_ID: res.Data.Items[0].ACT_ID,
            ROT_ID: res.Data.Items[0].ROT_ID,
            NODE_ID: res.Data.Items[0].NODE_ID,
            IS_ACTIVE: res.Data.Items[0].IS_ACTIVE,
            ITEM_CODE: res.Data.Items[0].ITEM_CODE,
            RULE_CODE: res.Data.Items[0].RULE_CODE,
            TEST_CODE: res.Data.Items[0].TEST_CODE,
            SAPL_CODE: res.Data.Items[0].SAPL_CODE,
            LABEL_CODE: res.Data.Items[0].LABEL_CODE,
            PKG_CODE: res.Data.Items[0].PKG_CODE,
            ACT_CODE: res.Data.Items[0].ACT_CODE,
            REMARK: res.Data.Items[0].REMARK,
            PROD_CODE: params['objParams'].value['CODE'],
            ACT_TYPE: res.Data.Items[0].ACT_TYPE,
            CUST_CODE: params['selectedNodes'].value[0].cust,
          });
        }
        if (params['selectedNodes'].value[0].type == 'Node') {
          params['setFieldsValue']({
            ID: res.Data.Items[0].ID,
            OPER_CODE: res.Data.Items[0].OPER_CODE,
            ROT_ID: res.Data.Items[0].ROT_ID,
            NODE_ID: res.Data.Items[0].NODE_ID,
            NODE_NAME: res.Data.Items[0].NODE_NAME,
            IS_ACTIVE: res.Data.Items[0].IS_ACTIVE,
            IS_CALC_FPY: res.Data.Items[0].IS_CALC_FPY,
            CAN_SKIP: res.Data.Items[0].CAN_SKIP,
            IS_INPUT: res.Data.Items[0].IS_INPUT,
            IS_OUTPUT: res.Data.Items[0].IS_OUTPUT,
            REMARK: res.Data.Items[0].REMARK,
            PROD_CODE: params['objParams'].value['CODE'],
            CUST_CODE: params['selectedNodes'].value[0].cust,
          });
        }
      });
    },
    /**
     * @description: 自定义提交方法
     * @return {*}
     */
    SubmitFunc: (values: Recordable<any>, type: string, emit) => {
      let entityName = '';
      switch (type) {
        case 'Action':
          entityName = 'MES_PROD_ACTION';
          break;
        case 'Node':
          entityName = 'MES_PROD_OPER';
          break;
      }
      SaveEntity(values, true, entityName).then((action) => {
        if (action.IsSuccessed) {
          emit('success');
        }
      });
    },
    /**
     * @description: 弹出选择框打开方法
     * @param {Fn} openItemModal
     * @return {*}
     */
    OpenSelectItem: (openItemModal: Fn, ...args) => {
      let config = {};
      switch (args[0]) {
        case 'scanadd':
          config = ruleModalCfg;
          break;
        case 'assyadd':
          config = itemCodeModalCfg;
          break;
        case 'testadd':
          config = itemCodeModalCfg;
          break;
        case 'printadd':
          config = printModalCfg;
          break;
        case 'pkgadd':
          config = pkgModalCfg;
          break;
      }
      openItemModal(true, config);
    },
    /**
     * @description: 弹出选择框选择成功返回
     * @param {*} d
     * @param {*} u
     * @return {*}
     */
    GetSelectSuccess: (d, u, ...args) => {
      let value = {};
      switch (args[0]) {
        case 'scanadd':
          value = {
            RULE_CODE: d.values['val'],
          };
          break;
        case 'assyadd':
          value = {
            ITEM_CODE: d.values['val'],
          };
          break;
        case 'printadd':
          value = {
            LABEL_CODE: d.values['val'],
          };
          break;
        case 'pkgadd':
          value = {
            pkgRULE_CODE: d.values['val'],
          };
        case 'addRoute':
          if (isNullOrEmpty(args[1]['CODE'])) {
            createErrorModal({
              title: t('sys.api.errorTip'),
              content: '产品为空，不能添加工艺路线，请点击左侧选择产品',
            });
            return;
          }
          let codes = d.values.id.split(',');
          var i;
          for (i = 0; i < codes.length; i++) {
            if (d.which == 'addRoute') {
              RouteToProd({ rotId: codes[i], prodCode: args[1]['CODE'] });
            }
          }

          args[2]();
          break;
        case 'addCustomer':
          if (isNullOrEmpty(args[1]['CODE'])) {
            createErrorModal({
              title: t('sys.api.errorTip'),
              content: '产品为空，不能添加工艺路线，请点击左侧选择产品',
            });
            return;
          }
          let rotIds = d.ROT_ID.split(',');
          var i;
          for (i = 0; i < rotIds.length; i++) {
            RouteToCust({ rotId: rotIds[i], prodCode: args[1]['CODE'], custCode: d.CUST_CODE });
          }

          args[2]();
          break;
      }
      return value;
    },
    /**
     * @description: 获取模态框应用列表
     * @return {*}
     */
    GetUseModals: () => {
      return {
        addRoute: useModal(),
        addCustomer: useModal(),
        editRoute: useModal(),
      };
    },
    GetUseForm: () => {
      return {
@@ -335,95 +193,129 @@
          },
          showActionButtonGroup: false,
        }),
        tmpinfo: useForm({
          labelWidth: 120,
          schemas: prodCfgformSchema,
          actionColOptions: {
            span: 24,
          },
          showActionButtonGroup: false,
        }),
      };
    },
    /**
     * @description: 获取标题信息
     * @description: 自定义方法
     * @param {string} type
     * @param {array} args
     * @return {*}
     */
    GetTitle: (type: string) => {
      return {
        configTitle: type == 'Action' ? '行为配置' : '工序配置',
        navTitle: type == 'Product' ? '添加工艺路线' : '工艺路线维护',
      };
    CustFunc: (param: CustModalParams) => {
      switch (param.cType) {
        case 'BIZ_MES_WO':
        case 'BIZ_MES_WO_Config':
          return getWoFns[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 {Ref} selectedNodes
     * @description: 获取多表单插槽列表
     * @return {*}
     */
    SelectNode: (selectedNodes: Ref<any[]>) => {
      let result = {
        showConfig: false,
        showNav: false,
        type: selectedNodes.value[0].type,
        nodes: selectedNodes.value,
      };
      if (isNullOrUnDef(selectedNodes)) {
        return result;
      }
      if (selectedNodes.value[0].type == 'Product' || selectedNodes.value[0].type == 'Route') {
        result.showNav = true;
        result.showConfig = false;
      }
      if (selectedNodes.value[0].type == 'Action' || selectedNodes.value[0].type == 'Node') {
        result.showNav = false;
        result.showConfig = true;
    GetDtlSlots: (type: string) => {
      let result = [] as any[];
      switch (type) {
        case 'BIZ_MES_WO_Config':
          result = [
            { name: 'woinfo', slots: [], preIcons: {}, title: '工单信息' },
            {
              name: 'prodinfo',
              slots: ['addRot', 'setRot'],
              preIcons: { addRot: 'search|svg', setRot: 'config|svg' },
              title: '产品信息',
            },
            { name: 'rotinfo', slots: ['add'], preIcons: { add: 'search|svg' }, title: '工艺信息' },
          ];
          break;
        case 'BIZ_MES_WO':
          result = [
            {
              name: 'forminfo',
              slots: ['add', 'set'],
              preIcons: { add: 'search|svg', set: 'config|svg' }, //如果是多个表单，增加多个插槽。slots是弹出框按钮的插槽，preIcons是插槽对应的按钮图标
              title: '下发配置',
            },
          ];
          break;
      }
      return result;
    },
    /**
     * @description: 获取导航项
     * @description: 获取模态框应用列表
     * @return {*}
     */
    GetNavItems: (type: string) => {
      let item: NavItem[] = [];
      switch (type) {
        case 'Product':
          item = [
            {
              title: '添加产品工艺路线',
              icon: 'add_green|svg',
              color: '#1fdaca',
              url: '/addRoute',
              action: 'addRoute',
              isStep: false,
            },
            {
              title: '添加客户工艺路线',
              icon: 'add_customer|svg',
              color: '#bf0c2c',
              url: '/addCustomer',
              action: 'addCustomer',
              isStep: true,
            },
          ];
          break;
        case 'Route':
          item = [
            {
              title: '编辑工艺路线',
              icon: 'clarity:note-edit-line',
              color: '#1fdaca',
              url: '/editRoute',
              action: 'editRoute',
              isStep: false,
            },
          ];
          break;
      }
      return item;
    GetUseModals: () => {
      return {
        useModalData: {
          add: useModal(),
          set: useModal(),
          addRot: useModal(),
          setRot: useModal(),
        },
      };
    },
    /**
     * @description: 导航页面切换按钮时调用方法
     * @param {any} action
     * @description: 获取自定义数据
     * @return {*}
     */
    navChangeItem: (action: any, ...args) => {
      switch (action) {
        case 'addRoute':
          args[0](true, {
    GetCustData: () => {
      return {
        isCustEl: {
          forminfo: false,
          woinfo: false,
          prodinfo: false,
          rotinfo: true,
        },
      };
    },
    /**
     * @description: 弹出选择框选择成功返回方法
     * @param {*} d
     * @param {*} u
     * @return {*}
     */
    GetSelectSuccess: (d, u) => {
      return {
        ROUTE_CODE: d.values['val'],
        // ID: d.values['id'],
        ROT_ID: d.values['id'],
      };
    },
    /**
     * @description: 打开弹出选择框
     * @param {Fn} openItemModal
     * @param {array} args
     * @return {*}
     */
    OpenSelectItem: (openItemModal: Fn, ...args) => {
      const slotName = args[0];
      const openRvModal = args[1];
      const selectVals = args[2];
      switch (slotName) {
        case 'addRot':
        case 'add':
          openItemModal(true, {
            title: '工艺路线列表',
            schemas: [
              {
@@ -453,91 +345,26 @@
            ],
            tableName: 'MES_ROUTE',
            rowKey: 'ROT_CODE',
            returnFieldName: 'ROUTE_CODE', //返回值要赋值的字段名称
            returnFieldName: ['ROUTE_CODE', 'ROT_ID'], //返回值要赋值的字段名称
            searchInfo: { TABLE_NAME: 'MES_ROUTE' },
            which: action,
          });
          break;
        case 'addCustomer':
          args[0](true, {
            title: '请完成以下步骤',
          });
        case 'set':
          openRvModal(true, { rotId: selectVals.value['ROUTE_CODE'], slotName: slotName });
          break;
        case 'editRoute':
          args[1](true, { rotId: args[2][0].id, slotName: '' });
        case 'setRot':
          break;
      }
    },
    /**
     * @description: 获取卡片内配置列表，以循环显示多个卡片并配置多个插槽
     * @return {*}
     */
    GetBaseCards: (type: string) => {
      let reusts: any[] = [];
      switch (type) {
        case 'Product':
          reusts = [];
          break;
        case 'Route':
          reusts = [
            {
              name: 'RotInfo',
              slots: [],
              preIcons: {},
              title: '工艺路线图',
              entityName: '',
            },
          ];
          break;
      }
      return reusts;
    },
    /**
     * @description: 获取插槽列表
     * @return {*}
     */
    GetSlots: () => {
      return ['RotInfo'];
    },
    /**
     * @description: 生成html
     * @return {*}
     */
    GenerateHtml: (type: string | null) => {
      const newElement = document.createElement('div');
      // newElement.textContent = 'New Element =>'+type;
      // newElement.style.height = '250px';
      newElement.id = 'lfContainer';
      newElement.className = 'h-full';
      // newElement.style.color = 'blue';
      // newElement.style.fontSize = '16px';
      return newElement;
    },
    /**
     * @description: 自定义方法
     * @description: 获取标题信息
     * @param {string} type
     * @param {array} args
     * @return {*}
     */
    CustFunc: (param: CustModalParams) => {
      switch (param.cType) {
        case 'BIZ_MES_WO':
        case 'BIZ_MES_WO_Config':
          return getWoFns[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;
      }
    GetTitle: () => {
      return {
        importTitle: '工单计划导入' /* 打开模态窗口显示的标题 */,
      };
    },
  };

@@ -559,12 +386,19 @@
        try {
          const form = param.values['prodinfo'];
          const wo = param.values['mValues'];
          wo.ROUTE_STATUS = 1;
          SaveEntity(wo, true, 'BIZ_MES_WO').then((action) => {
          const _wo = cloneDeep(wo);
          _wo.ROUTE_STATUS = 1;
          _wo.ROUTE_CODE = form.ROUTE_CODE;
          SaveEntity(_wo, true, 'BIZ_MES_WO').then((action) => {
            if (action.IsSuccessed) {
              resolve(true);
              SP_MES_PROD2WO({ rotId: form.ROT_ID, wo: wo.ORDER_NO }).then((res) => {
                if (!res.IsSuccessed) {
                  SaveEntity(wo, true, 'BIZ_MES_WO');
                }
                resolve(res);
              });
            } else {
              reject(false);
              reject(action);
            }
          });
        } catch {
@@ -582,8 +416,7 @@
        try {
          const form = param.values['forminfo'];
          const wo = param.values['mValues'];
          wo.ROUTE_CODE = form.ROUTE_CODE;
          wo.STATUS = 2;
          wo.STATUS = wo.STATUS == 3 ? wo.STATUS : 2;
          let input: SaveWoBatchInput = {
            Wo: wo,
            WoBatch: {
@@ -593,7 +426,7 @@
              UPDATE_TIME: new Date(),
              UPDATE_USER: useUserStore().getUserInfo.userId as string,
              GHOST_ROW: false,
              AUTH_ORG: '',
              AUTH_ORG: useUserStore().getUserInfo.orgCode,
              AUTH_PROD: useUserStore().getUserInfo.prodCode as string,
              AUTH_WH: '',
              ORDER_NO: wo.ORDER_NO,
@@ -602,7 +435,7 @@
              CUST_CODE: wo.CUST_CODE,
              FACTORY: wo.FACTORY,
              WS_CODE: wo.WS_CODE,
              ACT_LINE: form.PLAN_LINE,
              ACT_LINE: form.ACT_LINE,
              STD_WORKER_QTY: wo.STD_WORKER_QTY,
              ACT_WORKER_QTY: wo.ACT_WORKER_QTY,
              RELEASE_TIME: new Date(),
@@ -619,6 +452,7 @@
              ACT_END_TIME: wo.ACT_END_TIME,
              BATCH_NO: '',
            },
            IfToCust: form.IfToCust,
          };
          SaveMesBatchWo(input).then((action) => {
            resolve(action);
@@ -628,517 +462,107 @@
        }
      });
    },
    initRoute: () => {},
  };

  /**
   * @description: 弹出选择框-物料选择框配置
   * @description: 跳转到详情页面方法
   * @param {Fn} go
   * @return {*}
   */
  const itemCodeModalCfg = {
    title: '物料列表',
    schemas: [
      {
        field: 'ITEM_CODE',
        component: 'Input',
        label: '物料编码',
        colProps: {
          span: 12,
  function goDetail(go: Fn, params: Recordable) {
    const id = {
      ID: params['record'].ID,
      CODE: params['record']['ORDER_NO'],
      Name: 'BIZ_MES_WO_BATCH',
      Tabs: [
        {
          name: '工单批次',
          tableTitle: '批次',
          entityName: 'BIZ_MES_WO_BATCH',
          key: 'batch'
        },
      },
    ],
    ItemColumns: [
      {
        title: t('物料编码'),
        dataIndex: 'ITEM_CODE',
        resizable: true,
        sorter: true,
        width: 200,
      },
      {
        title: t('物料名称'),
        dataIndex: 'ITEM_NAME',
        resizable: true,
        sorter: true,
        width: 180,
      },
    ],
    tableName: 'BAS_ITEM',
    rowKey: 'ITEM_CODE',
    searchInfo: { TABLE_NAME: 'BAS_ITEM' },
  };
        // {
        //   name: '工单批次2',
        //   tableTitle: '批次2',
        //   entityName: 'BIZ_U9_ASN_DTL',
        //   key: 'batch2'
        // }
      ],
      pageTitle: '工单详情', //详情页面标题
      contentStr: '这里是工单批次管理页面，可以显示工单下发的所有批次详情',
      detailName: `工单[${params['record'].ORDER_NO}]批次详情`,
      keyFieldValues: { ORDER_NO: params['record']['ORDER_NO'] },
      colSlots: params['colSlots'].value,
      SessionName: 'BIZ_MES_WO_BATCH_update',
      ifSave: false,
    };
    // 将对象转换为JSON字符串并保存到sessionStorage
    sessionStorage.removeItem(`${id.SessionName}_params`);
    sessionStorage.setItem(`${id.SessionName}_params`, encodeURI(JSON.stringify(id)));
    go(`/BIZ_MES_WO_BATCH/${encodeURI(JSON.stringify({ sName: id.SessionName, Name: id.Name }))}`);
  }

  /**
   * @description: 弹出选择框-规则选择框配置
   * @description: 配置工艺
   * @param {Recordable} record
   * @param {array} args
   * @return {*}
   */
  const ruleModalCfg = {
    title: '规则列表',
    schemas: [
      {
        field: 'RULE_CODE',
        component: 'Input',
        label: '规则编码',
        colProps: {
          span: 12,
        },
      },
    ],
    ItemColumns: [
      {
        title: t('规则编码'),
        dataIndex: 'RULE_CODE',
        resizable: true,
        sorter: true,
        width: 200,
      },
      {
        title: t('规则名称'),
        dataIndex: 'RULE_NAME',
        resizable: true,
        sorter: true,
        width: 180,
      },
    ],
    tableName: 'BAS_CODE_RULE',
    rowKey: 'RULE_CODE',
    searchInfo: { TABLE_NAME: 'BAS_CODE_RULE' },
  };
  function handleConfig(args, params: Recordable) {
    const go = args[5];
    const id = {
      ID: params['record'].ID,
      Name: 'WoRouteBinding',
      CODE: params['record'].ORDER_NO,
      Title: `工单[${params['record'].ORDER_NO}]工艺绑定`,
      colSlots:
        params['colSlots'].value /* 表格内的查询表单字段的插槽列表，一般用于弹出选择框按钮 */,
      crudColSlots: {
        BAS_PKG_DTL: ['BAS_LABEL_TEMP1add'],
        ItemCode: ['BAS_CODE_RULE1add'],
      } /* 增删改表单字段的插槽列表，一般用于弹出选择框按钮 */,
      OtherTableName: [
        'BAS_PKG_DTL',
        'ItemCode',
      ] /* 自定义显示列表的表名，跟上面增删改的表名一致，有多个就放列表中 */,
      record: params['record'],
      dense: true,
      pageTitle: `工单工艺绑定`,
      pageContent: `这里是管理工单的工艺绑定，一个工单可以绑定一个工艺路线，并可以保存为客户专用的工艺路线`,
      SessionName: 'WoRouteBinding_update',
      ifSave: false,
      rotType: 'Wo',
    };
    // 将对象转换为JSON字符串并保存到sessionStorage
    sessionStorage.removeItem(`${id.SessionName}_params`);
    sessionStorage.setItem(`${id.SessionName}_params`, encodeURI(JSON.stringify(id)));
    /* 设置标志，以根据缓存数据取数据 */
    const useProdRoute = useProdRouteStore();
    useProdRoute.setChangeToCPPage(true);
    go(`/WoRouteBinding/CP/${encodeURI(JSON.stringify({ sName: id.SessionName, Name: id.Name }))}`);
  }

  /**
   * @description: 弹出选择框-打印模板选择框配置
   * @description: 下发
   * @param {*} record
   * @return {*}
   */
  const printModalCfg = {
    title: '打印模板列表',
    schemas: [
      {
        field: 'LABEL_CODE',
        component: 'Input',
        label: '模板编码',
        colProps: {
          span: 12,
        },
      },
    ],
    ItemColumns: [
      {
        title: t('模板编码'),
        dataIndex: 'LABEL_CODE',
        resizable: true,
        sorter: true,
        width: 200,
      },
      {
        title: t('模板名称'),
        dataIndex: 'LABEL_NAME',
        resizable: true,
        sorter: true,
        width: 180,
      },
    ],
    tableName: 'BAS_LABEL_TEMP',
    rowKey: 'LABEL_CODE',
    searchInfo: { TABLE_NAME: 'BAS_LABEL_TEMP' },
  };

  const pkgModalCfg = {
    title: '包装规则列表',
    schemas: [
      {
        field: 'RULE_CODE',
        component: 'Input',
        label: '包装规则编码',
        colProps: {
          span: 12,
        },
      },
    ],
    ItemColumns: [
      {
        title: t('包装规则编码'),
        dataIndex: 'RULE_CODE',
        resizable: true,
        sorter: true,
        width: 200,
      },
      {
        title: t('包装规则名称'),
        dataIndex: 'RULE_NAME',
        resizable: true,
        sorter: true,
        width: 180,
      },
    ],
    tableName: 'BAS_PKG_RULE',
    rowKey: 'RULE_CODE',
    searchInfo: { TABLE_NAME: 'BAS_PKG_RULE' },
  };

  /**
   * @description: 行为配置表单字段
   * @return {*}
   */
  const actionFormShema: FormSchema[] = [
    {
      field: 'PROD_CODE',
      label: '产品编码',
      component: 'Input',
      dynamicDisabled: ({ values }) => {
        return true;
      },
      colProps: { span: 12 },
    },
    {
      field: 'ID',
      label: 'ID',
      component: 'Input',
      show: false,
    },
    {
      field: 'ACT_ID',
      label: 'ACT_ID',
      component: 'Input',
      show: false,
    },
    {
      field: 'ROT_ID',
      label: 'ROT_ID',
      component: 'Input',
      show: false,
    },
    {
      field: 'ACT_CODE',
      label: 'ACT_CODE',
      component: 'Input',
      show: false,
    },
    {
      field: 'NODE_ID',
      label: 'NODE_ID',
      component: 'Input',
      show: false,
    },
    {
      field: 'CUST_CODE',
      label: '客户编码',
      component: 'Input',
      dynamicDisabled: ({ values }) => {
        return true;
      },
      colProps: { span: 12 },
    },
    {
      field: 'ACT_TYPE',
      label: '行为类型',
      component: 'ApiSelect',
      colProps: { span: 12 },
      defaultValue: 0,
      componentProps: {
        api: GetEnum,
        params: { name: 'MES_PROD_ACTION+ACT_TYPEs' },
        resultField: 'Data',
        labelField: unref(getLocale) == 'zh_CN' ? 'Desc' : 'Name',
        valueField: 'Value',
        // onChange: (e, v) => {
        //   alert(e)
        //   console.log('ApiSelect====>:', e, v);
        // },
      },
    },
    {
      field: 'IS_ACTIVE',
      label: '是否启用',
      required: true,
      component: 'Select',
      colProps: { span: 12 },
      componentProps: {
        options: [
          {
            label: '是',
            value: 'Y',
            key: 'Y',
          },
          {
            label: '否',
            value: 'N',
            key: 'N',
          },
        ],
      },
    },
    {
      field: 'RULE_CODE',
      label: '扫码验证',
      component: 'Input',
      colProps: { span: 10 },
      ifShow: ({ values }) => isScan(values.ACT_TYPE),
    },
    {
      field: '0',
      label: '1',
      defaultValue: '',
      component: 'Input',
      colProps: { span: 2, pull: 1 },
      ifShow: ({ values }) => isScan(values.ACT_TYPE),
      colSlot: 'scanadd',
    },
    {
      field: 'ITEM_CODE',
      label: '组装上料',
      colProps: { span: 10 },
      component: 'Input',
      ifShow: ({ values }) => isAssy(values.ACT_TYPE),
    },
    {
      field: '00',
      label: '1',
      defaultValue: '',
      component: 'Input',
      colProps: { span: 2, pull: 1 },
      ifShow: ({ values }) => isAssy(values.ACT_TYPE),
      colSlot: 'assyadd',
    },
    {
      field: 'TEST_CODE',
      label: '产品测试',
      colProps: { span: 10 },
      component: 'Input',
      ifShow: ({ values }) => isTest(values.ACT_TYPE),
    },
    {
      field: 'test0',
      label: '1',
      defaultValue: '',
      component: 'Input',
      colProps: { span: 2, pull: 1 },
      ifShow: ({ values }) => isTest(values.ACT_TYPE),
      colSlot: 'testadd',
    },
    {
      field: 'SAPL_CODE',
      label: '产品抽检',
      colProps: { span: 10 },
      component: 'Input',
      ifShow: ({ values }) => isAudit(values.ACT_TYPE),
    },
    {
      field: 'audit0',
      label: '1',
      defaultValue: '',
      component: 'Input',
      colProps: { span: 2, pull: 1 },
      ifShow: ({ values }) => isAudit(values.ACT_TYPE),
      colSlot: 'auditadd',
    },
    {
      field: 'LABEL_CODE',
      label: '标签打印',
      colProps: { span: 10 },
      component: 'Input',
      ifShow: ({ values }) => isPrint(values.ACT_TYPE),
    },
    {
      field: 'print0',
      label: '1',
      defaultValue: '',
      component: 'Input',
      colProps: { span: 2, pull: 1 },
      ifShow: ({ values }) => isPrint(values.ACT_TYPE),
      colSlot: 'printadd',
    },
    {
      field: 'pkgRULE_CODE',
      label: '包装规则',
      colProps: { span: 10 },
      component: 'Input',
      ifShow: ({ values }) => isPackage(values.ACT_TYPE),
    },
    {
      field: 'pkg0',
      label: '1',
      defaultValue: '',
      component: 'Input',
      colProps: { span: 2, pull: 1 },
      ifShow: ({ values }) => isPackage(values.ACT_TYPE),
      colSlot: 'pkgadd',
    },
    {
      field: 'REMARK',
      label: '备注',
      component: 'Input',
      colProps: { span: 12 },
    },
  ];

  /**
   * @description: 工序配置表单字段
   * @return {*}
   */
  const nodeFormShema: FormSchema[] = [
    {
      field: 'PROD_CODE',
      label: '产品编码',
      component: 'Input',
      dynamicDisabled: ({ values }) => {
        return true;
      },
      colProps: { span: 12 },
    },
    {
      field: 'ID',
      label: 'ID',
      component: 'Input',
      show: false,
    },
    {
      field: 'ACT_ID',
      label: 'ACT_ID',
      component: 'Input',
      show: false,
    },
    {
      field: 'ROT_ID',
      label: 'ROT_ID',
      component: 'Input',
      show: false,
    },
    {
      field: 'NODE_ID',
      label: 'NODE_ID',
      component: 'Input',
      show: false,
    },
    {
      field: 'NODE_NAME',
      label: '工序节点名称',
      component: 'Input',
    },
    {
      field: 'CUST_CODE',
      label: '客户编码',
      component: 'Input',
      dynamicDisabled: ({ values }) => {
        return true;
      },
      colProps: { span: 12 },
    },
    {
      field: 'OPER_CODE',
      label: '工序编码',
      component: 'Input',
    },
    {
      field: 'IS_ACTIVE',
      label: '是否启用',
      required: true,
      component: 'Select',
      colProps: { span: 12 },
      componentProps: {
        options: [
          {
            label: '是',
            value: 'Y',
            key: 'Y',
          },
          {
            label: '否',
            value: 'N',
            key: 'N',
          },
        ],
      },
    },
    {
      field: 'IS_CALC_FPY',
      label: '是否计算直通率',
      required: true,
      component: 'Select',
      colProps: { span: 12 },
      componentProps: {
        options: [
          {
            label: '是',
            value: 'Y',
            key: 'Y',
          },
          {
            label: '否',
            value: 'N',
            key: 'N',
          },
        ],
      },
    },
    {
      field: 'CAN_SKIP',
      label: '是否允许跳站',
      required: true,
      component: 'Select',
      colProps: { span: 12 },
      componentProps: {
        options: [
          {
            label: '是',
            value: 'Y',
            key: 'Y',
          },
          {
            label: '否',
            value: 'N',
            key: 'N',
          },
        ],
      },
    },
    {
      field: 'IS_INPUT',
      label: '是否投入站',
      required: true,
      component: 'Select',
      colProps: { span: 12 },
      componentProps: {
        options: [
          {
            label: '是',
            value: 'Y',
            key: 'Y',
          },
          {
            label: '否',
            value: 'N',
            key: 'N',
          },
        ],
      },
    },
    {
      field: 'IS_OUTPUT',
      label: '是否产出站',
      required: true,
      component: 'Select',
      colProps: { span: 12 },
      componentProps: {
        options: [
          {
            label: '是',
            value: 'Y',
            key: 'Y',
          },
          {
            label: '否',
            value: 'N',
            key: 'N',
          },
        ],
      },
    },
    {
      field: 'REMARK',
      label: '备注',
      component: 'Input',
      colProps: { span: 12 },
    },
  ];
  function handleRelease(args, params: Recordable) {
    const openCustModal = args[7];
    openCustModal(true, {
      isUpdate: true, //是否更新操作
      ctype: 'BIZ_MES_WO', //是哪个页面
      title: '工单下发', //标题
      width: '900px', //弹出框宽度
      formEl: params['useFormData'].value,
      formElName: ['forminfo'], //表单插槽名称
      RowKeys: { add: 'ROUTE_CODE', set: 'ROUTE_CODE' }, //插槽的弹出框选择的code
      fnName: 'SaveWoBatch', //保存方法名
      initFnName: {}, //初始化方法名，没有就留空{}
      values: params['record'], //表单记录
    });
  }

  const woformSchema: FormSchema[] = [
    {
@@ -1148,6 +572,9 @@
      required: true,
      colProps: {
        span: 24,
      },
      dynamicDisabled: ({ values }) => {
        return true;
      },
    },
    {
@@ -1160,8 +587,8 @@
      },
    },
    {
      label: '计划产线',
      field: 'PLAN_LINE',
      label: '实际产线',
      field: 'ACT_LINE',
      component: 'ApiSelect',
      required: true,
      colProps: {
@@ -1176,34 +603,44 @@
      },
    },
    {
      label: '工艺路线',
      field: 'ROUTE_CODE',
      component: 'Input',
      required: true,
      field: 'IfToCust',
      component: 'Switch',
      label: '是否保存工艺路线到客户',
      defaultValue: true,
      colProps: {
        span: 22,
        span: 8,
      },
      labelWidth: 200,
    },
    {
      field: 'add',
      component: 'Input',
      label: '1',
      colSlot: 'add',
      defaultValue: 'MES_ROUTE',
      colProps: {
        span: 1,
      },
    },
    {
      field: 'set',
      component: 'Input',
      label: '1',
      colSlot: 'set',
      defaultValue: 'MES_ROUTE',
      colProps: {
        span: 1,
      },
    },
    // {
    //   label: '工艺路线',
    //   field: 'ROUTE_CODE',
    //   component: 'Input',
    //   required: true,
    //   colProps: {
    //     span: 22,
    //   },
    // },
    // {
    //   field: 'add',
    //   component: 'Input',
    //   label: '1',
    //   colSlot: 'add',
    //   defaultValue: 'MES_ROUTE',
    //   colProps: {
    //     span: 1,
    //   },
    // },
    // {
    //   field: 'set',
    //   component: 'Input',
    //   label: '1',
    //   colSlot: 'set',
    //   defaultValue: 'MES_ROUTE',
    //   colProps: {
    //     span: 1,
    //   },
    // },
  ];

  const woCfgformSchema: FormSchema[] = [
@@ -1224,23 +661,19 @@
    },
    {
      field: 'ORDER_TYPE',
      component: 'Select',
      component: 'ApiSelect',
      label: '工单类型',
      colProps: {
        span: 8,
      },
      defaultValue: 'Normal',
      defaultValue: 0,
      componentProps: {
        options: [
          {
            label: '正常',
            value: 'Normal',
          },
          {
            label: '返工',
            value: 'Rework',
          },
        ],
        api: GetEnum,
        params: { name: 'BIZ_MES_WO+ORDER_TYPEs' },
        resultField: 'Data',
        labelField: unref(getLocale) == 'zh_CN' ? 'Desc' : 'Name',
        valueField: 'Value',
        placeholder: '请选择工单类型',
      },
      dynamicDisabled: true,
    },
@@ -1310,21 +743,30 @@
      },
    },
    {
      field: 'fieldsc',
      component: 'Upload',
      label: '打印模板',
      label: '工艺路线',
      field: 'ROT_ID',
      component: 'Input',
      show: false,
      colProps: {
        span: 10,
      },
      rules: [{ required: true, message: '请选择上传文件' }],
      componentProps: {
        api: uploadApi,
        multiple: false,
        span: 12,
      },
    },
    // {
    //   field: 'fieldsc',
    //   component: 'Upload',
    //   label: '打印模板',
    //   colProps: {
    //     span: 10,
    //   },
    //   rules: [{ required: true, message: '请选择上传文件' }],
    //   componentProps: {
    //     api: uploadApi,
    //     multiple: false,
    //   },
    // },
  ];

  return [methods];
  return [methods, ActionColumn];
}

export default _default;