/* eslint-disable */
import { useEffect, useReducer, useRef, useState } from "react";
import { cloneDeep } from "lodash";
import { message, Modal } from "antd";

import * as commonUtils from "@/utils/utils";
import * as commonConfig from "@/utils/config";
import * as commonServices from "@/services/services";
import * as commonBusiness from "@/components/Common/commonBusiness";
import * as commonFunc from "@/components/Common/commonFunc";
import * as commonKeyUp from './commonKeyUp';
import instructSet from "@/components/Common/CommonInstructSet";
import costomPageFun from "@/mes/costomPageFun";
const { reducer } = commonUtils;

// 获取默认值
const getInitialState = props => {
  return {
    app: props.app,
    token: props.app.token,
    formRoute: props.routing,
    formSrcRoute: props.routing
      ? props.routing.pathname.replace("/", "")
      : commonUtils.isNotEmptyObject(location.pathname) &&
        location.pathname.toLowerCase() === "/loginmes"
        ? "/commonAuto"
        : "",
    sModelsId: props.sModelsId || "17060784200008784503254849061000",
    callbackRefresh: 0,
    callback: null
    // enabled: true
  };
};

/**
 * 使用commonUtils中的reducer函数和initialState创建commonBase组件
 * @param {Object} props - 组件传入的props对象
 * @returns {Object} - 经处理后的props对象
 */
const useCommonBase = props => {
  const [state, dispatch] = useReducer(reducer, getInitialState(props));
  const tempRef = useRef({});
  let mounted = true
  const setTempRef = (params, bRewrite) => {
    if (bRewrite) {
      tempRef.current = params;
    } else {
      tempRef.current = { ...tempRef.current, ...params };
    }
  };

  const getTempRef = () => tempRef.current;

  useEffect(async () => {
    if (location.pathname.toLowerCase() === "/loginmes") {
      return;
    }
    const { sModelsId, app } = state;
    const formData = await handleGetModelConfig({ sModelsId });

    const addState = {};
    let pageRoute = props.sModelType;
    // 如果是弹窗且没有pageLayout，则认为是commonBill
    if (commonUtils.isNotEmptyObject(props.parentProps) && formData.length && !formData[0].gdsconfigformslave.some(item => item.sControlName === 'pageLayout')) {
      pageRoute = '/indexPage/commonBill';
    }

    if (formData.length && !props.currentContent && ['/indexPage/commonList', '/indexPage/commonBill'].includes(pageRoute) && !formData[0].gdsconfigformslave.some(item => item.sControlName === 'pageLayout')) {
      if (pageRoute === '/indexPage/commonList') {
        formData[0].sGrd = 'slave';
        formData[0].gdsconfigformslave.push({
          sId: commonUtils.createSid(),
          sControlName: 'pageLayout',
          sDefault: JSON.stringify([["slave"], [{ "configList": [{ "sName": "slave", "sTabName": "", "sEnglishTabName": "", "sBig5TabName": "", "showType": "table", "bHideTitle": true, "tableBtnsConfig": [] }], "mode": "advanced", "height": "100%", "width": "100%" }]])
        })
      } else if (pageRoute === '/indexPage/commonBill') {
        const { sLanguage } = app.userinfo;
        const [tableList, tabConfig] = [[], []];
        formData.forEach((item, index) => {
          if (index === 0) {
            item.sGrd = 'master';
            tableList.push('master');
            tabConfig.push({ "configList": [{ "sName": "master", "showType": "form", "bHideTitle": true, "defaultEnabled": true }], "mode": "advanced", "height": "auto", "width": "100%" });
          } else {
            const tablename = `slave${index - 2 < 0 ? '' : index - 2}`;
            item.sGrd = tablename;
            tableList.push(tablename);
            if (!tabConfig[1]) {
              tabConfig.push({ "configList": [], "mode": "advanced" });
            }
            tabConfig[1].configList.push({ "sName": tablename, "sTabName": item[sLanguage], "showType": "table", "defaultEnabled": true, "bHideTitle": true });
          }
        });
        formData[0].gdsconfigformslave.push({
          sId: commonUtils.createSid(),
          sControlName: 'pageLayout',
          sDefault: JSON.stringify([tableList, tabConfig])
        })
        addState.bMesBill = true;
        addState.copyTo = { master: { maxBillNo: 'sBillNo' } };
      }
    }

    handleSaveState({ formData, ...addState });
  }, []);
  useEffect(() => {
    // handleSaveState({ refreshTableList: [] });
  }, [props?.refresh])
  const { callbackRefresh, callback } = state;
  // 使用useCallback钩子函数，确保callback函数在callbackRefresh改变时重新调用
  useXlyCallback(callbackRefresh, callback, state, () => {
    dispatch(["saveState", { callback: null }]);
  });

  /**
   * 处理保存state的逻辑
   * @param {Object} values - 传入的values对象
   * @param {Function} callback - 回调函数
   */
  const handleSaveState = (values, callback) => {
    console.log("🚀 ~ handleSaveState ~ values:", values)
    if (commonUtils.isNotEmptyObject(values.masterConfig) && values.masterConfig.bMerged) {
      delete values.masterConfig;
    }
    Object.keys(values).forEach(key => {
      // 如果将要保存的slaveConfig是合并过的，则删除掉
      if (key.startsWith('slave') && key.endsWith('Config') && commonUtils.isNotEmptyObject(values[key]) && values[key].bMerged) {
        delete values[key];
      }
    });
    // 如果改变了主表数据，遍历下所有配置sButtonEnabled的字段，生成配置
    const addState = {};
    const sRulesJsonTotal = handleGetRulesJsonTotal(values);
    if (sRulesJsonTotal) {
      addState.sRulesJsonTotal = sRulesJsonTotal;
    }
    const cbState = {};
    if (typeof callback === "function") {
      cbState.callbackRefresh = callbackRefresh + 1;
      cbState.callback = callback;
    }
    dispatch(["saveState", { ...values, ...cbState }]);
  };

  // 遍历下所有配置sButtonEnabled的字段，生成配置

  const handleGetRulesJsonTotal = (values) => {
    const { masterConfig: masterConfig1, masterData: masterData1 } = values;
    const { masterConfig: masterConfig2, masterData: masterData2, sRulesJsonTotal } = state;

    const masterConfig = masterConfig1 || masterConfig2;
    const masterData = masterData1 || masterData2;

    const condition0 = commonUtils.isEmptyObject(masterConfig1) && commonUtils.isEmptyObject(masterData1);
    const condition1 = commonUtils.isNotEmptyObject(masterConfig) && commonUtils.isNotEmptyObject(masterData1);
    const condition2 = commonUtils.isNotEmptyObject(masterConfig) && sRulesJsonTotal === undefined && commonUtils.isNotEmptyObject(masterData);
    const condition3 = commonUtils.convertObjToStr(masterData1) === commonUtils.convertObjToStr(masterData2) && sRulesJsonTotal !== undefined;

    const { sRulesTableList = [] } = state;
    let condition4 = false;
    if (sRulesTableList.length) {
      sRulesTableList.forEach(tableName => {
        const { [`${tableName}Data`]: tableData1 } = values;
        const { [`${tableName}Data`]: tableData2 = [] } = state;
        if (tableData1 !== undefined && commonUtils.convertObjToStr(tableData1) !== commonUtils.convertObjToStr(tableData2)) {
          condition4 = true;
        }
      })
    }

    if (condition0 || !(condition1 || condition2) || condition3) {
      if (!condition4) {
        return '';
      }
    }

    const { gdsconfigformslave = [] } = masterConfig;
    return gdsconfigformslave.reduce((result, config) => {
      const { sButtonEnabled } = config;
      const sRulesJson = commonUtils.convertStrToObj(sButtonEnabled, []);
      if (commonUtils.isNotEmptyArr(sRulesJson)) {
        for (let i = 0; i < sRulesJson.length; i += 1) {
          const rule = sRulesJson[i] || {};
          const { condition = [] } = rule;
          let flag = false; // 是否满足条件
          for (let j = 0; j < condition.length; j += 1) {
            const item = condition[j];
            const { bFilterName, bFilterCondition, bFilterValue, jsCondition } = item;
            if (jsCondition) {
              flag = commonFunc.getEvalResult({
                props: { ...props, ...state, ...values },
                str: jsCondition,
                defaultValue: false,
                reocrdRules: true,
                onSaveState: handleSaveState,
              })
            } else if (bFilterName !== undefined && bFilterCondition !== undefined && bFilterValue !== undefined) {
              const currentValue = masterData[bFilterName];
              flag = handleCompareValues(currentValue, bFilterValue, bFilterCondition);
            }
            if (!flag) {
              break;
            }
          }
          if (flag) {
            // console.log('=====匹配的规则', config, rule);
            const columnList = Object.keys(rule).filter(columnName => columnName && columnName.indexOf('Column') !== -1);
            columnList.forEach((columnName) => {
              if (commonUtils.isEmptyArr(result[columnName])) {
                result[columnName] = [];
              }
              result[columnName] = Array.from(new Set([...result[columnName], ...rule[columnName]]));
            });
            // return result;
          }
        }
      }
      return result;
    }, {});
  }
  /**
   * 获取模型配置
   * @param {Object} params - 参数对象
   * @param {string} params.sModelsId - 模型ID
   * @returns {Promise<Array>} - 表单数据
   */
  const handleGetModelConfig = async params => {
    const { sModelsId } = params;
    const { token, formSrcRoute } = state;
    const configUrl = `${commonConfig.server_host
      }business/getModelBysId/${sModelsId}?sModelsId=${sModelsId}&sName=${formSrcRoute}`;
    const configUrlModel = `${commonConfig.server_host
      }/gdsmodule/getGdsmoduleById/${sModelsId}?sModelsId=${sModelsId}&sName=${formSrcRoute}`;
    // const getGdsmoduleById
    const configReturnModel = (await commonServices.getService(token, configUrlModel))
      .data;
    console.log("🚀 ~ handleGetModelConfig ~ configReturnModel:", configReturnModel)

    const configReturn = (await commonServices.getService(token, configUrl))
      .data;

    let formData = [];
    if (configReturn.code === 1) {
      const [configData] = configReturn.dataset.rows;
      formData = configData.formData;
    } else {
      getServiceError(configReturn);
    }
    const configReturnModelData = configReturnModel.dataset.rows[0]
    if (configReturnModelData) {
      formData.forEach(item => {
        item.sModelType = configReturnModelData?.sModelType
      })
    }
    return formData;
  };

  /* 获取后台数据（数据集） */
  const handleGetDataSet = async params => {
    const {
      name,
      condition = {},
      flag,
      isWait,
      configData,
      clearSelectData,
    } = params;
    const {
      token,
      sModelsId,
      [`${name}SelectedData`]: tableSelectedData,
      formSrcRoute,
      formData,
      [`${name}DelData`]: tableDelData
    } = state;
    let {
      menuChildData,
      [`${name}SelectedRowKeys`]: tableSelectedRowKeys,
      iPageSize
    } = state;
    const masterConditionData = commonUtils.isNotEmptyObject(condition)
      ? condition.sSqlCondition
      : {};
    /* 根据后台主表配置bPagination判断 是否分页  */
    if (
      commonUtils.isNotEmptyObject(configData) &&
      commonUtils.isNotEmptyObject(condition)
    ) {
      const { bPagination } = configData;
      if (!bPagination || bPagination === undefined) {
        condition.pageSize = 10000; /* 不分页 */
      } else {
        /* 分页 */
        // eslint-disable-next-line no-lonely-if
        if (commonUtils.isNotEmptyArr(formData)) {
          if (
            commonUtils.isNotEmptyNumber(formData[0].iPageSize) &&
            formData[0].iPageSize !== 0
          ) {
            iPageSize = formData[0].iPageSize; /* 后台设定页数 */
          }
        }
      }
    }

    // 凹印人检特殊处理
    if (configData?.sGrd === "slaveWyrj2") {
      const {
        slaveWyrj1Data = [],
        slaveWyrj3Data = [],
        slaveWyrj3SelectedRowKeys = []
      } = state;
      const slaveWyrj3SelectedRow = slaveWyrj3Data.find(
        item => item.sId === slaveWyrj3SelectedRowKeys[0]
      );
      if (!slaveWyrj1Data.length && slaveWyrj3SelectedRow) {
        masterConditionData.sChildTrayId = slaveWyrj3SelectedRow.sId;
      }
    }

    // 加入mes通用参数
    const { app } = props;
    const {
      sMachineNameSId: sMachineGuid,
      sTeamNameSId: sTeamGuid,
      sShift
    } = app;
    condition.sSqlCondition = condition.sSqlCondition || {};
    condition.sSqlCondition.sMachineGuid = sMachineGuid;
    condition.sSqlCondition.sTeamGuid = sTeamGuid;
    condition.sSqlCondition.sShift = sShift;

    // 带入上个页面传递过来的参数
    const currentMesPane = commonUtils.convertStrToObj(
      localStorage.getItem(`${commonConfig.prefix}currentMesPane`),
      {}
    );
    const { sParentConditions: sParentConditions1 = {} } = currentMesPane; // 页面跳转带过来的参数
    const { sParentConditions: sParentConditions2 = {} } = props; // 页面弹窗太过来的参数
    const sParentConditions = { ...sParentConditions1, ...sParentConditions2 };
    if (commonUtils.isNotEmptyObject(sParentConditions)) {
      condition.sSqlCondition = {
        ...condition.sSqlCondition,
        ...sParentConditions
      };
    }

    const configDataId = configData?.sId;
    const sId = JSON.parse(JSON.stringify(condition?.sId || ''))
    let pageRoute = props.sModelType;
    // 如果是弹窗且没有pageLayout，则认为是commonBill
    if (commonUtils.isNotEmptyObject(props.parentProps)) {
      pageRoute = '/indexPage/commonBill';
    }
    if (name === 'master' && pageRoute.includes('indexPage/commonBill')) {
      // condition.sId = configDataId
      condition.pageNum = ''
      condition.pageSize = ''
      delete condition.sSqlCondition
    }
    if (name.includes('slave') && pageRoute.includes('indexPage/commonBill')) {
      delete condition.sSqlCondition
      delete condition.sId
      condition.sSqlCondition = {
        sParentId: sId
      }
    }
    if (name === 'master' && sId === '') {
      return
    }
    const dataUrl = `${commonConfig.server_host
      }business/getBusinessDataByFormcustomId/${configDataId}?sModelsId=${sModelsId}&sName=${formSrcRoute}`;
    const dataReturn = (await commonServices.postValueService(
      token,
      condition,
      dataUrl
    )).data;
    if (dataReturn.code === 1) {
      if (
        commonUtils.isNotEmptyObject(dataReturn.dataset) &&
        commonUtils.isNotEmptyArr(dataReturn.dataset.rows)
      ) {
        let returnData = dataReturn.dataset.rows[0].dataSet;
        const columnConfig = dataReturn.dataset.rows[0].columnConfig;
        if (commonUtils.isNotEmptyObject(returnData)) {
          if (commonUtils.isEmptyArr(tableSelectedData)) {
            if (flag) {
              tableSelectedRowKeys = [];
              menuChildData = []; // 打印下拉置空
            }
          }
        }
        if (clearSelectData) {
          tableSelectedRowKeys = [];
          menuChildData = []; // 打印下拉置空
        }
        const { sumSet } = dataReturn.dataset.rows[0];
        const totalData = sumSet !== undefined ? sumSet : [];
        const filterCondition = commonUtils.isNotEmptyObject(condition)
          ? condition.bFilter
          : "";
        const orderBy = commonUtils.isNotEmptyObject(condition)
          ? condition.sFilterOrderBy
          : "";
        /* 去除树搜索filterCondition */
        const filterConditionNew = commonUtils.isNotEmptyObject(filterCondition)
          ? filterCondition.filter(item => item.bFilterType !== "tree")
          : "";
        const addState = {
          [`${name}Data`]: returnData,
          [`${name}TotalData`]: totalData,
          // [`${name}Pagination`]: returnPagination,
          [`${name}FilterCondition`]: filterConditionNew,
          [`${name}OrderBy`]: orderBy,
          [`${name}SelectedRowKeys`]: tableSelectedRowKeys,
          menuChildData,
          pageLoading: false,
          iPageSize,
          masterConditionData
        };

        // 添加动态列数据
        if (commonUtils.isNotEmptyArr(columnConfig)) {
          addState[`${name}ColumnConfig`] = columnConfig;
        }

        const slaveSelectedData = [];
        addState[`${name}SelectedData`] = slaveSelectedData;
        /* 如果获取数据集时候 删除数据集有数据 则清空 */
        if (commonUtils.isNotEmptyArr(tableDelData)) {
          addState[`${name}DelData`] = [];
        }
        if (isWait) {
          return addState;
        }
        {
          handleSaveState(addState);
        }
      } else {
        message.error(name + "表数据获取错误！");
      }
    } else {
      if (!isWait) {
        handleSaveState({ pageLoading: false });
      }
      getServiceError(dataReturn);
    }
  };

  /* 获取过滤树数据（数据集） */
  const handleGetTreeDataSet = async (params, name) => {
    const { configData, condition, isWait } = params;
    const { token, sModelsId, formSrcRoute } = state;
    let treeData = [];
    const expandedKeys = [];
    const configDataId = configData.sParentId;
    const dataUrl = `${commonConfig.server_host
      }filterTree/getFilterTree/${configDataId}?sModelsId=${sModelsId}&sName=${formSrcRoute}`;
    const dataReturn = (await commonServices.postValueService(
      token,
      condition,
      dataUrl
    )).data;
    if (dataReturn.code === 1) {
      const returnData = dataReturn.dataset.rows;
      if (commonUtils.isNotEmptyArr(returnData)) {
        /* 拼装树结构 */
        treeData = returnData;
        /* 默认展开第一个父节点 */
        if (treeData.length > 0) {
          if (commonUtils.isNotEmptyObject(treeData[0].key)) {
            expandedKeys.push(treeData[0].key);
          }
        }
      }
      let addState = {
        expandedKeys
      };
      if (name) {
        addState[`${name}TreeData`] = treeData;
      } else {
        addState.treeData = treeData;
      }
      addState = { ...addState };
      if (isWait) {
        return addState;
      } else if (mounted) {
        handleSaveState(addState);
      }
    } else {
      getServiceError(dataReturn);
    }
  };

  // 获取sqlCondition值
  const handleGetSqlConditionValues = config => {
    let conditonValues = {};
    const { sSqlCondition } = config;
    const { app = {} } = state;
    if (commonUtils.isNotEmptyObject(sSqlCondition)) {
      const tableName = sSqlCondition.split(".")[0];
      if (tableName === "master") {
        conditonValues = getSqlCondition(config, "master", state.masterData);
      } else {
        let tableDataRow = {};
        const selectedRowKeys = state[`${tableName}SelectedRowKeys`];
        const tableData = state[`${tableName}Data`] || [];

        // 全局数据
        const globalData = commonUtils.convertStrToObj(
          localStorage.xlybusinessglobalData
        );
        if (globalData[tableName]) {
          // 如果是全局数据
          tableDataRow = globalData[tableName];
        } else if (
          commonUtils.isNotEmptyArr(selectedRowKeys) &&
          commonUtils.isNotEmptyArr(tableData)
        ) {
          tableDataRow =
            tableData.find(item => item.sId === selectedRowKeys[0]) || {};
        } else {
          tableDataRow = tableData[0] || {};
        }
        conditonValues = getSqlCondition(config, tableName, tableDataRow);
      }
    }

    const { currentPane = {} } = app;
    const { sSqlConditionValues = {} } = currentPane;

    // mes的额外参数
    const extraMesConditionValues = getExtraMesConditionValues();

    return {
      ...sSqlConditionValues,
      ...extraMesConditionValues,
      ...conditonValues
    };
  };

  // mes的额外参数
  const getExtraMesConditionValues = () => {
    const { app } = state;
    const { menuMapOpposite } = app;
    const globalData = commonUtils.convertStrToObj(
      localStorage.xlybusinessglobalData
    );
    const { sModelsId, sModelType } = props;
    const [path = []] = handleGetMenu(sModelsId);
    const currentContent = menuMapOpposite[path[0]];
    const { currentSelectedMachineTaskDataRow = {} } = globalData;
    // 如果是计划任务的子页面，默认加上工单id，工序id，机台id，产品id，客户id
    if (currentContent === "scheduledTasks") {
      // 机台任务、历史任务除外
      const excludeList = ["machineTask", "historyTask"];
      if (excludeList.some(item => sModelType.includes(item))) return {};
      const {
        sMachineId,
        sProcessId,
        sWorkOrderId,
        sProductId,
        sCustomerId
      } = currentSelectedMachineTaskDataRow;
      return { sMachineId, sProcessId, sWorkOrderId, sProductId, sCustomerId };
    }

    return {};
  };

  const getSqlCondition = (showConfig, name, record) => {
    const conditonValues = {};
    if (commonUtils.isNotEmptyStr(showConfig.sSqlCondition)) {
      const conditon = showConfig.sSqlCondition.split(",");

      conditon.forEach(item => {
        // 特殊处理
        if (item === "sBoardNo.sBoardNo") {
          if (commonUtils.isNotEmptyArr(state["qztable0Data"])) {
            item = "qztable0.sBoardNo";
          } else if (commonUtils.isNotEmptyArr(state["jytable0Data"])) {
            item = "jytable0.sBoardNo";
          } else if (commonUtils.isNotEmptyArr(state["wytable0Data"])) {
            item = "wytable0.sBoardNo";
          } else if (commonUtils.isNotEmptyArr(state["wytgtable0Data"])) {
            item = "wytgtable0.sBoardNo";
          }
        }

        if (item.indexOf(".") > -1) {
          const tableName = item.split(".")[0];
          let fieldName = item.split(".")[1];
          let fieldNameFilter =
            item.split(".").length > 2 ? item.split(".")[2] : fieldName;
          // master.sId 作为参数   master.sId.sId 作为filterDropdown过滤参数
          if (showConfig.sDropDownType === "picArr") {
            fieldNameFilter =
              item.split(".").length > 2 ? item.split(".")[2] : fieldName;
            if (fieldName.indexOf("&Search") > -1) {
              // 参数为&Search时认为是查找数据集中取数据
              const data = state[`${tableName}Data`];
              if (typeof data === "object" && data.constructor === Object) {
                Object.keys(data).forEach(dataItem => {
                  if (`&Search${data[dataItem]}` === fieldName) {
                    let sTmpName = dataItem;
                    sTmpName = sTmpName.replace("First", "Third");
                    if (data[dataItem].substring(0, 1) === "t") {
                      fieldName = `p${sTmpName.substring(1, dataItem.length)}`;
                    } else if (data[dataItem].substring(0, 1) === "m") {
                      fieldName =
                        data[dataItem].substring(0, 1) +
                        sTmpName.substring(1, sTmpName.length);
                    } else {
                      fieldName =
                        data[dataItem].substring(0, 1) +
                        sTmpName.substring(1, sTmpName.length);
                    }
                  }
                });
              }
            } else if (fieldName.indexOf("&") > -1) {
              fieldNameFilter =
                item.split(".").length > 2 ? item.split(".")[2] : fieldName;
              conditonValues[fieldNameFilter] = fieldName.replace("&", "");
              return;
            }
          }
          if (fieldName !== "") {
            if (
              [
                "userinfo",
                "currentSelectedMachineTask",
                "currentStartWorkMachineTask",
                "currentWorkOrderInfo"
              ].includes(tableName)
            ) {
              // 如果是全局变量
              const { app } = props;
              const globalData = commonUtils.convertStrToObj(
                localStorage.xlybusinessglobalData
              );
              const tempProps = {
                userinfo: app.userinfo,
                currentSelectedMachineTask:
                  globalData?.currentSelectedMachineTask,
                currentStartWorkMachineTask:
                  globalData?.currentStartWorkMachineTask,
                currentWorkOrderInfo: globalData?.currentWorkOrderInfo
              };
              conditonValues[fieldNameFilter] = tempProps[tableName][fieldName];
            } else if (name === tableName && !commonUtils.isEmpty(record)) {
              const data = record;
              conditonValues[fieldNameFilter] = data[fieldName];
            } else {
              const data = state[`${tableName}Data`];
              const selectedRowKeys = state[`${tableName}SelectedRowKeys`];
              if (typeof data === "object" && data.constructor === Object) {
                conditonValues[fieldNameFilter] = data[fieldName];
              } else if (commonUtils.isNotEmptyArr(selectedRowKeys)) {
                let iIndex = data.findIndex(
                  itemData => itemData.sId === selectedRowKeys[0]
                );
                iIndex =
                  iIndex > -1
                    ? iIndex
                    : data.findIndex(
                      itemData => itemData.sSlaveId === selectedRowKeys[0]
                    );
                if (iIndex > -1) {
                  conditonValues[fieldNameFilter] = data[iIndex][fieldName];
                }
              } else if (commonUtils.isNotEmptyArr(data)) {
                conditonValues[fieldNameFilter] = data[0][fieldName];
              }
            }
          }
        }
      });
    }
    if (name === 'master') {
      delete conditonValues.sSqlCondition
    }
    return conditonValues;
  };

  /*   获取数字格式化规范   */
  const getFloatNum = sName => {
    if (sName.toLowerCase().endsWith("price")) {
      /*   价格   */
      return props.app.decimals.dNetPrice;
    } else if (sName.toLowerCase().endsWith("money")) {
      /*   金额   */
      return props.app.decimals.dNetMoney;
    } else {
      /*   其它   */
      return 6;
    }
  };

  /*   获取数字格式化规范   */
  const getDateFormat = () => {
    return props.app.dateFormat;
  };

  /**   获取sql下拉数据   */
  const getSqlDropDownData = async (
    formId,
    name,
    showConfig,
    record,
    sKeyUpFilterName,
    pageNum
  ) => {
    /*   地址   */
    const { formSrcRoute } = state;
    if (commonUtils.isEmpty(showConfig.sFieldToContent)) {
      if (commonUtils.isEmpty(showConfig.showDropDown)) {
        return {
          dropDownData: [],
          totalPageCount: 0,
          currentPageNo: 0,
          conditonValues: {}
        };
      }
      const url = `${commonConfig.server_host}business/getSelectLimit/${showConfig.sId
        }?sModelsId=${state.sModelsId}&sName=${formSrcRoute}`;
      /*   参数   */
      let conditonValues = getSqlCondition(showConfig, name, record);
      if (record?.conditonValues) {
        conditonValues = { ...conditonValues, ...record.conditonValues };
      }
      const body = {
        sSqlCondition: commonUtils.isEmptyObject(conditonValues)
          ? ""
          : conditonValues /*   查询条件   */
      };
      if (!commonUtils.isEmpty(pageNum)) {
        body.sKeyUpFilterName = sKeyUpFilterName; /*   边输入边过滤,暂时没用1   */
        body.pageNum = pageNum;
        // 下拉数据改为无限
        body.pageSize = commonConfig.pageSize;
        // body.pageSize = 9999;
      }
      /*   获取数据   */
      const json = await commonServices.postValueService(
        props.app.token,
        body,
        url
      );
      /*   code为1代表获取数据成功   */
      if (json.data.code === 1) {
        /*   获取数据集   */
        const {
          rows,
          totalPageCount,
          currentPageNo,
          totalCount
        } = json.data.dataset;
        return {
          dropDownData: rows,
          totalPageCount,
          currentPageNo,
          conditonValues,
          totalCount
        };
      } else {
        return {
          dropDownData: [],
          totalPageCount: 0,
          currentPageNo: 0,
          conditonValues,
          totalCount
        };
      }
    } else {
      const returnData = [];
      if (showConfig.sFieldToContent === "1") {
        if (name === "master") {
          const { [`${name}Data`]: data } = state;
          const sName = `sParamDropDown${showConfig.sName.replace(
            "sParamValue",
            ""
          )}`;
          returnData.push(...commonUtils.objectToArr(data[sName]));
        } else {
          const {
            [`${name}Data`]: data,
            [`${name}SelectedRowKeys`]: selectedRowKeys
          } = state;
          const sName = `sParamDropDown${showConfig.sName.replace(
            "sParamValue",
            ""
          )}`;
          if (commonUtils.isNotEmptyObject(record)) {
            returnData.push(...commonUtils.objectToArr(record[sName]));
          } else if (
            commonUtils.isNotEmptyArr(data) &&
            commonUtils.isNotEmptyArr(selectedRowKeys)
          ) {
            const iIndex = data.findIndex(
              item => item.sId === selectedRowKeys.toString()
            );
            if (iIndex > -1) {
              returnData.push(...commonUtils.objectToArr(data[iIndex][sName]));
            }
          }
        }
      } else {
        const unionCondition = showConfig.sFieldToContent.split("&&");
        unionCondition.forEach(unionItem => {
          const conditon = unionItem.split(",");
          const tableNameContent = conditon[0].split(".")[0];
          let data = state[`${tableNameContent}Data`];
          if (commonUtils.isNotEmptyArr(data)) {
            if (showConfig.sSqlCondition !== "") {
              const sSqlCondition = showConfig.sSqlCondition;
              const sqlConditon = sSqlCondition.split(",");
              sqlConditon.forEach(item => {
                const tableName = item.split(".")[0];
                const fieldName = item.split(".")[1];
                const fieldNameFilter =
                  item.split(".").length > 2 ? item.split(".")[2] : fieldName;
                const dataCondition = state[`${tableName}Data`];
                const selectedRowKeys = state[`${tableName}SelectedRowKeys`];
                if (
                  typeof dataCondition === "object" &&
                  dataCondition.constructor === Object
                ) {
                  // 对象不用filter
                  // data = data.filter(item => commonUtils.isNull(item[fieldNameFilter], '') === commonUtils.isNull(dataCondition[fieldName], ''));
                } else if (commonUtils.isNotEmptyArr(selectedRowKeys)) {
                  let iIndex = dataCondition.findIndex(
                    itemData => itemData.sId === selectedRowKeys[0]
                  );
                  iIndex =
                    iIndex > -1
                      ? iIndex
                      : dataCondition.findIndex(
                        itemData => itemData.sSlaveId === selectedRowKeys[0]
                      );
                  if (iIndex > -1) {
                    data = data.filter(
                      item =>
                        commonUtils.isNull(item[fieldNameFilter], "") ===
                        commonUtils.isNull(dataCondition[iIndex][fieldName], "")
                    );
                  }
                } else if (commonUtils.isNotEmptyArr(data)) {
                  data = data.filter(
                    item =>
                      commonUtils.isNull(item[fieldNameFilter], "") ===
                      commonUtils.isNull(dataCondition[0][fieldName], "")
                  );
                }
              });
            }
            if (typeof data === "object" && data.constructor === Object) {
              const dataRow = {};
              conditon.forEach(item => {
                const fieldName = item.split(".")[1];
                const fieldNameFilter =
                  item.split(".").length > 2 ? item.split(".")[2] : fieldName;
                if (fieldName.indexOf("-") >= 0) {
                  fieldName.split("-").forEach(itemField => {
                    const sFieldValue = commonUtils.isEmpty(data[itemField])
                      ? ""
                      : data[itemField].toString();
                    dataRow[fieldNameFilter] = commonUtils.isEmpty(
                      dataRow[fieldNameFilter]
                    )
                      ? sFieldValue
                      : `${dataRow[fieldNameFilter]}-${sFieldValue}`;
                  });
                } else {
                  dataRow[fieldNameFilter] = commonUtils.isEmpty(
                    data[fieldName]
                  )
                    ? ""
                    : data[fieldName].toString();
                }
              });
              returnData.push(dataRow);
            } else {
              data.forEach(itemDataRow => {
                const dataRow = {};
                conditon.forEach(item => {
                  const fieldName = item.split(".")[1];
                  const fieldNameFilter =
                    item.split(".").length > 2 ? item.split(".")[2] : fieldName;
                  if (fieldName.indexOf("-") >= 0) {
                    fieldName.split("-").forEach(itemField => {
                      const sFieldValue = commonUtils.isEmpty(
                        itemDataRow[itemField]
                      )
                        ? ""
                        : itemDataRow[itemField].toString();
                      dataRow[fieldNameFilter] = commonUtils.isEmpty(
                        dataRow[fieldNameFilter]
                      )
                        ? sFieldValue
                        : `${dataRow[fieldNameFilter]}-${sFieldValue}`;
                    });
                  } else {
                    dataRow[fieldNameFilter] = commonUtils.isEmpty(
                      itemDataRow[fieldName]
                    )
                      ? ""
                      : itemDataRow[fieldName].toString();
                  }
                });
                returnData.push(dataRow);
              });
            }
          }
        });
      }
      return { dropDownData: returnData, totalPageCount: 0, currentPageNo: 0 };
    }
  };

  const handleTableSelectRowChange = (name, selectedRowKeys, isWait) => {
    /*   外置处理业务   */
    const {
      sModelsId,
      [`${name}Data`]: slaveData = [],
      [`${name}Config`]: tableConfig = {}
    } = state;
    let { slaveSelectedData } = state;
    const addState = {};
    addState[`${name}SelectedRowKeys`] = selectedRowKeys;
    addState.searchUpDownData = {};
    const slavePageData = slaveData.filter(item =>
      selectedRowKeys.includes(item.sSlaveId)
    );
    slaveSelectedData = commonUtils.isEmpty(slaveSelectedData)
      ? []
      : slaveSelectedData.filter(item =>
        selectedRowKeys.toString().includes(item.sSlaveId)
      );
    selectedRowKeys.forEach(item => {
      const iIndex = slaveSelectedData.findIndex(
        selectItem => selectItem.sSlaveId === item
      );
      if (iIndex === -1) {
        const iPageIndex = slavePageData.findIndex(
          pageItem => pageItem.sSlaveId === item
        );
        if (iPageIndex > -1) {
          slaveSelectedData.push(slavePageData[iPageIndex]);
        }
      }
    });
    addState.slaveSelectedData = slaveSelectedData;
    if (commonUtils.isNotEmptyObject(tableConfig)) {
      tableConfig.gdsconfigformslave.forEach(configItem => {
        const sFieldName = configItem.sName;
        if (
          !commonUtils.isEmpty(tableConfig.gdsconfigformslave) &&
          commonUtils.isNotEmptyArr(tableConfig.gdsconfigformslave) &&
          !commonUtils.isEmpty(sFieldName) &&
          (commonUtils.isEmptyArr(state[`${name}SelectedRowKeys`]) ||
            selectedRowKeys.toString() !==
            state[`${name}SelectedRowKeys`].toString())
        ) {
          tableConfig.gdsconfigformslave
            .filter(
              item =>
                !commonUtils.isEmpty(item.sSqlCondition) &&
                !commonUtils.isEmpty(item.sChineseDropDown) &&
                (item.sChineseDropDown.includes(`#${sFieldName}`) ||
                  item.sChineseDropDown.includes(`*${sFieldName}`)) &&
                (item.sSqlCondition.includes(`master.${sFieldName}`) ||
                  item.sSqlCondition.includes(sFieldName.replace("Name", "Id")))
            )
            .forEach(item => {
              commonUtils.setStoreDropDownData(
                sModelsId,
                "slave",
                item.sName,
                []
              );
            });
        }
      });
    }
    if (isWait) {
      return addState;
    } else {
      handleSaveState(addState, newState => {
        handleTableClickInstruct(newState, name);
      });
    }
  };

  // 表格点击调用指令集
  const handleTableClickInstruct = (newState, name) => {
    const {
      [`${name}Config`]: tableConfig = {},
      slave0SelectedRowKeys,
      slave0Data
    } = newState;
    if (name === "slave0") {
      const viewRow = slave0SelectedRowKeys.length
        ? slave0Data?.filter(item =>
          slave0SelectedRowKeys.includes(item.sId)
        )[0]
        : {};
      if (viewRow?.sAbnormalEventId) {
        handleSaveState({
          [`slave1SelectedRowKeys`]: [viewRow.sAbnormalEventId]
        });
      }
    }
    const rowClickConfig = tableConfig.gdsconfigformslave?.find(
      item =>
        item.sControlName &&
        item.sControlName.toLowerCase().includes("rowclick")
    );
    if (!rowClickConfig) return;

    if (rowClickConfig.sControlName.toLowerCase().includes("after")) {
      window.rowclickAfterFunc = nextProps => {
        handleExecInstructSet({
          btnConfig: rowClickConfig,
          nextProps: nextProps
        });
      };
    } else {
      props.app.globalFun.onSetMask(true);
      handleExecInstructSet({
        btnConfig: rowClickConfig,
        nextProps: newState,
        callback: () => {
          props.app.globalFun.onSetMask(false);
        }
      });
    }
  };

  // 发送websocket消息
  const handleSendSocketMessage = (
    flag,
    showType,
    sId,
    sendTo,
    msgInfo,
    param
  ) => {
    const { token } = props.app;
    const sendws = handleSendWebSocketMsg;
    const { dispatch } = props;
    if (commonUtils.isNotEmptyObject(token)) {
      if (
        props.app.webSocket !== null &&
        props.app.webSocket.readyState === WebSocket.OPEN
      ) {
        sendws(flag, showType, msgInfo, sId, sendTo, param);
      } else {
        props.dispatch({
          type: "app/createWebSocket",
          payload: { reStart: true, dispatch }
        });
        setTimeout(() => {
          sendws(flag, showType, msgInfo, sId, sendTo, param);
        }, 30000);
      }
    }
  };

  const handleSendWebSocketMsg = (
    flag,
    showType,
    msgInfo,
    sId,
    sendTo,
    param
  ) => {
    const { app } = props;
    const { webSocket, userinfo, currentPane } = app;
    const { key } = currentPane;
    commonFunc.sendWebSocketMessage(
      webSocket,
      key,
      flag,
      showType,
      userinfo.sId,
      msgInfo,
      sId,
      sendTo,
      param
    );
  };

  /* newRecord新纪录保存后，将数据回到到下拉框中 字段名，主从表名，赋值字段 */
  const handleCallBackRecord = async (sName, name, sId) => {
    const {
      [`${name}SelectedRowKeys`]: tableSelectedRowKeys,
      sModelsId,
      [`${name}Data`]: tableNewData,
      slaveData,
      masterData,
      sModelsType,
      token,
      formRoute
    } = state;
    const { app } = props;
    /* 获取下拉的字段showConfig */
    const { [`${[name]}Config`]: nameConfig } = state;
    const filedShowConfig = nameConfig.gdsconfigformslave.filter(
      item => item.sName === sName
    );
    const AssignField = commonUtils.isNotEmptyArr(filedShowConfig)
      ? filedShowConfig[0].sAssignField
      : "";
    const sqlDropDownData = await getSqlDropDownData(
      sModelsId,
      name,
      filedShowConfig[0]
    );
    /* 根据sName得到过滤数据 */
    const dropdownData = sqlDropDownData.dropDownData;
    const filterDataIndex = dropdownData.findIndex(
      item =>
        item.sId === sId ||
        (commonUtils.isNotEmptyObject(item.sNId) && item.sNId === sId)
    );
    if (filterDataIndex > -1) {
      if (
        name !== "master" &&
        commonUtils.isNotEmptyObject(tableSelectedRowKeys)
      ) {
        const newCopyTo = {};
        const iIndex = tableNewData.findIndex(
          item => item.sId === tableSelectedRowKeys.toString()
        );
        newCopyTo.master = masterData;
        newCopyTo.slave = tableNewData[iIndex];
        let slaveRow = {};
        slaveRow = {
          ...tableNewData[iIndex],
          ...commonFunc.getAssignFieldValue(
            AssignField,
            dropdownData[filterDataIndex],
            newCopyTo
          )
        }; // 取赋值字段
        slaveRow.handleType = commonUtils.isEmpty(slaveRow.handleType)
          ? "update"
          : slaveRow.handleType;
        if (sName === "sProductId" || sName === "sProductName") {
          slaveRow.sProductInfo = "";
        }
        tableNewData[iIndex] = slaveRow;

        /* 套装工单、报价单、工艺卡的从表, 点击newRecord后 回带控制表合版数据 */
        const addState = {};
        if (
          formRoute &&
          formRoute.includes("PackTableTree") &&
          name === "slave"
        ) {
          const { controlData } = state;
          let { packData } = state;
          if (commonUtils.isEmptyArr(packData)) {
            packData = [];
          }
          if (controlData.length === 1) {
            const controlRow = controlData[0];
            const iIndex = packData.findIndex(
              item => item.sControlId === controlRow.sId
            );
            if (iIndex > -1) {
              const packFilterData = packData.filter(
                item => item.sControlId === controlRow.sId
              );
              if (commonUtils.isNotEmptyArr(packFilterData)) {
                packFilterData.forEach((itemPack, index) => {
                  let packDataRow = itemPack;
                  const sControlId = controlRow.sControlId;
                  packDataRow.sControlId = controlRow.sId;
                  packDataRow.sSlaveId = slaveRow.sId;
                  packDataRow.sProductId = slaveRow.sProductId; /* 产品id */
                  packDataRow.sCustomerId = slaveRow.sCustomerId; /* 客户id */
                  packDataRow.sCustomerName =
                    slaveRow.sCustomerName; /* 客户名称 */
                  packDataRow.sProductName =
                    slaveRow.sProductName; /* 产品名称 */
                  packDataRow.sProductNo = slaveRow.sProductNo; /* 产品编号 */
                  packDataRow.dCombineQty = 1;
                  packData[index] = { ...packData[index], ...packDataRow };
                  if (commonUtils.isNotEmptyObject(packData[index])) {
                    const {
                      sId,
                      sProductNo,
                      dProductQty,
                      dCombineQty,
                      dFactProductQty,
                      sCombinePartsName
                    } = packData[0];
                    const tableCombineSelectedData = [];
                    const jsonObj = {};
                    jsonObj.sId = sId;
                    jsonObj.sProductNo = sProductNo; /* 产品编号 */
                    jsonObj.dCombineQty = commonUtils.isNotEmptyNumber(
                      dCombineQty
                    )
                      ? dCombineQty
                      : 0; /* 排版数 */
                    jsonObj.dProductQty = commonUtils.isNotEmptyNumber(
                      dProductQty
                    )
                      ? dProductQty
                      : 0; /* 生产数 */
                    jsonObj.dFactProductQty = commonUtils.isNotEmptyNumber(
                      dFactProductQty
                    )
                      ? dFactProductQty
                      : 0; /* 实际生产数 */
                    jsonObj.sCombinePartsName = sCombinePartsName; /* 合版部件名称 */
                    tableCombineSelectedData.push(jsonObj);
                    const sCombinedMemo = commonUtils.isNotEmptyArr(
                      tableCombineSelectedData
                    )
                      ? JSON.stringify(tableCombineSelectedData)
                      : ""; /* JSON对象转换为字符串存放到合版信息中 */
                    controlRow.sCombinedMemo = commonUtils.isNotEmptyObject(
                      sCombinedMemo
                    )
                      ? sCombinedMemo
                      : "合版信息";
                    controlRow.handleType = commonUtils.isEmpty(
                      controlRow.handleType
                    )
                      ? "update"
                      : controlRow.handleType;
                    controlData[0] = { ...controlData, ...controlRow };
                  }
                });
                addState.packData = packData;
                addState.controlData = controlData;
              }
            }
          }
        }

        dispatch(["saveState", { [`${name}Data`]: tableNewData, ...addState }]);
      } else {
        /* 主表赋值 */
        const changeValue = commonFunc.getAssignFieldValue(
          AssignField,
          dropdownData[filterDataIndex]
        );
        const masterNewData = { ...masterData, ...changeValue }; // 取赋值字段
        const sFieldName = sName;
        const addState = {};
        if (
          sFieldName === "sCustomerId" ||
          sFieldName === "sCustomerNo" ||
          sFieldName === "sCustomerName" ||
          sFieldName === "sSupplyId" ||
          sFieldName === "sSupplyNo" ||
          sFieldName === "sSupplyName" ||
          sFieldName === "sWareHouseId" ||
          sFieldName === "sWareHouseNo" ||
          sFieldName === "sWareHouseName" ||
          sFieldName === "tDeliverDate"
        ) {
          const slaveDataNew = [];
          for (const item of slaveData) {
            let tableDataRow =
              (sFieldName === "sWareHouseId" ||
                sFieldName === "sWareHouseNo" ||
                sFieldName === "sWareHouseName") &&
                sModelsType.includes("materialsStock/productionmaterialsadjust")
                ? { ...item }
                : { ...item, [sFieldName]: changeValue[sFieldName] };
            if (
              sFieldName === "sCustomerId" ||
              sFieldName === "sCustomerNo" ||
              sFieldName === "sCustomerName" ||
              sFieldName === "sSupplyId" ||
              sFieldName === "sSupplyNo" ||
              sFieldName === "sSupplyName"
            ) {
              tableDataRow.sTaxId = changeValue.sTaxId;
              tableDataRow.sTaxNo = changeValue.sTaxNo;
              tableDataRow.sTaxName = changeValue.sTaxName;
              tableDataRow.dTaxRate = changeValue.dTaxRate;
              tableDataRow.handleType = commonUtils.isEmpty(
                tableDataRow.handleType
              )
                ? "update"
                : tableDataRow.handleType;
              const models =
                sModelsType.includes("sales/") ||
                  sModelsType.includes("manufacture/") ||
                  sModelsType.includes("productStock/")
                  ? "Product"
                  : "Materials";

              tableDataRow = commonBusiness.getCalculateAllMoney(
                app,
                models,
                "sTaxId",
                masterData,
                tableDataRow
              );
              let dMaterialsMoney = "";
              if (sModelsType.includes("outside/")) {
                /* 工序发外 */
                let sComputeId = "";
                const sSupplyId = changeValue.sSupplyId;
                const sProcessId = tableDataRow.sProcessId;
                /* 根据客户id,工序id获取公式ID */
                if (
                  commonUtils.isNotEmptyObject(sSupplyId) &&
                  commonUtils.isNotEmptyObject(sProcessId)
                ) {
                  sComputeId = await commonBusiness.getOutSideProcessFormula({
                    token,
                    sModelsId,
                    sSupplyId,
                    sProcessId
                  });
                  if (commonUtils.isNotEmptyObject(sComputeId)) {
                    dMaterialsMoney = await commonBusiness.getFormulaValue({
                      token,
                      sModelsId,
                      masterData,
                      tableDataRow,
                      sComputeId
                    });
                    tableDataRow.dMaterialsMoney = dMaterialsMoney;
                    tableDataRow = commonBusiness.getCalculateMoney(
                      app,
                      masterData,
                      tableDataRow,
                      "Materials"
                    );
                  }
                }
              }
            }
            if (
              (sFieldName === "sWareHouseId" ||
                sFieldName === "sWareHouseNo" ||
                sFieldName === "sWareHouseName") &&
              !sModelsType.includes("materialsStock/productionmaterialsadjust")
            ) {
              tableDataRow.sWareHouseId = changeValue.sWareHouseId;
              tableDataRow.sWareHouseNo = changeValue.sWareHouseNo;
              tableDataRow.sWareHouseName = changeValue.sWareHouseName;
              tableDataRow.sLocationId = changeValue.sLocationId;
              tableDataRow.sLocationNo = changeValue.sLocationNo;
              tableDataRow.sLocationName = changeValue.sLocationName;
              tableDataRow.sWareHouseLocationId =
                changeValue.sWareHouseLocationId;
              tableDataRow.sWareHouseLocationNo =
                changeValue.sWareHouseLocationNo;
              tableDataRow.sWareHouseLocationName =
                changeValue.sWareHouseLocationName;
              tableDataRow.handleType = commonUtils.isEmpty(
                tableDataRow.handleType
              )
                ? "update"
                : tableDataRow.handleType;
            }
            slaveDataNew.push(tableDataRow);
          }
          addState.slaveData = slaveDataNew;
          // props.onSaveState({ slaveData: slaveDataNew });
        }
        dispatch([
          "saveState",
          { [`${name}Data`]: masterNewData, ...addState }
        ]);
      }
    }
  };

  /**   sql下拉新增处理   */
  const handleSqlDropDownNewRecord = async (showConfig, name) => {
    const {
      [`${name}SelectedRowKeys`]: tableSelectedRowKeys,
      [`${name}Data`]: tableNewData,
      masterData,
      formSrcRoute
    } = state;
    /*   待用数据声明   */
    const sTabId = props.app.currentPane.key; /*   当前标签页TabId   */
    /*   接口地址   */
    const sNameUrl = `${commonConfig.server_host}gdsmodule/getGdsmoduleById/${showConfig.sActiveId
      }?sModelsId=${showConfig.sActiveId}&sName=${formSrcRoute}`;
    const CallBackRecord = handleCallBackRecord; /* 字段名，主从表，字段名 */
    /*  newRecord时，如果是新增产品，则要带客户过去 */
    const addStata = {};
    for (const each of props.app.panes) {
      each.notCurrentPane = true;
    }
    if (
      commonUtils.isNotEmptyObject(showConfig) &&
      showConfig.sName === "sProductName"
    ) {
      if (
        name !== "master" &&
        commonUtils.isNotEmptyObject(tableSelectedRowKeys)
      ) {
        const iIndex = tableNewData.findIndex(
          item => item.sId === tableSelectedRowKeys.toString()
        );
        const newData = tableNewData[iIndex];
        addStata.sCustomerId = newData.sCustomerId;
        addStata.sCustomerNo = newData.sCustomerNo;
        addStata.sCustomerName = newData.sCustomerName;
        if (commonUtils.isEmptyObject(addStata.sCustomerId)) {
          /* 新增产品时，看客户在从表还是主表。如果不在从表，那看是否在主表 */
          addStata.sCustomerId = masterData.sCustomerId;
          addStata.sCustomerNo = masterData.sCustomerNo;
          addStata.sCustomerName = masterData.sCustomerName;
        }
      }
    }
    /*   接口参数   */
    const payload = {
      url: sNameUrl,
      sParentId: sTabId,
      classifyOption: "add",
      newRecordFlag: `NewRecord_${sTabId}` /* newRecord当前字段 */,
      newRecordRelation: addStata /* newRecord 关联字段，如新增产品，带客户信息 */,
      newRecordMethod: CallBackRecord.bind(
        this,
        showConfig.sName,
        name
      ) /* newRecord当前字段 */
    };
    /*   调用接口   */
    props.dispatch({ type: "content/onRouter", payload });
  };

  /** 修改主表数据 */
  const handleMasterChange = (
    name,
    sFieldName,
    changeValue,
    sId,
    dropDownData,
    isWait,
    masterDataNew
  ) => {
    const { [`${name}Data`]: masterDataOld } = state;
    const {
      sModelsId,
      [`${name}Config`]: masterConfig = {},
      slaveConfig,
      slave0Config,
      slave1Config,
      slave2Config,
      slave3Config,
      slave4Config,
      slave5Config
    } = state;
    const addState = {};
    let masterData =
      masterDataNew === undefined
        ? masterDataOld === undefined
          ? {}
          : masterDataOld
        : masterDataNew;
    let { handleType } = masterData;
    handleType = commonUtils.isEmpty(handleType) ? "update" : handleType;
    if (sFieldName.substring(0, 1).toLowerCase() === "c") {
      const sAllField = sFieldName.substring(1, sFieldName.length);
      const allField = sAllField.split("_");
      const value = changeValue[sFieldName];
      allField.forEach((item, iArr) => {
        if (value.length > iArr) {
          changeValue[item] = value[iArr];
        }
      });
    }
    const bClearSelectedRowKeys = location.pathname.includes("commonList")
      ? false
      : true; /* 是否清除从表选择行 */
    if (
      !commonUtils.isEmpty(masterConfig.gdsconfigformslave) &&
      commonUtils.isNotEmptyArr(masterConfig.gdsconfigformslave) &&
      !commonUtils.isEmpty(sFieldName)
    ) {
      masterConfig.gdsconfigformslave
        .filter(
          item =>
            !commonUtils.isEmpty(item.sSqlCondition) &&
            !commonUtils.isEmpty(item.sChineseDropDown) &&
            (item.sChineseDropDown.includes(`#${sFieldName}`) ||
              item.sChineseDropDown.includes(`*${sFieldName}`)) &&
            (item.sSqlCondition.includes(sFieldName) ||
              item.sSqlCondition.includes(sFieldName.replace("Name", "Id")))
        )
        .forEach(item => {
          commonUtils.setStoreDropDownData(sModelsId, name, item.sName, []);
        });
      if (commonUtils.isNotEmptyObject(slaveConfig)) {
        slaveConfig.gdsconfigformslave
          .filter(
            item =>
              !commonUtils.isEmpty(item.sSqlCondition) &&
              !commonUtils.isEmpty(item.sChineseDropDown) &&
              (item.sChineseDropDown.includes(`#${sFieldName}`) ||
                item.sChineseDropDown.includes(`*${sFieldName}`)) &&
              (item.sSqlCondition.includes(`master.${sFieldName}`) ||
                item.sSqlCondition.includes(sFieldName.replace("Name", "Id")))
          )
          .forEach(item => {
            commonUtils.setStoreDropDownData(
              sModelsId,
              "slave",
              item.sName,
              []
            );
            if (bClearSelectedRowKeys) {
              addState.slaveSelectedRowKeys = [];
            }
          });
      }
      if (commonUtils.isNotEmptyObject(slave0Config)) {
        slave0Config.gdsconfigformslave
          .filter(
            item =>
              !commonUtils.isEmpty(item.sSqlCondition) &&
              !commonUtils.isEmpty(item.sChineseDropDown) &&
              (item.sChineseDropDown.includes(`#${sFieldName}`) ||
                item.sChineseDropDown.includes(`*${sFieldName}`)) &&
              (item.sSqlCondition.includes(`master.${sFieldName}`) ||
                item.sSqlCondition.includes(sFieldName.replace("Name", "Id")))
          )
          .forEach(item => {
            commonUtils.setStoreDropDownData(
              sModelsId,
              "slave0",
              item.sName,
              []
            );
            if (bClearSelectedRowKeys) {
              addState.slave0SelectedRowKeys = [];
            }
          });
      }
      if (commonUtils.isNotEmptyObject(slave1Config)) {
        slave1Config.gdsconfigformslave
          .filter(
            item =>
              !commonUtils.isEmpty(item.sSqlCondition) &&
              !commonUtils.isEmpty(item.sChineseDropDown) &&
              (item.sChineseDropDown.includes(`#${sFieldName}`) ||
                item.sChineseDropDown.includes(`*${sFieldName}`)) &&
              (item.sSqlCondition.includes(`master.${sFieldName}`) ||
                item.sSqlCondition.includes(sFieldName.replace("Name", "Id")))
          )
          .forEach(item => {
            commonUtils.setStoreDropDownData(
              sModelsId,
              "slave1",
              item.sName,
              []
            );
            if (bClearSelectedRowKeys) {
              addState.slave1SelectedRowKeys = [];
            }
          });
      }
      if (commonUtils.isNotEmptyObject(slave2Config)) {
        slave2Config.gdsconfigformslave
          .filter(
            item =>
              !commonUtils.isEmpty(item.sSqlCondition) &&
              !commonUtils.isEmpty(item.sChineseDropDown) &&
              (item.sChineseDropDown.includes(`#${sFieldName}`) ||
                item.sChineseDropDown.includes(`*${sFieldName}`)) &&
              (item.sSqlCondition.includes(`master.${sFieldName}`) ||
                item.sSqlCondition.includes(sFieldName.replace("Name", "Id")))
          )
          .forEach(item => {
            commonUtils.setStoreDropDownData(
              sModelsId,
              "slave2",
              item.sName,
              []
            );
            if (bClearSelectedRowKeys) {
              addState.slave2SelectedRowKeys = [];
            }
          });
      }
      if (commonUtils.isNotEmptyObject(slave3Config)) {
        slave3Config.gdsconfigformslave
          .filter(
            item =>
              !commonUtils.isEmpty(item.sSqlCondition) &&
              !commonUtils.isEmpty(item.sChineseDropDown) &&
              (item.sChineseDropDown.includes(`#${sFieldName}`) ||
                item.sChineseDropDown.includes(`*${sFieldName}`)) &&
              (item.sSqlCondition.includes(`master.${sFieldName}`) ||
                item.sSqlCondition.includes(sFieldName.replace("Name", "Id")))
          )
          .forEach(item => {
            commonUtils.setStoreDropDownData(
              sModelsId,
              "slave3",
              item.sName,
              []
            );
            if (bClearSelectedRowKeys) {
              addState.slave3SelectedRowKeys = [];
            }
          });
      }
      if (commonUtils.isNotEmptyObject(slave4Config)) {
        slave4Config.gdsconfigformslave
          .filter(
            item =>
              !commonUtils.isEmpty(item.sSqlCondition) &&
              !commonUtils.isEmpty(item.sChineseDropDown) &&
              (item.sChineseDropDown.includes(`#${sFieldName}`) ||
                item.sChineseDropDown.includes(`*${sFieldName}`)) &&
              (item.sSqlCondition.includes(`master.${sFieldName}`) ||
                item.sSqlCondition.includes(sFieldName.replace("Name", "Id")))
          )
          .forEach(item => {
            commonUtils.setStoreDropDownData(
              sModelsId,
              "slave4",
              item.sName,
              []
            );
            if (bClearSelectedRowKeys) {
              addState.slave4SelectedRowKeys = [];
            }
          });
      }
      if (commonUtils.isNotEmptyObject(slave5Config)) {
        slave5Config.gdsconfigformslave
          .filter(
            item =>
              !commonUtils.isEmpty(item.sSqlCondition) &&
              !commonUtils.isEmpty(item.sChineseDropDown) &&
              (item.sChineseDropDown.includes(`#${sFieldName}`) ||
                item.sChineseDropDown.includes(`*${sFieldName}`)) &&
              (item.sSqlCondition.includes(`master.${sFieldName}`) ||
                item.sSqlCondition.includes(sFieldName.replace("Name", "Id")))
          )
          .forEach(item => {
            commonUtils.setStoreDropDownData(
              sModelsId,
              "slave5",
              item.sName,
              []
            );
            if (bClearSelectedRowKeys) {
              addState.slave5SelectedRowKeys = [];
            }
          });
      }
      /* 字段输入时 根据规则 控制其他字段的显示与隐藏 */
      const iConfigIndex = masterConfig.gdsconfigformslave.findIndex(
        item => item.sName === sFieldName
      );
      if (iConfigIndex > -1) {
        const sFiledConfig = masterConfig.gdsconfigformslave[iConfigIndex];
        if (commonUtils.isNotEmptyObject(sFiledConfig)) {
          const tableDataRow = { ...masterData, ...changeValue, handleType };
          const sRulesJson = sFiledConfig.sButtonEnabled;
          if (
            commonUtils.isNotEmptyObject(sRulesJson) &&
            commonUtils.isJSON(sRulesJson)
          ) {
            const sRulesObjArr = JSON.parse(sRulesJson);
            if (commonUtils.isNotEmptyArr(sRulesObjArr)) {
              console.log("sRulesObjArr:", sRulesObjArr);
              sRulesObjArr.forEach(sRulesObj => {
                const {
                  showColumn,
                  hideColumn,
                  condition,
                  tbName,
                  sConfigName
                } = sRulesObj;
                console.log("tbName:", tbName,);
                /* 主表单表字段根据条件控制 其他字段的显示与隐藏 */
                if (commonUtils.isEmptyObject(tbName)) {
                  if (commonUtils.isNotEmptyArr(condition)) {
                    let flag = false;
                    for (const item of condition) {
                      const {
                        bFilterName,
                        bFilterCondition,
                        bFilterValue
                      } = item;
                      if (bFilterCondition === ">") {
                        if (tableDataRow[bFilterName] > bFilterValue) {
                          flag = true;
                        }
                      } else if (bFilterCondition === "=") {
                        if (tableDataRow[bFilterName] === bFilterValue) {
                          flag = true;
                        }
                      } else if (bFilterCondition === "<") {
                        if (tableDataRow[bFilterName] < bFilterValue) {
                          flag = true;
                        }
                      }
                    }
                    if (flag) {
                      if (commonUtils.isNotEmptyArr(showColumn)) {
                        for (const column of showColumn) {
                          const iShowIndex = masterConfig.gdsconfigformslave.findIndex(
                            item => item.sName === column
                          );
                          if (iShowIndex > -1) {
                            const sFiledObj =
                              masterConfig.gdsconfigformslave[iShowIndex];
                            if (commonUtils.isNotEmptyObject(sFiledObj)) {
                              if (
                                commonUtils.isNotEmptyObject(sConfigName) &&
                                sConfigName === "bControl"
                              ) {
                                masterConfig.gdsconfigformslave[
                                  iShowIndex
                                ].bControl = true; /* 控制字段bControl的显示与隐藏 */
                              } else {
                                masterConfig.gdsconfigformslave[
                                  iShowIndex
                                ].bVisible = true;
                              }
                            }
                          }
                        }
                      }
                      if (commonUtils.isNotEmptyArr(hideColumn)) {
                        for (const column of hideColumn) {
                          const iHideIndex = masterConfig.gdsconfigformslave.findIndex(
                            item => item.sName === column
                          );
                          if (iHideIndex > -1) {
                            if (
                              commonUtils.isNotEmptyObject(sConfigName) &&
                              sConfigName === "bControl"
                            ) {
                              masterConfig.gdsconfigformslave[
                                iHideIndex
                              ].bControl = true; /* 控制字段bControl的显示与隐藏 */
                            } else {
                              masterConfig.gdsconfigformslave[
                                iHideIndex
                              ].bVisible = false;
                            }
                          }
                        }
                      }
                      addState[`${name}Data`] = masterConfig;
                    }
                  }
                } else {
                  /* 主表字段根据条件控制 其他表格字段的显示与隐藏 */
                  const { [`${tbName}Config`]: tableConfig } = state;
                  // const { controlConfig: tableConfig } = state;
                  if (commonUtils.isNotEmptyObject(tableConfig)) {
                    if (commonUtils.isNotEmptyArr(condition)) {
                      let flag = false;
                      for (const item of condition) {
                        const {
                          bFilterName,
                          bFilterCondition,
                          bFilterValue
                        } = item;
                        if (bFilterCondition === ">") {
                          if (tableDataRow[bFilterName] > bFilterValue) {
                            flag = true;
                          }
                        } else if (bFilterCondition === "=") {
                          if (tableDataRow[bFilterName] === bFilterValue) {
                            flag = true;
                          }
                        } else if (bFilterCondition === "<") {
                          if (tableDataRow[bFilterName] < bFilterValue) {
                            flag = true;
                          }
                        }
                      }
                      if (flag) {
                        if (commonUtils.isNotEmptyArr(showColumn)) {
                          for (const column of showColumn) {
                            const iShowIndex = tableConfig.gdsconfigformslave.findIndex(
                              item => item.sName === column
                            );
                            if (iShowIndex > -1) {
                              const sFiledObj =
                                tableConfig.gdsconfigformslave[iShowIndex];
                              if (commonUtils.isNotEmptyObject(sFiledObj)) {
                                tableConfig.gdsconfigformslave[
                                  iShowIndex
                                ].bVisible = true;
                              }
                            }
                          }
                        }
                        if (commonUtils.isNotEmptyArr(hideColumn)) {
                          for (const column of hideColumn) {
                            const iHideIndex = tableConfig.gdsconfigformslave.findIndex(
                              item => item.sName === column
                            );
                            if (iHideIndex > -1) {
                              const sFiledObj =
                                tableConfig.gdsconfigformslave[iHideIndex];
                              if (commonUtils.isNotEmptyObject(sFiledObj)) {
                                tableConfig.gdsconfigformslave[
                                  iHideIndex
                                ].bVisible = false;
                              }
                            }
                          }
                        }
                        if (commonUtils.isNotEmptyObject(tableConfig)) {
                          const tableColumn = commonFunc.getHeaderConfig(
                            tableConfig
                          );
                          // addState.masterConfig = masterConfig;
                          // addState.controlConfig = tableConfig; /* 表格配置塞到addState中 */
                          // addState.controlColumn = tbColumn;
                          addState[`${tbName}Config`] = tableConfig;
                          addState[`${tbName}Column`] = tableColumn;
                        }
                      }
                    }
                  }
                }
              });
            }
          }
        }
      }
    }
    masterData = { ...masterData, ...changeValue, handleType };
    if (isWait) {
      return { [`${name}Data`]: masterData, ...addState }; // , sUseInfo: ''
    } else {
      dispatch(["saveState", { [`${name}Data`]: masterData, ...addState }]);
      return { [`${name}Data`]: masterData, ...addState };
    }
  };

  /** 表格数据更改 */
  const handleTableChange = async (
    name,
    sFieldName,
    changeValue,
    sId,
    dropDownData,
    isWait
  ) => {
    if (name.includes("master")) {
      return handleMasterChange(
        name,
        sFieldName,
        changeValue,
        sId,
        dropDownData,
        isWait
      );
    }

    const {
      [`${name}Data`]: tableData,
      [`${name}Config`]: tableConfig,
      sModelsId
    } = state;
    const iIndex = tableData.findIndex(item => item.sId === sId);
    let { handleType } = tableData[iIndex];
    handleType = commonUtils.isEmpty(handleType) ? "update" : handleType;
    if (sFieldName.substring(0, 1).toLowerCase() === "c") {
      const sAllField = sFieldName.substring(1, sFieldName.length);
      const allField = sAllField.split("_");
      const value = changeValue[sFieldName];
      allField.forEach((item, iArr) => {
        if (value.length > iArr) {
          changeValue[item] = value[iArr];
        }
      });
    }

    if (
      !commonUtils.isEmpty(tableConfig.gdsconfigformslave) &&
      commonUtils.isNotEmptyArr(tableConfig.gdsconfigformslave) &&
      !commonUtils.isEmpty(sFieldName)
    ) {
      tableConfig.gdsconfigformslave
        .filter(
          item =>
            !commonUtils.isEmpty(item.sSqlCondition) &&
            !commonUtils.isEmpty(item.sChineseDropDown) &&
            (item.sChineseDropDown.includes(`#${sFieldName}`) ||
              item.sChineseDropDown.includes(`*${sFieldName}`)) &&
            (item.sSqlCondition.includes(`master.${sFieldName}`) ||
              item.sSqlCondition.includes(sFieldName.replace("Name", "Id")))
        )
        .forEach(item => {
          commonUtils.setStoreDropDownData(sModelsId, "slave", item.sName, []);
        });

      const tableDataRowNew = {
        ...tableData[iIndex],
        ...changeValue,
        handleType
      };
      const tableDataAfter = commonBusiness.getKeyUpEvent(
        name,
        sFieldName,
        tableConfig,
        tableDataRowNew,
        tableDataRowNew,
        true
      );
      if (commonUtils.isNotEmptyObject(tableDataAfter)) {
        changeValue = { ...tableDataAfter };
      }
    }
    const models = name === 'materials' ? 'Materials' : ''
    let tableDataRow = { ...tableData[iIndex], ...changeValue, handleType }
    const { masterData } = state
    const { app } = props
    const { token } = app || {}
    tableDataRow = await handleMaterialsChange(tableDataRow, sModelsId, masterData, changeValue, sFieldName, app, token, models);
    console.log(tableDataRow, 'tableDataRow');
    if (isWait) {
      return tableDataRow;
    } else {
      const rowDataOld = JSON.parse(JSON.stringify(tableData[iIndex]));
      tableData[iIndex] = tableDataRow;
      handleSaveState(
        { [`${name}Data`]: tableData, sUseInfo: "" },
        nextProps => {
          costomPageFun({
            props: {
              ...nextProps,
              rowDataOld,
              onSaveState: handleSaveState,
              handleExecInstructSet
            },
            tableName: name,
            sFieldName,
            actionName: "mesTableChange"
          });
        }
      );
    }
  };
  // const handleMaterialsChange = async (tableDataRow, sModelsId, masterData, changeValue, sFieldName, app, token, models) => {
  //   const { sComputeId, sConversionComputeId, sReConversionComputeId } = tableDataRow;
  //   const sFormulaIdType = tableDataRow.bInverse ? 'sReComputeId' : 'sComputeId'; /* 正算、反算类型 */
  //   if (sFieldName === 'sMaterialsNo' || sFieldName === 'sMaterialsName' || sFieldName === 'dAuxiliaryQty' || sFieldName === 'dReelAuxiliaryQty' || sFieldName === 'dConversionQty' || sFieldName === 'sMaterialsStyle' || sFieldName === 'dProductQty') {
  //     if (sFieldName === 'dReelAuxiliaryQty') {
  //       if (tableDataRow.sMaterialsUnit === '吨' && tableDataRow.bReel && tableDataRow.dGramWeight > 0) {
  //         tableDataRow = commonBusiness.getMaterialsQty(app, { ...tableDataRow, sMaterialsStyle: tableDataRow.sReelMaterialsStyle }, 'dReelAuxiliaryQty', 'dMaterialsQty');
  //         tableDataRow.dAuxiliaryQty = tableDataRow.dMaterialsQty;
  //         tableDataRow.sMaterialsStyle = tableDataRow.sMaterialsStyle !== undefined && tableDataRow.sMaterialsStyle.split('*').length > 1 ? tableDataRow.sMaterialsStyle.split('*')[0] : tableDataRow.sMaterialsStyle;
  //         tableDataRow.sAuxiliaryUnit = tableDataRow.sMaterialsUnit;
  //       } else if (tableDataRow.sMaterialsUnit.toUpper() === 'M2' && tableDataRow.bReel) {
  //         tableDataRow = commonBusiness.getMaterialsQty(app, tableDataRow, 'dReelAuxiliaryQty', 'dMaterialsQty');
  //         tableDataRow.dAuxiliaryQty = tableDataRow.dReelAuxiliaryQty;
  //       } else {
  //         tableDataRow.dAuxiliaryQty = tableDataRow.dReelAuxiliaryQty;
  //       }
  //     }
  //     if (commonUtils.isEmpty(sComputeId) && sFieldName !== 'dConversionQty') {
  //       if (sFieldName === 'dProductQty') {
  //         tableDataRow = commonBusiness.getMaterialsQty(app, tableDataRow, 'dProductQty', 'dMaterialsQty');
  //       } else if (app.currentPane.sModelsType && app.currentPane.sModelsType.includes('outside/')) {
  //         tableDataRow = commonBusiness.getMaterialsQty(app, tableDataRow, 'dAuxiliaryQty', 'dMaterialsQty');
  //       } else {
  //         tableDataRow.dMaterialsQty = await commonBusiness.getFormulaValue({
  //           token, sModelsId, masterData, tableDataRow, sComputeId, sFormulaIdType,
  //         });
  //       }
  //     } else if (!commonUtils.isEmpty(sComputeId)) {
  //       tableDataRow.dMaterialsQty = await commonBusiness.getFormulaValue({
  //         token, sModelsId, masterData, tableDataRow, sComputeId,
  //       });
  //     }
  //     if (sFieldName !== 'dConversionQty' && !commonUtils.isEmpty(sConversionComputeId)) {
  //       tableDataRow.dConversionQty = await commonBusiness.getFormulaValue({
  //         token, sModelsId, masterData, tableDataRow, sComputeId: sConversionComputeId,
  //       });
  //     }
  //   } else if (sFieldName === 'dMaterialsQty') {
  //     const { sReComputeId } = tableDataRow;
  //     if (commonUtils.isEmpty(sReComputeId) && tableDataRow.bInverse) {
  //       if (app.currentPane.sModelsType && app.currentPane.sModelsType.includes('outside/')) {
  //         tableDataRow = commonBusiness.getAuxiliaryQty(app, tableDataRow, sFieldName, 'dAuxiliaryQty');
  //       } else {
  //         tableDataRow.dAuxiliaryQty = await commonBusiness.getFormulaValue({
  //           token, sModelsId, masterData, tableDataRow, sReComputeId, sFormulaIdType,
  //         });
  //       }
  //     } else if (tableDataRow.bInverse) {
  //       tableDataRow.dAuxiliaryQty = await commonBusiness.getFormulaValue({
  //         token, sModelsId, masterData, tableDataRow, sComputeId: sReComputeId,
  //       });
  //       if (commonUtils.isNotEmptyArr(tableDataRow.dAuxiliaryQty) && tableDataRow.dAuxiliaryQty !== 0) {
  //         tableDataRow.dProductQty = tableDataRow.dAuxiliaryQty;
  //       }
  //     }
  //     if (!commonUtils.isEmpty(sReConversionComputeId)) {
  //       tableDataRow.dConversionQty = await commonBusiness.getFormulaValue({
  //         token, sModelsId, masterData, tableDataRow, sComputeId: sReConversionComputeId,
  //       });
  //     }
  //   } else if (sFieldName === 'dAuxiliaryLossQty') {
  //     const tableDataRowNew = { ...tableDataRow, dAuxiliaryQty: tableDataRow.dAuxiliaryLossQty };
  //     if (commonUtils.isEmpty(sComputeId)) {
  //       // tableDataRow = commonBusiness.getMaterialsQty(app, tableDataRow, sFieldName, 'dLossQty');
  //       tableDataRow.dLossQty = await commonBusiness.getFormulaValue({
  //         token, sModelsId, masterData, tableDataRow: tableDataRowNew, sComputeId, sFormulaIdType,
  //       });
  //     } else {
  //       tableDataRow.dLossQty = await commonBusiness.getFormulaValue({
  //         token, sModelsId, masterData, tableDataRow: tableDataRowNew, sComputeId,
  //       });
  //     }
  //     if (!commonUtils.isEmpty(tableDataRow.dSrcSurplusAuxiliaryQty)) {
  //       tableDataRow.dAuxiliaryQty = tableDataRow.dSrcSurplusAuxiliaryQty - tableDataRow.dAuxiliaryLossQty;
  //       tableDataRow.dMaterialsQty = commonUtils.convertFixNum(tableDataRow.dSrcSurplusQty - tableDataRow.dLossQty, 6);
  //     }
  //   } else if (sFieldName === 'dLossQty') {
  //     const { sReComputeId } = tableDataRow;
  //     const tableDataRowNew = { ...tableDataRow, dMaterialsQty: tableDataRow.dLossQty };
  //     if (commonUtils.isEmpty(sReComputeId) && tableDataRow.bInverse) {
  //       // tableDataRow = commonBusiness.getAuxiliaryQty(app, tableDataRow, sFieldName, 'dAuxiliaryLossQty');
  //       tableDataRow.dAuxiliaryLossQty = await commonBusiness.getFormulaValue({
  //         token, sModelsId, masterData, tableDataRow: tableDataRowNew, sReComputeId, sFormulaIdType,
  //       });
  //     } else {
  //       tableDataRow.dAuxiliaryLossQty = await commonBusiness.getFormulaValue({
  //         token, sModelsId, masterData, tableDataRow: tableDataRowNew, sComputeId: sReComputeId,
  //       });
  //     }
  //     if (!commonUtils.isEmpty(tableDataRow.dSrcSurplusAuxiliaryQty)) {
  //       tableDataRow.dAuxiliaryQty = tableDataRow.dSrcSurplusAuxiliaryQty - tableDataRow.dAuxiliaryLossQty;
  //       tableDataRow.dMaterialsQty = tableDataRow.dSrcSurplusQty - tableDataRow.dLossQty;
  //     }
  //   } else if (sFieldName === 'sProcessId' || sFieldName === 'sProcessNo' || sFieldName === 'sProcessName') {
  //     const sProcessId = changeValue.sProcessId;
  //     const url = `${commonConfig.server_host}process/outsideprocess?sModelsId=${sModelsId}&sProcessId=${sProcessId}`;
  //     const dataReturn = (await commonServices.getService(token, url)).data;
  //     if (dataReturn.code === 1) {
  //       if (commonUtils.isNotEmptyArr(dataReturn.dataset.rows)) {
  //         tableDataRow.dMaterialsPrice = dataReturn.dataset.rows[0].dMaterialsPrice;
  //       }
  //       tableDataRow = commonBusiness.getCalculateAllMoney(app, models, 'dMaterialsPrice', masterData, tableDataRow);
  //     }
  //   }
  //   return tableDataRow;
  // }
  const handleMaterialsChange = async (tableDataRow, sModelsId, masterData, changeValue, sFieldName, app, token, models) => {
    const { sComputeId, sConversionComputeId, sReConversionComputeId } = tableDataRow;
    // dAuxiliaryQty
    const sFormulaIdType = tableDataRow.bInverse ? 'sReComputeId' : 'sComputeId'; /* 正算、反算类型 */
    if (sFieldName === 'sMaterialsNo' || sFieldName === 'sMaterialsName' || sFieldName === 'dAuxiliaryQty' || sFieldName === 'dReelAuxiliaryQty' || sFieldName === 'dConversionQty' || sFieldName === 'sMaterialsStyle' || sFieldName === 'dProductQty') {
      if (sFieldName === 'dReelAuxiliaryQty') {
        if (tableDataRow.sMaterialsUnit === '吨' && tableDataRow.bReel && tableDataRow.dGramWeight > 0) {
          tableDataRow = commonBusiness.getMaterialsQty(app, { ...tableDataRow, sMaterialsStyle: tableDataRow.sReelMaterialsStyle }, 'dReelAuxiliaryQty', 'dMaterialsQty');
          tableDataRow.dAuxiliaryQty = tableDataRow.dMaterialsQty;
          tableDataRow.sMaterialsStyle = tableDataRow.sMaterialsStyle !== undefined && tableDataRow.sMaterialsStyle.split('*').length > 1 ? tableDataRow.sMaterialsStyle.split('*')[0] : tableDataRow.sMaterialsStyle;
          tableDataRow.sAuxiliaryUnit = tableDataRow.sMaterialsUnit;
        } else if (tableDataRow.sMaterialsUnit.toUpper() === 'M2' && tableDataRow.bReel) {
          tableDataRow = commonBusiness.getMaterialsQty(app, tableDataRow, 'dReelAuxiliaryQty', 'dMaterialsQty');
          tableDataRow.dAuxiliaryQty = tableDataRow.dReelAuxiliaryQty;
        } else {
          tableDataRow.dAuxiliaryQty = tableDataRow.dReelAuxiliaryQty;
        }
      }
      if (commonUtils.isEmpty(sComputeId) && sFieldName !== 'dConversionQty') {
        if (sFieldName === 'dProductQty') {
          tableDataRow = commonBusiness.getMaterialsQty(app, tableDataRow, 'dProductQty', 'dMaterialsQty');
        } else if (app.currentPane.sModelsType && app.currentPane.sModelsType.includes('outside/')) {
          tableDataRow = commonBusiness.getMaterialsQty(app, tableDataRow, 'dAuxiliaryQty', 'dMaterialsQty');
        } else {
          tableDataRow.dMaterialsQty = await commonBusiness.getFormulaValue({
            token, sModelsId, masterData, tableDataRow, sComputeId, sFormulaIdType,
          });
        }
      } else if (!commonUtils.isEmpty(sComputeId)) {
        tableDataRow.dMaterialsQty = await commonBusiness.getFormulaValue({
          token, sModelsId, masterData, tableDataRow, sComputeId,
        });
      }
      if (sFieldName !== 'dConversionQty' && !commonUtils.isEmpty(sConversionComputeId)) {
        tableDataRow.dConversionQty = await commonBusiness.getFormulaValue({
          token, sModelsId, masterData, tableDataRow, sComputeId: sConversionComputeId,
        });
      }
    } else if (sFieldName === 'dMaterialsQty') {
      const { sReComputeId } = tableDataRow;
      if (commonUtils.isEmpty(sReComputeId) && tableDataRow.bInverse) {
        if (app.currentPane.sModelsType && app.currentPane.sModelsType.includes('outside/')) {
          tableDataRow = commonBusiness.getAuxiliaryQty(app, tableDataRow, sFieldName, 'dAuxiliaryQty');
        } else {
          tableDataRow.dAuxiliaryQty = await commonBusiness.getFormulaValue({
            token, sModelsId, masterData, tableDataRow, sReComputeId, sFormulaIdType,
          });
        }
      } else if (tableDataRow.bInverse) {
        tableDataRow.dAuxiliaryQty = await commonBusiness.getFormulaValue({
          token, sModelsId, masterData, tableDataRow, sComputeId: sReComputeId,
        });
        if (commonUtils.isNotEmptyArr(tableDataRow.dAuxiliaryQty) && tableDataRow.dAuxiliaryQty !== 0) {
          tableDataRow.dProductQty = tableDataRow.dAuxiliaryQty;
        }
      }
      if (!commonUtils.isEmpty(sReConversionComputeId)) {
        tableDataRow.dConversionQty = await commonBusiness.getFormulaValue({
          token, sModelsId, masterData, tableDataRow, sComputeId: sReConversionComputeId,
        });
      }
    } else if (sFieldName === 'dAuxiliaryLossQty') {
      const tableDataRowNew = { ...tableDataRow, dAuxiliaryQty: tableDataRow.dAuxiliaryLossQty };
      if (commonUtils.isEmpty(sComputeId)) {
        // tableDataRow = commonBusiness.getMaterialsQty(app, tableDataRow, sFieldName, 'dLossQty');
        tableDataRow.dLossQty = await commonBusiness.getFormulaValue({
          token, sModelsId, masterData, tableDataRow: tableDataRowNew, sComputeId, sFormulaIdType,
        });
      } else {
        tableDataRow.dLossQty = await commonBusiness.getFormulaValue({
          token, sModelsId, masterData, tableDataRow: tableDataRowNew, sComputeId,
        });
      }
      if (!commonUtils.isEmpty(tableDataRow.dSrcSurplusAuxiliaryQty)) {
        tableDataRow.dAuxiliaryQty = tableDataRow.dSrcSurplusAuxiliaryQty - tableDataRow.dAuxiliaryLossQty;
        tableDataRow.dMaterialsQty = commonUtils.convertFixNum(tableDataRow.dSrcSurplusQty - tableDataRow.dLossQty, 6);
      }
    } else if (sFieldName === 'dLossQty') {
      const { sReComputeId } = tableDataRow;
      const tableDataRowNew = { ...tableDataRow, dMaterialsQty: tableDataRow.dLossQty };
      if (commonUtils.isEmpty(sReComputeId) && tableDataRow.bInverse) {
        // tableDataRow = commonBusiness.getAuxiliaryQty(app, tableDataRow, sFieldName, 'dAuxiliaryLossQty');
        tableDataRow.dAuxiliaryLossQty = await commonBusiness.getFormulaValue({
          token, sModelsId, masterData, tableDataRow: tableDataRowNew, sReComputeId, sFormulaIdType,
        });
      } else {
        tableDataRow.dAuxiliaryLossQty = await commonBusiness.getFormulaValue({
          token, sModelsId, masterData, tableDataRow: tableDataRowNew, sComputeId: sReComputeId,
        });
      }
      if (!commonUtils.isEmpty(tableDataRow.dSrcSurplusAuxiliaryQty)) {
        tableDataRow.dAuxiliaryQty = tableDataRow.dSrcSurplusAuxiliaryQty - tableDataRow.dAuxiliaryLossQty;
        tableDataRow.dMaterialsQty = tableDataRow.dSrcSurplusQty - tableDataRow.dLossQty;
      }
    } else if (sFieldName === 'sProcessId' || sFieldName === 'sProcessNo' || sFieldName === 'sProcessName') {
      const sProcessId = changeValue.sProcessId;
      const url = `${commonConfig.server_host}process/outsideprocess?sModelsId=${sModelsId}&sProcessId=${sProcessId}`;
      const dataReturn = (await commonServices.getService(token, url)).data;
      if (dataReturn.code === 1) {
        if (commonUtils.isNotEmptyArr(dataReturn.dataset.rows)) {
          tableDataRow.dMaterialsPrice = dataReturn.dataset.rows[0].dMaterialsPrice;
        }
        tableDataRow = commonBusiness.getCalculateAllMoney(app, models, 'dMaterialsPrice', masterData, tableDataRow);
      }
    }
    return tableDataRow;
  }
  const handleFilterDropDownData = (dropDownData, showConfig, name, record) => {
    if (!commonUtils.isEmptyArr(dropDownData)) {
      const conditon = showConfig.sSqlCondition.split(",");
      let orTableName;
      let orFieldName;
      let orFieldNameFilter;
      let orValue;
      conditon.forEach(item => {
        if (item.indexOf(".") > -1) {
          const tableName = item.split(".")[0];
          const fieldName = item.split(".")[1];
          const fieldNameFilter = item.split(".")[2];
          if (tableName.indexOf("|") > -1) {
            orTableName = tableName.replace("|", "");
            orFieldName = fieldName;
            orFieldNameFilter = fieldNameFilter;
            if (orFieldName.indexOf("&") > -1) {
              orValue = orFieldName.replace("&", "");
            } else if (!commonUtils.isEmpty(orFieldNameFilter)) {
              if (name === orTableName && !commonUtils.isEmpty(record)) {
                const data = record;
                orValue = data[orFieldName];
              } else {
                const data = state[`${orTableName}Data`];
                const selectedRowKeys = state[`${orTableName}SelectedRowKeys`];
                if (typeof data === "object" && data.constructor === Object) {
                  orValue = data[orFieldName];
                } else if (commonUtils.isNotEmptyArr(selectedRowKeys)) {
                  const iIndex = data.findIndex(
                    itemData => itemData.sId === selectedRowKeys[0]
                  );
                  if (iIndex > -1) {
                    orValue = data[iIndex][orFieldName];
                  }
                } else if (commonUtils.isNotEmptyArr(data)) {
                  orValue = data[0][orFieldName];
                }
              }
            }
            orValue = orValue.toString();
          } else if (!commonUtils.isEmpty(orFieldName)) {
            // master.sId 作为参数   control.sId.sControlId 作为filterDropdown过滤参数
            if (!commonUtils.isEmpty(fieldNameFilter)) {
              if (name === tableName && !commonUtils.isEmpty(record)) {
                const data = record;
                dropDownData = dropDownData.filter(
                  itemDrop =>
                    itemDrop[fieldNameFilter] === data[fieldName] ||
                    itemDrop[orFieldNameFilter] === orValue
                );
              } else {
                const data = state[`${tableName}Data`];
                const selectedRowKeys = state[`${tableName}SelectedRowKeys`];
                if (typeof data === "object" && data.constructor === Object) {
                  dropDownData = dropDownData.filter(
                    itemDrop =>
                      itemDrop[fieldNameFilter] === data[fieldName] ||
                      itemDrop[orFieldNameFilter] === orValue
                  );
                } else if (commonUtils.isNotEmptyArr(selectedRowKeys)) {
                  const iIndex = data.findIndex(
                    itemData => itemData.sId === selectedRowKeys[0]
                  );
                  if (iIndex > -1) {
                    dropDownData = dropDownData.filter(
                      itemDrop =>
                        itemDrop[fieldNameFilter] === data[iIndex][fieldName] ||
                        itemDrop[orFieldNameFilter] === orValue
                    );
                  }
                } else if (commonUtils.isNotEmptyArr(data)) {
                  dropDownData = dropDownData.filter(
                    itemDrop =>
                      itemDrop[fieldNameFilter] === data[0][fieldName] ||
                      itemDrop[orFieldNameFilter] === orValue
                  );
                }
              }
            }
          } else if (!commonUtils.isEmpty(fieldNameFilter)) {
            if (name === tableName && !commonUtils.isEmpty(record)) {
              const data = record;
              dropDownData = dropDownData.filter(
                itemDrop => itemDrop[fieldNameFilter] === data[fieldName]
              );
            } else {
              const data = state[`${tableName}Data`];
              const selectedRowKeys = state[`${tableName}SelectedRowKeys`];
              if (typeof data === "object" && data.constructor === Object) {
                dropDownData = dropDownData.filter(
                  itemDrop => itemDrop[fieldNameFilter] === data[fieldName]
                );
              } else if (commonUtils.isNotEmptyArr(selectedRowKeys)) {
                const iIndex = data.findIndex(
                  itemData =>
                    (commonUtils.isEmpty(itemData.sSlaveId)
                      ? itemData.sId
                      : itemData.sSlaveId) === selectedRowKeys[0]
                );
                if (iIndex > -1) {
                  dropDownData = dropDownData.filter(
                    itemDrop =>
                      itemDrop[fieldNameFilter] === data[iIndex][fieldName]
                  );
                }
              } else if (commonUtils.isNotEmptyArr(data)) {
                dropDownData = dropDownData.filter(
                  itemDrop => itemDrop[fieldNameFilter] === data[0][fieldName]
                );
              }
            }
          }
        }
      });
    }

    return dropDownData;
  };

  // 处理接口报错
  const getServiceError = returnData => {
    const { msg } = returnData;
    if (props.dispatch) {
      props.dispatch({ type: "app/throwErrorMes", payload: returnData });
    } else {
      message.destroy();
      message.error(msg, 5);
    }
  };

  // 调用通用过程
  const handleProcedureCall = async (params, iFlag) => {
    const {
      btnConfig = {}, // 按钮配置
      sValue = {}, // 额外参数
      tableData: tableDataSelected, // 传过来的数据
      faceData = {}, // 人脸数据
      onSuccess,
      onConfirm,
      onError,
      nextProps
    } = params;

    const currentState = nextProps || state;

    // 加入mes通用参数
    const { app } = props;
    const FriendlyReminder = commonFunc.showLocalMessage(props, 'FriendlyReminder', '温馨提示');
    const { tableNameCompareJson = {} } = currentState;
    const {
      sMachineNameSId: sMachineGuid,
      sTeamNameSId: sTeamGuid,
      sShift
    } = app;
    const commonData = {
      sMachineGuid,
      sTeamGuid,
      sShift
    };

    const { sButtonParam } = btnConfig;
    const btn = commonUtils.convertStrToObj(sButtonParam, {});
    if (commonUtils.isEmptyObject(btn)) {
      onSuccess && onSuccess(false);
      return;
    }
    const { sproName: sProName, inMap, sTableName, staticData = {} } = btn;

    const inParams = [];
    const arr = {};

    if (inMap) {
      const inlist = inMap.split(",");
      inlist.forEach(item => {
        const [
          tableNameOld,
          sFieldName,
          sFieldNameNew = sFieldName
        ] = item.split(".");

        const tableName = tableNameCompareJson[tableNameOld] || tableNameOld;
        if (!tableName) return;
        if (!arr[tableName]) {
          arr[tableName] = [];
        }
        arr[tableName].push({ sFieldName, sFieldNameNew });
      });
    }

    // 拼接params参数
    Object.keys(arr).forEach(tableName => {
      const addState = { key: tableName };
      if (tableName.includes("master")) {
        const { [`${tableName}Data`]: tableData = {} } = currentState;
        const allValue = [];
        const value = { ...commonData, ...staticData, ...faceData };
        arr[tableName].forEach(({ sFieldName, sFieldNameNew }) => {
          value[`${sFieldNameNew}`] = tableData[`${sFieldName}`];
        });
        allValue.push(value);
        addState.value = allValue;
        inParams.push(addState);
      } else {
        let filterData = tableDataSelected;
        if (commonUtils.isEmptyArr(filterData)) {
          if (
            [
              "userinfo",
              "currentSelectedMachineTask",
              "currentStartWorkMachineTask",
              "currentWorkOrderInfo"
            ].includes(tableName)
          ) {
            // 如果是全局变量
            const globalData = commonUtils.getAppData("globalData");
            const tempProps = {
              userinfo: app.userinfo,
              currentSelectedMachineTask: globalData.currentSelectedMachineTask,
              currentStartWorkMachineTask:
                globalData.currentStartWorkMachineTask,
              currentWorkOrderInfo: globalData.currentWorkOrderInfo
            };
            filterData = [tempProps[tableName]];
          } else {
            // 如果不是全局变量
            const {
              [`${tableName}Data`]: tableData = [],
              [`${tableName}SelectedRowKeys`]: selectedRowKeys = []
            } = currentState;
            if (selectedRowKeys.length === 0 && nextProps) {
              filterData = tableData;
            } else {
              const iIndex = arr[tableName].findIndex(
                item => item.sFieldNameNew === "*"
              );
              if (iIndex > -1) {
                filterData = tableData;
              } else {
                filterData = tableData.filter(
                  item =>
                    true &&
                    (selectedRowKeys.includes(item.sId) ||
                      selectedRowKeys.includes(item.sSlaveId))
                );
              }
            }
          }
          if (sProName === "Sp_Mes_BindMaterials") {
            filterData = filterData.filter(item => item.sAdded == "1");
          }
        }
        const addState = { key: tableName };
        const allValue = [];
        filterData.forEach(currData => {
          let value = { ...commonData, ...staticData, ...faceData };
          arr[tableName].forEach(({ sFieldName, sFieldNameNew }) => {
            if (sFieldNameNew === "*") {
              value = { ...value, ...currData };
              delete value.sColumnConfig;
            } else {
              value[`${sFieldNameNew}`] = currData[`${sFieldName}`];
            }
          });
          allValue.push(value);
        });
        addState.value = allValue;
        inParams.push(addState);
      }
    });

    if (
      commonUtils.isNotEmptyStr(sTableName) &&
      commonUtils.isNotEmptyArr(inParams)
    ) {
      inParams.forEach(item => {
        if (commonUtils.isNotEmptyArr(item.value)) {
          item.value.forEach(item1 => {
            item1.sTableName = sTableName;
          });
        }
      });
    }

    const { token, sModelsId } = currentState;
    const { sControlName: sBtnName } = btnConfig;

    if (iFlag !== undefined) {
      inParams[0]?.value?.forEach(item => {
        item.iFlag = iFlag;
      });
    }

    const proInParam = JSON.stringify({
      params: inParams.map(item => ({
        ...item,
        sUserName: app.userinfo.sUserName
      })),
      changeValue: sValue,
      sButtonParam: btn
    });
    const value = { sProName, sProInParam: proInParam, sBtnName };
    if (iFlag !== undefined) {
      value.iFlag = iFlag;
    }

    console.log("=====存储过程参数", {
      params: inParams,
      changeValue: sValue,
      sButtonParam: btn
    });
    const url = `${commonConfig.server_host
      }procedureCall/doGenericProcedureCall?sModelsId=${sModelsId}`;
    const returnData = (await commonServices.postValueService(
      token,
      value,
      url
    )).data;
    const { code, msg, dataset } = returnData;
    if (code === 1) {
      message.success(msg);
      onSuccess && onSuccess(true, dataset);
    } else if (code === -7) {
      Modal.confirm({
        title: FriendlyReminder,
        content: <div>{handleGetMsg(msg)}</div>,
        onOk() {
          handleProcedureCall(params, 1);
        },
        onCancel() {
          onError && onError();
        }
      });
    } else if (code === -8) {
      Modal.info({
        title: FriendlyReminder,
        content: <div>{handleGetMsg(msg)}</div>,
        onOk() {
          onConfirm && onConfirm();
        },
        onCancel() {
          onError && onError();
        }
      });
    } else {
      getServiceError(returnData);
      onError & onError();
    }
  };

  /* 解析消息 */
  const handleGetMsg = str => {
    const msgArr = commonUtils.isNotEmptyObject(str) ? str.split("xpm") : "";
    const divStr = [];
    if (commonUtils.isNotEmptyArr(msgArr)) {
      for (let i = 0; i < msgArr.length; i++) {
        divStr.push(<p>{msgArr[i]}</p>);
      }
    }
    return divStr;
  };

  // 双击事件
  const handleDoubleClickNew = ({ name, record }) => {
    const { [`${name}Config`]: tableConfig = {} } = state;
    let dbclickPopConfig = tableConfig.gdsconfigformslave?.find(
      item =>
        item.sControlName && item.sControlName.toLowerCase() === "dbclickpop"
    );
    if (!dbclickPopConfig) {
      dbclickPopConfig = tableConfig.gdsconfigformslave?.find(
        item =>
          item.sName && item.sName.toLowerCase() === "picarr"
      );
    };
    if (!dbclickPopConfig) return

    let { sActiveId, sActiveName } = dbclickPopConfig;
    // 如果行数据里有sFormId， 则取sFormId作为弹窗的表单id
    const { sFormId, sMaintenanceLevel } = record;
    if (sFormId && sMaintenanceLevel) {
      sActiveId = sFormId;
      sActiveName = sMaintenanceLevel;
      if (sMaintenanceLevel === "日常保养") {
        sActiveName = "设备日保养";
      } else if (
        sMaintenanceLevel === "一级保养" ||
        sMaintenanceLevel === "1级保养"
      ) {
        sActiveName = "设备一级保养";
      }

      if (
        ["101251240115016050003838930", "12710101117207650035150"].includes(
          sFormId
        )
      ) {
        sActiveId = "17102090670002643282020454509600";
      }
    } else {
      sActiveId = sFormId || sActiveId;
      sActiveName = '编辑';
    }


    if (sActiveId) {
      // 获取sqlCondition值
      const sParentConditions = getSqlCondition(dbclickPopConfig, name, record);
      // 弹窗展示
      props.onOpenCommonModal({
        type: "commonModal",
        sActiveId,
        title: sActiveName,
        sParentConditions,
        sModelType: '/indexPage/commonBill',
        parentProps: {
          ...returnProps,
          record
        },
        onOk: data => {
          console.log("=====onOk", data);
        },
        onCancel: () => {
          console.log("=====onCancel");
        },
      });
    }
  };
  /* 下拉多选离开事件 */
  const handleTableBlur = async (name, sFileName, record, tableConfig, other) => {
    const { sModelsId, app } = props;
    const { controlData, slaveConfig, [`${name}Data`]: tableData, [`${name}Config`]: tempConfig } = state;
    let { slaveData: slaveDataOld, masterData, slaveDelData, } = state;
    const addState = {};
    if (commonUtils.isEmptyArr(slaveDelData)) {
      slaveDelData = [];
    }
    if (sFileName === 'sPartsNameNew') {
      if (commonUtils.isNotEmptyArr(controlData)) {
        /* 离开时 把sPartsNameNewId数据挂载到sControlParentId */
        let iIndex = controlData.findIndex(item => item.sId === record.sId);
        if (iIndex === -1) {
          if (record.sId && record.sId.split('-').length > 1) {
            iIndex = controlData.findIndex(item => item.sId === record.sId.split('-')[0]);
          }
        }
        if (iIndex > -1) {
          addState.sControlParentId = controlData[iIndex].sPartsNameNewId;
          if (commonUtils.isNotEmptyObject(controlData[iIndex].sPartsNameNewId)) {
            controlData[iIndex] = { ...controlData[iIndex], ...addState };
            props.onSaveState({ controlData: controlData });
          }
        }
      }
    } else if (tableConfig.sDropDownType === 'movesql') { /* 通用字段离开调下拉事件 */
      let slaveRow = record;
      const sqlDropDownData = await getSqlDropDownData(sModelsId, name, tableConfig, slaveRow);
      const dDropDownData = sqlDropDownData.dropDownData;
      const iIndex = tableData.findIndex(item => item.sId === record.sId);
      if (commonUtils.isNotEmptyArr(dDropDownData) && iIndex > -1) {
        slaveRow = { ...slaveRow, ...commonFunc.getAssignFieldValue(tableConfig.sAssignField, dDropDownData[0]) }; // 取赋值字段
        slaveRow.handleType = commonUtils.isEmpty(slaveRow.handleType) ? 'update' : slaveRow.handleType;
        const sButtonParam = tableConfig.sButtonParam; /* 设置多级联动 */
        if (commonUtils.isNotEmptyObject(sButtonParam)) {
          let sLinkFieldName = 'dMaterialsPrice';
          if (commonUtils.isJSON(sButtonParam)) { /* 按钮条件 */
            const linkObj = JSON.parse(sButtonParam); /* 联动配置 */
            let models = 'Materials';
            if (linkObj.linkMaterials) {
              sLinkFieldName = linkObj.linkMaterials;
              models = 'Materials';
            } else if (linkObj.linkProduct) {
              sLinkFieldName = linkObj.linkProduct;
              models = 'Product';
            }
            slaveRow = commonBusiness.getCalculateAllMoney(app, models, sLinkFieldName, masterData, slaveRow);
          }
        }

        tableData[iIndex] = { ...tableData[iIndex], ...slaveRow };
        handleSaveState({ ...addState });
      }
    } else if (commonUtils.isNotEmptyObject(tableConfig) && commonUtils.isNotEmptyObject(tableConfig.sButtonParam)) {
      let slaveNewData = [];
      const allConfig = { slaveConfig };
      // console.log('sTmpInfoConfigArr', sTmpInfoConfigArr);
      const sTmpInfoConfig = tableConfig;
      const sButtonParam = tableConfig.sButtonParam;
      const btn = commonUtils.isNotEmptyObject(sButtonParam) && commonUtils.isJSON(sButtonParam) ? JSON.parse(sButtonParam) : {};;
      const sProName = commonUtils.isNotEmptyObject(btn) ? btn.sproName : '';
      const sTmpInfoBySqlBtnName = commonUtils.isNotEmptyObject(btn) ? btn.sControlName : '';
      const sActiveKey = sTmpInfoConfig.sActiveKey;
      if (commonUtils.isNotEmptyObject(sTmpInfoConfig)) {
        if (commonUtils.isEmptyObject(sTmpInfoBySqlBtnName)) {
          const newCopyTo = {};
          newCopyTo.master = masterData;
          // newCopyTo.slave = commonUtils.isEmpty(slaveData) ? [] : slaveData[0];
          // const sRowData = copyTo.slaveData;
          const sRowData = masterData;
          const value = { sProName, sProInParam: JSON.stringify({ params: sRowData }) };
          if (other?.iFlag === 1) {
            value.iFlag = 1;
          }
          const url = `${commonConfig.server_host}procedureCall/doGenericProcedureCall?sModelsId=${sModelsId}`;
          const dataReturn = (await commonServices.postValueService(app.token, value, url)).data;
          if (dataReturn.code === 1) {
            if (commonUtils.isNotEmptyArr(slaveDataOld)) {
              slaveDataOld.forEach((item) => {
                item.handleType = 'del';
                slaveDelData.push(item);
              });
              addState.slaveDelData = slaveDelData;
            }
            const returnData = dataReturn.dataset.rows[0];
            const slaveReturn = returnData.dataSet.proData;
            if (commonUtils.isNotEmptyArr(slaveReturn)) {
              slaveReturn.forEach((slaveItem) => {
                newCopyTo.slave = slaveItem;
                let slaveRow = commonFunc.getDefaultData(allConfig.slaveConfig, newCopyTo); // 取默认值
                // if (salveDetailAssignField) {
                //   slaveRow = {...slaveRow, ...commonFunc.getAssignFieldValue(salveDetailAssignField, copyTo.masterData, newCopyTo)};
                // } else if (salveAssignField) {
                //   slaveRow = {...slaveRow, ...commonFunc.getAssignFieldValue(salveAssignField, slaveItem, newCopyTo)}; // 取赋值字段
                // }
                slaveRow = { ...slaveRow, ...slaveItem };
                slaveRow.handleType = 'add';
                slaveRow.sId = commonUtils.createSid();
                slaveRow.sParentId = masterData.sId;
                slaveNewData.push(slaveRow);
              });
            }
            addState.slaveData = slaveNewData;
            handleSaveState({ ...addState });
          } else {
            getServiceError({ ...dataReturn, fn: () => handleTableBlur(name, sFileName, record, tableConfig, { iFlag: 1 }) });
          }
        } else if (sTmpInfoBySqlBtnName.includes('sTmpInfoBySql')) { /* 走TmpInfo逻辑 */
          const newCopyTo = {};
          newCopyTo.master = masterData;
          /* 找到自定义TempInfo配置 */

          const btnConfig = tempConfig.gdsconfigformslave.filter(item => item.sControlName.includes(sTmpInfoBySqlBtnName));
          const dataUrl = `${commonConfig.server_host}salesorder/getTmpInfoBySql/?sModelsId=${sModelsId}`;
          const sConfigformId = commonUtils.isEmpty(btnConfig) ? '' : btnConfig[0].sParentId;
          const sControlName = commonUtils.isNotEmptyObject(sTmpInfoBySqlBtnName) ? sTmpInfoBySqlBtnName : 'TmpInfoBySql';
          const sAssignField = btnConfig[0].sAssignField;
          const sActiveKeyNew = btnConfig[0].sActiveKey;
          let sRowData = [record];
          if (name === 'master' && sTmpInfoBySqlBtnName.includes('_update')) {
            const { slaveData } = state;
            if (commonUtils.isNotEmptyArr(slaveData)) {
              sRowData = [...sRowData, ...slaveData];
            }
          }
          const values = { sConfigformId, sControlName, sRowData };
          if (true) {
            const dataReturn = (await commonServices.postValueService(app.token, values, dataUrl)).data;
            const allReturnMap = {};
            if (dataReturn.code === 1) {
              const returnData = dataReturn.dataset.rows[0];
              if (commonUtils.isNotEmptyObject(returnData)) {
                for (const key of Object.keys(returnData)) {
                  const sName = `${key}Data`;
                  const sDelName = `${key}DelData`;
                  // allReturnMap[sName] = returnData[key];
                  let { [`${key}Data`]: oldData, [`${key}Data`]: oldDelData } = state;
                  if (commonUtils.isEmptyArr(oldDelData)) {
                    oldDelData = [];
                  }
                  if (commonUtils.isEmptyArr(oldData)) {
                    oldData = [];
                  }
                  if (sTmpInfoBySqlBtnName.includes('_edit')) { /* 替换 根据对应字段对比 相同的不管 不同的插入  */
                    /* 对应字段 */
                    const sActiveKey = sTmpInfoConfig.sActiveKey;
                    const keyData = returnData[key];
                    let newData = [];
                    if (commonUtils.isNotEmptyArr(keyData)) {
                      keyData.forEach((child) => {
                        const filterData = oldData.filter(item => item[sActiveKeyNew] !== child[sActiveKeyNew]);
                        if (commonUtils.isNotEmptyArr(filterData) && filterData.length === oldData.length) {
                          const tableRow = { ...child, ...commonFunc.getAssignFieldValue(sAssignField, child) }; // 取赋值字段111
                          tableRow.sId = commonUtils.createSid();
                          tableRow.sParentId = masterData.sId;
                          tableRow.handleType = 'add';
                          newData.push(tableRow);
                        } else {  /* 相同的根据赋值字段覆盖 */
                          const iIndex = oldData.findIndex(item => item[sActiveKeyNew] === child[sActiveKeyNew]);
                          if (iIndex > -1) {
                            if (sAssignField) {
                              oldData[iIndex] = { ...oldData[iIndex], ...commonFunc.getAssignFieldValue(sAssignField, child) };
                            } else {
                              oldData[iIndex] = { ...oldData[iIndex], ...child };
                            }
                            oldData[iIndex].handleType = commonUtils.isEmpty(oldData[iIndex].handleType) ? 'update' : oldData[iIndex].handleType;
                          }
                        }
                      });
                      newData = oldData.concat(newData)
                    }

                  } else if (sTmpInfoBySqlBtnName.includes('_del')) { /* 替换 根据对应字段对比 相同的不管 不同的插入  */
                    /* 对应字段 */
                    oldData.forEach((child) => {
                      child.handleType = 'del';
                      oldDelData.push(child);
                    });
                    allReturnMap[sDelName] = oldDelData;
                    oldData = [];
                    const keyData = returnData[key];
                    if (commonUtils.isNotEmptyArr(keyData)) {
                      keyData.forEach((child) => {
                        const tableRow = { ...child, ...commonFunc.getAssignFieldValue(sAssignField, child) }; // 取赋值字段111
                        tableRow.sId = commonUtils.createSid();
                        if (sName === 'slaveData' && !tableRow.sSqlConditionId) {
                          tableRow.sSqlConditionId = tableRow.sId;
                        }
                        tableRow.sParentId = masterData.sId;
                        tableRow.handleType = 'add';
                        oldData.push(tableRow);
                      });
                    }
                    allReturnMap[sName] = oldData;
                  } else if (sTmpInfoBySqlBtnName.includes('_update')) { /* 更新字段  */
                    const keyData = returnData[key];
                    if (commonUtils.isNotEmptyArr(keyData) && sActiveKeyNew) {
                      const [linkField, onchangeField] = sActiveKeyNew.split(',');
                      const tableName = key.split('_update')[0];
                      const { [`${tableName}Data`]: tableData = [] } = state;

                      for (let i = 0; i < keyData.length; i++) {
                        const child = keyData[i];
                        const tableDataFilter = tableData.filter(item => item[linkField] === child[linkField]);
                        for (let j = 0; j < tableDataFilter.length; j++) {
                          const item = tableDataFilter[j];
                          const iIndex = tableData.findIndex(row => row.sId === item.sId);
                          tableData[iIndex] = { ...item, ...child };
                          if (onchangeField && state.onEventDataChange) {
                            const { sId, [onchangeField]: fieldsValue } = tableData[iIndex];
                            window.tmpSlaveData = tableData;
                            tableData[iIndex] = await state.onEventDataChange('slave', onchangeField, { [onchangeField]: fieldsValue }, sId, [], true);
                            window.tmpSlaveData = null;
                          }
                        }
                      }
                      allReturnMap[`${tableName}Data`] = tableData;
                    }
                  } else {
                    allReturnMap[sName] = returnData[key];
                  }

                }
                if (commonUtils.isNotEmptyArr(allReturnMap.masterData) && Array.isArray(allReturnMap.masterData)) {
                  allReturnMap.masterData = allReturnMap.masterData[0];
                }
                handleSaveState({ ...allReturnMap });
              }
            } else {
              getServiceError(dataReturn);
            }
          }
        }
      } else {
        message.error('请正确配置自定义按钮！');
      }
    }
  };
  // 通用表格行按钮操作
  const handleTableBtnClick = async params => {
    const { app } = props;
    const {
      name,
      index,
      record,
      tableData,
      config = {},
      onSuccess,
      nextProps
    } = params;
    const { sControlName = "", sInstruct } = config;
    const sControlLowerName = sControlName.toLowerCase();
    // 调用指令集
    if (sInstruct) {
      handleExecInstructSet({
        ...props,
        btnConfig: config,
        tableLineParams: params,
        nextProps
      });
      return;
    }

    // 是否调用过存储过程
    const bHandleProcedure = await new Promise(resolve => {
      handleProcedureCall({
        btnConfig: config,
        tableData: [record],
        onSuccess: status => {
          resolve(status);
        }
      });
    });

    // 成功回调
    bHandleProcedure && onSuccess && onSuccess();

    // 获取sqlCondition值
    const sParentConditions = getSqlCondition(config, name, record);

    const { sActiveId, sActiveName } = config;
    // 复制到
    if (sControlLowerName.includes("copyto")) {
      const { sDropDownType, sAssignField } = config;
      if (!sActiveId) {
        message.info("请先配置弹出界面！");
        return;
      }
      if (!sAssignField) {
        message.info("请先配置赋值字段！");
        return;
      }

      const copyTo = {};
      const allTableData = commonFunc.getAllTableData(props);
      const tableDataRow = commonFunc.getAssignFieldValue(
        sAssignField,
        record,
        allTableData
      );
      copyTo[name] = tableDataRow;

      if (sDropDownType === "=+@") {
        // 如果弹窗类型为空
        const [menuPath, sModelType] = handleGetMenu(sActiveId);
        app.globalFun.onChangeRouter({
          type: "id",
          path: menuPath,
          sModelType,
          sParentConditions
        });
      } else if (sDropDownType === "popup") {
        // 弹窗展示
        props.onOpenCommonModal({
          type: "commonModal",
          sActiveId,
          title: sActiveName,
          sParentConditions,
          copyTo,
          parentProps: {
            ...returnProps
          },
          onOk: data => {
            console.log("=====onOk", data);
          },
          onCancel: () => {
            console.log("=====onCancel");
          }
        });
      }
    } else if (sActiveId) {
      const addState = {};
      if (sActiveId === "12710101117126502477360") {
        addState.copyTo = {
          table0: [record]
        };
      }

      // 弹窗展示
      props.onOpenCommonModal({
        type: "commonModal",
        sActiveId,
        title: sActiveName,
        sParentConditions,
        ...addState,
        parentProps: {
          ...returnProps
        },
        modalCallback: ({ refreshTable, closeModal }) => {
          // 关闭弹窗
          if (closeModal) {
            app.globalFun.onCloseCommonModal({ type: "commonModal" });
          }
          // 刷新表格
          if (refreshTable) {
            handleSaveState({ refreshTableList: [name] });
          }
        }
      });
    }

    // 预览
    if (sControlName.toLowerCase().includes("preview")) {
      const [, , targetField] = sControlName.split(".");
      const { [targetField]: filePreviewUrl } = record;
      app.globalFun.onOpenCommonModal({
        type: "commonFilePreviewModal",
        url: filePreviewUrl
      });
    }
  };

  //  获取菜单路径和类型
  const handleGetMenu = sActiveId => {
    const { app } = state;
    const { managementData } = app;

    let result = [];

    for (let i = 0; i < managementData.length; i++) {
      if (result) break;
      const item1 = managementData[i];
      if (!item1.children) continue;
      for (let j = 0; j < item1.children.length; j++) {
        const item2 = item1.children[j];
        if (commonUtils.isNotEmptyArr(item2.children)) {
          for (let k = 0; k < item2.children.length; k++) {
            const item3 = item2.children[k];
            if (item3.sId === sId) {
              result = [[item1.sId, item2.sId, item3.sId], item3.sName];
              break;
            }
          }
        } else {
          if (item2.sId === sActiveId) {
            result = [[item1.sId, item2.sId], item2.sName];
          }
        }
      }
    }

    return result;
  };

  // 执行指令集
  const handleExecInstructSet = params => {
    const {
      btnConfig,
      tableLineParams,
      callback,
      inscallback,
      nextProps = {}
    } = params;
    const { sInstruct } = btnConfig;
    if (!sInstruct) return;

    instructSet({
      ...returnProps,
      ...nextProps,
      btnConfig,
      tableLineParams,
      callback,
      inscallback
    });
  };

  // 表格行新增
  const handleMesTableLineAdd = ({ tableName, callback, bAddFirst }) => {
    const {
      [`${tableName}Config`]: config = {},
      [`${tableName}Data`]: data = [],
      masterData = {}
    } = state;

    // 自定义事件
    if (
      costomPageFun({
        props: {
          ...state,
          onSaveState: handleSaveState,
          handleExecInstructSet
        },
        tableName,
        actionName: "mesTableLineAdd"
      })
    )
      return;

    const { gdsconfigformslave = [] } = config;
    const btnTableAddConfig =
      gdsconfigformslave.find(
        item => item.sControlName?.toLowerCase() === "btntableadd"
      ) || {};

    const { sInstruct } = btnTableAddConfig;
    if (sInstruct) {
      handleExecInstructSet({
        ...props,
        btnConfig: btnTableAddConfig
      });
      return;
    }

    const allTableData = commonFunc.getAllTableData(state);
    const newSid = commonUtils.createSid();
    let addRowData = commonFunc.getDefaultData(config, allTableData, {
      newSid
    }); // 取默认值
    addRowData.handleType = "add";
    addRowData.sId = newSid;
    if (masterData.sId) {
      addRowData.sParentId = masterData.sId;
    }

    const newData = bAddFirst ? [addRowData, ...data] : [...data, addRowData];
    const selectedRowKeys = [newSid];
    const addState = {};
    if (location.pathname.includes("indexPad")) {
      addState.enabled = true;
    }
    handleSaveState(
      {
        ...addState,
        [`${tableName}Data`]: newData,
        [`${tableName}SelectedRowKeys`]: selectedRowKeys
      },
      callback
    );
  };

  // 表格行删除
  const handleMesTableLineDel = ({
    tableName,
    record,
    index: indexOld,
    callback
  }) => {
    const {
      [`${tableName}Data`]: data = [],
      [`${tableName}DelData`]: delData = [],
      [`${tableName}Config`]: config = {}
    } = state;

    let index = indexOld;
    if (
      record.sRev &&
      record.sRev?.startsWith("第") &&
      record.sRev?.endsWith("转")
    ) {
      index = data.findIndex(item => item.sId === record.sId);
    }

    const { gdsconfigformslave = [] } = config;
    const btnTableDelConfig =
      gdsconfigformslave.find(
        item => item.sControlName?.toLowerCase() === "btntabledel"
      ) || {};

    const { sInstruct } = btnTableDelConfig;
    if (sInstruct) {
      handleExecInstructSet({
        ...props,
        btnConfig: btnTableDelConfig,
        tableLineParams: {
          name: tableName,
          index,
          record
        },
        nextProps: {
          [`${tableName}SelectedRowKeys`]: [record.sId]
        }
      });
      return;
    }

    const newData = [...data];
    const delRowData = [...newData.splice(index, 1)].map(item => ({
      ...item,
      handleType: "del"
    }));
    const delDataNew = [...delData, ...delRowData];
    handleSaveState(
      {
        [`${tableName}Data`]: newData,
        [`${tableName}DelData`]: delDataNew
      },
      nextProps => {
        callback && callback(nextProps);
        // 自定义事件
        costomPageFun({
          props: {
            ...nextProps,
            delRowData,
            onSaveState: handleSaveState,
            handleExecInstructSet
          },
          tableName,
          actionName: "mesTableLineDel"
        });
      }
    );
  };
  // 表格行复制
  const handleMesTableLineCopy = ({ tableName, record, index, callback }) => {
    const { [`${tableName}Data`]: data = [] } = state;

    const copyRowData = { ...record };
    const newSid = commonUtils.createSid();
    copyRowData.sId = newSid;

    const newData = [...data, copyRowData];
    const selectedRowKeys = [newSid];
    handleSaveState(
      {
        [`${tableName}Data`]: newData,
        [`${tableName}SelectedRowKeys`]: selectedRowKeys
      },
      callback
    );
  };

  // 复制到
  const handleCopyTo = async (nextProps, name, sActiveId) => {
    /*   待用数据声明   */
    const {
      masterConfig,
      masterData,
      slaveData,
      controlData,
      materialsData,
      processData,
      packData,
      app,
      token,
      sModelsId,
      formRoute,
      slaveSelectedRowKeys,
    } = props;
    const { sActiveName } = nextProps.config;
    let sParentConditions = {};
    props.onOpenCommonModal({
      type: "commonModal",
      sActiveId,
      sActiveName,
      sParentConditions,
      parentProps: nextProps,
      onOk: data => {
        window.debugger && console.log("=====onOk");
      },
      onCancel: () => {
        window.debugger && console.log("=====onCancel");
      }
    });
    return
    // 从表有sCopyToCondition则不能复制，并提示
    if (commonUtils.isNotEmptyArr(slaveData) && name.includes('.')) {
      const sCopyToConditionIndex = slaveData.findIndex(item => item.sCopyToCondition);
      if (sCopyToConditionIndex !== -1) {
        message.warning(slaveData[sCopyToConditionIndex].sCopyToCondition);
        return;
      }
    }

    const copyTo = {};
    // const copyToConfig = masterConfig.gdsconfigformslave.filter(item => item.sControlName.includes(name));
    copyTo.name = name;
    copyTo.config = copyToConfig;
    copyTo.masterData = masterData;
    copyTo.slaveData = slaveData;
    copyTo.controlData = controlData;
    copyTo.materialsData = materialsData;
    copyTo.processData = processData;
    copyTo.packData = packData;
    copyTo.srcFormRoute = formRoute;

    // 部分红冲，需要将选中的从表数据带过去
    if (name.includes('Portion')) {
      if (commonUtils.isEmptyArr(slaveSelectedRowKeys)) {
        message.warning('请选择至少一条从表数据');
        return;
      }
      const filterSlaveData = slaveData.filter(item => slaveSelectedRowKeys.includes(item.sId));
      copyTo.slaveData = filterSlaveData;
    }
    if (sModelsId === '12710101116943091653680' && name === 'BtnCopyTo.alumite') {
      if (commonUtils.isEmptyArr(slaveSelectedRowKeys)) {
        message.warning('请选择至少一条从表数据');
        return;
      }
    }


    const tbSuffix = '';
    let sId = '';
    if (!commonUtils.isEmpty(slaveData)) {
      sId = slaveData[0].sId;
    } else {
      sId = masterData.sId;
    }

    const dataUrl = `${commonConfig.server_host}bill/billCopyToCheck/?sModelsId=${sModelsId}&sActiveId=${sActiveId}&tbSuffix=${tbSuffix}&sName=${formRoute}`;
    const values = { sSlaveId: sId };
    const dataReturn = (await commonServices.postValueService(token, values, dataUrl)).data;
    if (dataReturn.code === 1) {
      if (dataReturn.dataset.rows.length > 0) {
        console.log(dataReturn, 'dataReturn');

      } else {

      }
    }
  };
  // 合并config配置和所有sButtonEnabled配置
  const handleMergeTableConfig = tableConfig => {
    const { sRulesJsonTotal } = state;
    if (commonUtils.isEmptyObject(tableConfig)) {
      return {};
    }
    if (commonUtils.isEmptyObject(sRulesJsonTotal)) {
      return tableConfig;
    }
    const { sTbName, sGrd } = tableConfig;
    const tableConfigNew = cloneDeep(tableConfig);
    const { gdsconfigformslave } = tableConfigNew;
    if (commonUtils.isNotEmptyArr(sRulesJsonTotal.showColumn)) {
      sRulesJsonTotal.showColumn.filter(item => item).forEach(item => {
        const iIndex = gdsconfigformslave.findIndex(
          child =>
            item === `${sTbName}.${child.sName}` ||
            item === `${sGrd}.${child.sName}`
        );
        if (iIndex !== -1) {
          const { sControlName } = gdsconfigformslave[iIndex];
          !sControlName && (gdsconfigformslave[iIndex].bVisible = true);
          gdsconfigformslave[iIndex].bControl = true;
        }
      });
    }

    if (commonUtils.isNotEmptyArr(sRulesJsonTotal.hideColumn)) {
      sRulesJsonTotal.hideColumn.filter(item => item).forEach(item => {
        const iIndex = gdsconfigformslave.findIndex(
          child =>
            item === `${sTbName}.${child.sName}` ||
            item === `${sGrd}.${child.sName}`
        );
        if (iIndex !== -1) {
          const { sControlName } = gdsconfigformslave[iIndex];
          !sControlName && (gdsconfigformslave[iIndex].bVisible = false);
          gdsconfigformslave[iIndex].bControl = false;
        }
      });
    }

    if (commonUtils.isNotEmptyArr(sRulesJsonTotal.mustColumn)) {
      sRulesJsonTotal.mustColumn.filter(item => item).forEach(item => {
        const iIndex = gdsconfigformslave.findIndex(
          child =>
            item === `${sTbName}.${child.sName}` ||
            item === `${sGrd}.${child.sName}`
        );
        if (iIndex !== -1) {
          gdsconfigformslave[iIndex].bNotEmpty = true;
        }
      });
    }

    if (commonUtils.isNotEmptyArr(sRulesJsonTotal.readOnlyColumn)) {
      sRulesJsonTotal.readOnlyColumn.filter(item => item).forEach(item => {
        const iIndex = gdsconfigformslave.findIndex(
          child =>
            item === `${sTbName}.${child.sName}` ||
            item === `${sGrd}.${child.sName}`
        );
        if (iIndex !== -1) {
          gdsconfigformslave[iIndex].bReadonly = true;
        }
      });
    }
    return tableConfigNew;
  };
  /* 通用弹窗 选择数据带回窗体 */
  const handleSelectCommonPopup = (currentPaneName, selectConfig, selectData, tbName, isWait) => {
    // 如果配置了sAfterClickInstruct，先走指令集再走原逻辑，否值直接走原逻辑
    const { sAfterClickInstruct, showName } = selectConfig;
    if (sAfterClickInstruct) {
      instructSet({
        ...props,
        ...state,
        slavepupData: selectData,
        btnConfig: { sInstruct: sAfterClickInstruct, showName },
        onSaveState: handleSaveState,
        callback: () => {
          handleSelectCommonPopupNew(currentPaneName, selectConfig, selectData, tbName, isWait);
        }
      })
    } else {
      if (typeof isWait === 'boolean' && isWait) {
        return handleSelectCommonPopupNew(currentPaneName, selectConfig, selectData, tbName, isWait);
      } else {
        handleSelectCommonPopupNew(currentPaneName, selectConfig, selectData, tbName);
      }
    }
  };
  const handleSelectCommonPopupNew = (currentPaneName, selectConfig, selectData, tbName, isWait) => {
    const {
      [`${tbName}SelectedRowKeys`]: tableSelectedRowKeys, masterData,
      controlData, controlSelectedRowKeys, sModelsId,
    } = state;
    const { sOnChangeInstruct, showName } = selectConfig;
    const type = 'change';
    const onChangeNew = commonUtils.convertStrToObj(sOnChangeInstruct, {});
    const instructType = onChangeNew[type];
    // 回弹字段直接设置单价
    async function setProductPrice(tableDataRowAdd, item, props) {
      if (selectConfig.sName === 'sProductId' || selectConfig.sName === 'sProductName' || selectConfig.sName === 'sProductNo') {
        const url = `${commonConfig.server_host}business/getProData?sModelsId=${sModelsId}`;
        const { sCustomerId } = masterData; /* 增加客户id参数 */
        const value = {
          sProName: 'Sp_Cashier_GetProductPrice',
          paramsMap: {
            sProductGuid: item.sId,
            sCustomerId,
          },
        };
        const returnData = (await commonServices.postValueService(props.app.token, value, url)).data;
        if (returnData.code === 1) {
          tableDataRowAdd.dNProductPrice = returnData.dataset.rows[0].dataSet.outData[0].dPrice; /* 产品单价 */
          const dProofingMoney = commonUtils.convertToNum(tableDataRowAdd.dProofingMoney); /* 打样金额 */
          const dPlateMoney = commonUtils.convertToNum(tableDataRowAdd.dPlateMoney); /* 制版金额 */
          const dKnifeMouldMoney = commonUtils.convertToNum(tableDataRowAdd.dKnifeMouldMoney); /* 刀模金额 */
          const dProductQty = commonUtils.convertToNum(tableDataRowAdd.dProductQty); /* 数量 */
          const dCurrencyRate = commonUtils.convertIsNotNumToNumber1(masterData.dCurrencyRate); /* 汇率 */
          const { dNetPrice } = props.app.decimals;
          if (dProductQty === 0 || (dProofingMoney === 0 && dPlateMoney === 0 && dKnifeMouldMoney === 0)) {
            const dProductForeignPrice = returnData.dataset.rows[0].dataSet.outData[0].dPrice;
            tableDataRowAdd.dProductForeignPrice = dProductForeignPrice;
            tableDataRowAdd.dProductPrice = commonUtils.convertFixNum(dProductForeignPrice * dCurrencyRate, dNetPrice);
          }
        }
        return tableDataRowAdd;
      } else {
        return tableDataRowAdd;
      }
    }
    let { [`${tbName}Data`]: tableData, [`${tbName}Pagination`]: pagination = {} } = state;
    let addReturn = {};
    if (commonUtils.isNotEmptyArr(tableData) && commonUtils.isNotEmptyArr(selectData)) {
      const iIndex = commonUtils.isNotEmptyArr(tableSelectedRowKeys) && commonUtils.isNotEmptyObject(tableSelectedRowKeys[0]) ? tableData.findIndex(item => item.sId === tableSelectedRowKeys[0]) : -1;
      const iControlIndex = commonUtils.isNotEmptyArr(controlSelectedRowKeys) ? controlData.findIndex(item => item.sId === controlSelectedRowKeys[0]) : -1; /* 控制表 */
      selectData.forEach(async (item, index) => {
        const newCopyTo = {};
        newCopyTo.master = masterData;
        const sName = selectConfig.sKeyUpFilter; /* 将后台配置筛选字段作为 列字段 */
        console.log("🚀 ~ handleSelectCommonPopupNew ~ sName:", sName)
        let sValue = '';
        if (iIndex > -1) {
          newCopyTo.slave = tableData[iIndex];
          sValue = tableData[iIndex][sName];
        }
        if (iControlIndex > -1) {
          newCopyTo.control = controlData[iControlIndex];
        }
        /* 第一条数据若字段值为空或者只有一条数据时 则添加到该行 否则新增一行 */
        if (selectData.length === 1 || (index === 0 && commonUtils.isEmptyObject(sValue))) {
          let tableDataRow = {}; // 取默认值
          if (tbName === 'master') {
            tableDataRow = { ...tableData, ...commonFunc.getAssignFieldValue(selectConfig.sAssignField, item, newCopyTo) }; // 取赋值字段
            tableData = tableDataRow;
            tableData.handleType = commonUtils.isEmpty(tableData.handleType) ? 'update' : tableData.handleType;
            if (instructType) {
              handleExecInstructSet({
                type,
                sInstruct: instructType,
                showName: `${showName}-${type === 'blur' ? '离焦' : '变化'}`,
              });
            }

          } else {
            tableDataRow = { ...tableData[iIndex] };
            if (tbName === 'slave') {
              tableDataRow.sSqlConditionId = tableDataRow.sId;
            }
            tableDataRow = { ...tableDataRow, ...commonFunc.getAssignFieldValue(selectConfig.sAssignField, item, newCopyTo) }; // 取赋值字段

            tableData[iIndex] = tableDataRow;
            tableData[iIndex].handleType = commonUtils.isEmpty(tableData[iIndex].handleType) ? 'update' : tableData[iIndex].handleType;
            tableData[iIndex] = await setProductPrice(tableData[iIndex], item, props);
            if (instructType) {
              handleExecInstructSet({
                type,
                sInstruct: instructType,
                showName: `${showName}-${type === 'blur' ? '离焦' : '变化'}`,
              });
            }
          }
        } else {
          let tableDataRowAdd = handleTableAdd(tbName, true);
          if (tbName === 'slave') {
            tableDataRowAdd.sSqlConditionId = tableDataRowAdd.sId;
          }
          tableDataRowAdd = { ...tableDataRowAdd, ...commonFunc.getAssignFieldValue(selectConfig.sAssignField, item, newCopyTo) }; // 取赋值字段
          tableDataRowAdd = await setProductPrice(tableDataRowAdd, item, props);
          if (instructType) {
            handleExecInstructSet({
              type,
              sInstruct: instructType,
              showName: `${showName}-${type === 'blur' ? '离焦' : '变化'}`,
            });
          }
          tableData.push(tableDataRowAdd);
        }

        pagination = {
          ...pagination,
          total: tableData.length,
        }

        if (tbName === 'master') {
          const result = handleMasterChange(tbName, selectConfig.sName, {}, null, null, true, tableData);
          tableData = result.masterData;
        } else if (tbName.includes('slave')) {
          tableData.forEach(item => {
            item.sParentId = state?.masterData?.sId
          })
        }

        const addState = { [`${tbName}Data`]: tableData, [`${tbName}Pagination`]: pagination };

        if (typeof isWait !== 'boolean') {
          handleSaveState(addState);
        }

      });
      if (typeof isWait === 'boolean' && isWait) {
        addReturn = { [`${tbName}Data`]: tableData, [`${tbName}Pagination`]: pagination };
        return addReturn;
      }
    }
  };
  const handleDel = (obj) => {
    const props = { ...obj, ...state };
    handleOkDel(props);
  };
  /* 确定要删除 */
  const handleOkDel = async (props) => {
    /*   数据参数   */
    const {
      token, sModelsId, sModelsType, masterConfig, masterData, slaveConfig, checkConfig, orderDetailConfig, app,
    } = props;
    const { userinfo, systemData } = app;
    const { sMakePerson } = masterData; /* 本单据制单人 */
    const { sUserName, sType } = userinfo;/* 登录用户 */
    const iIndex = systemData.findIndex(item => item.sName === 'CkxModifyBillNoMakePerson');
    if (iIndex > -1) {
      const sValue = systemData[iIndex].sValue;
      if (sValue === '0') { /* 系统未启用非制单人修改单据，普通用户非制单人不可以修改制单人的单据 */
        if (sType !== 'sysadmin' && sUserName !== sMakePerson) {
          message.error(commonFunc.showMessage(app.commonConst, 'NoDelByNoMakePerson'));
          return;
        }
      }
    }
    const value = {
      sClientType: '1',
      data: {
        sMasterTable: masterConfig.sTbName,
        sId: [masterData.sId],
      },
    };
    const sSlaveTable = [];
    if (commonUtils.isNotEmptyObject(slaveConfig)) {
      sSlaveTable.push({
        tableName: slaveConfig.sTbName,
        relationName: 'sParentId',
      });
    }
    if (commonUtils.isNotEmptyObject(checkConfig)) {
      sSlaveTable.push({
        tableName: checkConfig.sTbName,
        relationName: 'sParentId',
      });
    }
    if (sModelsType === 'purchase/purchaseOrder') {
      sSlaveTable.push({
        tableName: orderDetailConfig.sTbName,
        relationName: 'sParentId',
      });
    }
    value.sSlaveTable = sSlaveTable;
    const { sBillNo, sId } = masterData || {};
    const url = `${commonConfig.server_host}business/delMasSlaBusinessData?sModelsId=${sModelsId}&sBillNo=${sBillNo}&sSysLogSrcId=${sId}`;
    /*   接收返回值   */
    const { data } = await commonServices.postValueService(token, value, url);
    if (data.code === 1) {
      /*   数据删除成功   */

      if (sModelsType !== 'commonOeeBill') {
        handleDelDataSuccess(props);
      } else {
        message.success("删除成功！");
      }
      props.onCancel()
    } else { /*   失败   */
      props.getServiceError(data);
    }
  };
  /* 数据删除成功跳转到新路由即pane */
  const handleDelDataSuccess = (props) => {

  };
  /**   toolbar审核(消审)   */
  const handleAudit = async (flag) => {
    console.log("🚀 ~ handleAudit ~ flag:", flag)
    /*   待用数据声明   */
    let bResult = true;
    const { masterData, gdsformconst } = props;
    if (!commonUtils.isEmpty(masterData)) {
      /*   作废订单不能审核   */
      if (masterData.bInvalid) {
        message.warning(commonFunc.showMessage(app.commonConst, 'sToVoid'));
        handleSaveState({
          loading: false,
        });
        return '';
      }
      /**   数据审核   */
      bResult = await dataAudit(flag);
    } else {
      handleSaveState({
        loading: false,
      });
    }
    return bResult;
  };
  /**   数据审核   */
  const dataAudit = async (flag, tmpCheck, isWait) => {
    console.log("🚀 ~ dataAudit ~ flag:", flag)
    message.destroy();
    /*   待用数据声明   */
    const {
      sModelsId, masterData, app, masterConfig, slaveConfig, checkConfig, token, sModelsType, controlConfig, materialsConfig, processConfig, colorConfig, packConfig, slaveData, orderDetailConfig,
    } = props;
    const FriendlyReminder = commonFunc.showLocalMessage(props, 'FriendlyReminder', '温馨提示');
    const sSlaveIdArray = [];
    if (commonUtils.isNotEmptyArr(slaveData)) {
      slaveData.forEach((item) => {
        sSlaveIdArray.push(commonUtils.isNotEmptyObject(item.sId) ? item.sId : item.sSlaveId);
      });
    }
    const slaveId = sSlaveIdArray.toString();
    /*   数据参数   */
    const value = {
      sClientType: '1',
      paramsMap: {
        iFlag: flag,
        iTmpCheck: commonUtils.isEmptyNumber(tmpCheck) ? 0 : tmpCheck,
        sFormGuid: sModelsId,
        sGuid: masterData.sId,
        sSlaveId: slaveId,
        sBillNo: commonUtils.isNotEmptyObject(masterData.sBillNo) ? masterData.sBillNo : '',
      },
    };
    let clearFlag = false;
    if (sModelsType.includes('sales/salesOrder') || sModelsType.includes('manufacture/workOrder')) {
      if (commonUtils.isNotEmptyArr(slaveData)) {
        for (const item of slaveData) {
          if (commonUtils.isNotEmptyStr(item.sProductInfo)) {
            clearFlag = true;
            break;
          }
        }
      } else {
        handleSaveState({
          loading: false,
        });
        return;
      }
    }
    /*   数据审核   */
    const url = `${commonConfig.server_host}business/doExamine?sModelsId=${sModelsId}`;
    const returnData = (await commonServices.postValueService(app.token, value, url)).data;
    if (isWait) {
      return returnData;
    } else {
      /*   接收返回值   */
      const check = commonFunc.showMessage(app.commonConst, 'BtnExamine');/* 审核 */
      const BtnCancelExamine = commonFunc.showMessage(app.commonConst, 'BtnCancelExamine');/* 销审 */
      if (returnData.code === 1) { /*   成功   */
        handleSaveState({
          loading: false,
        });
        if (flag === 1) {
          /*   审核   */
          if (clearFlag && (sModelsType.includes('sales/salesOrder') || sModelsType.includes('manufacture/workOrder'))) {
            commonUtils.setStoreDropDownData(sModelsId, 'master', 'sProductId', []);
            commonUtils.setStoreDropDownData(sModelsId, 'master', 'sProductNo', []);
            commonUtils.setStoreDropDownData(sModelsId, 'master', 'sProductName', []);
          }
          let outData;
          if (commonUtils.isNotEmptyObject(returnData.dataset)) {
            outData = returnData.dataset.rows[0].dataSet.outData;
          }
          if (false && commonUtils.isNotEmptyStr(outData[0].sReturn)) {
            const sReturnArray = outData[0].sReturn.split('|');
            if (outData[0].sReturn.split('-').length < 2) {
              // 正常业务提示，非审核模板
              // if (this.props.app.currentPane.refresh !== undefined) {
              //   this.props.app.currentPane.refresh();
              // }
              message.error(check + outData[0].sReturn);
              return;
            }
            const checkConditions = [];
            let checkPersonData = {};
            sReturnArray.forEach((item) => {
              const checkCondition = item.split('-')[2];
              const iIndex = checkConditions.findIndex(itemCondition => itemCondition.condition === checkCondition);
              if (iIndex <= -1) {
                checkConditions.push({
                  key: commonUtils.createSid(),
                  condition: checkCondition,
                });
              }
            });
            const sCheckModelId = sReturnArray[0].split('-')[1];
            if (commonUtils.isNotEmptyStr(sCheckModelId)) {
              const urlCheck = `${commonConfig.server_host}checkModel/getUserListByModelId/${sCheckModelId}?sModelsId=${sModelsId}`;
              const dataReturn = (await commonServices.getService(token, urlCheck)).data;
              if (dataReturn.code === 1) {
                checkPersonData = dataReturn.dataset.rows;
                checkPersonData.forEach((item) => {
                  item.key = commonUtils.createSid();
                });
                this.props.onSaveState({
                  checkConditions, checkPersonData, sCheckModelId, visible: true,
                });
                return true;
              } else { /*   失败   */
                this.props.getServiceError({ msg: check + dataReturn });
              }
            }
          } else {
            message.success(check + returnData.msg);
          }
        } else {
          /*   消审   */
          const { outData } = returnData.dataset.rows[0].dataSet;
          if (commonUtils.isNotEmptyStr(outData[0].sReturn)) {
            message.error(outData[0].sReturn);
          } else {
            // if (this.props.app.currentPane.refresh !== undefined) {
            //   this.props.app.currentPane.refresh();
            // }
            message.success(BtnCancelExamine + returnData.msg);
          }
        }
        await handleGetData(masterConfig, slaveConfig, checkConfig);
        if ((sModelsType.includes('sales/salesOrder') || sModelsType.includes('manufacture/workOrder')) && !commonUtils.isEmpty(controlConfig)) {
          await handleGetMemoData(controlConfig, materialsConfig, processConfig, colorConfig, packConfig);
        } else if (commonUtils.isNotEmptyObject(orderDetailConfig)) {
          await handleGetOneMemoData('orderDetail', orderDetailConfig);
        }
        // if (props.app.currentPane.refresh !== undefined) {
        //   this.props.app.currentPane.refresh();
        // }
      } else if (returnData.code === -8) {
        Modal.info({
          title: FriendlyReminder,
          content: (
            <div>
              {handleGetMsg(returnData.msg)}
            </div>
          ),
          onOk() { },
        });
        handleSaveState({
          loading: false,
        });
        return false;
      } else { /*   失败   */
        props.getServiceError(returnData);
        handleSaveState({
          loading: false,
        });
        return false;
      }
      return true;
    }
  };

  const returnProps = {
    ...props,
    ...state,
    setTempRef,
    getTempRef,
    getFloatNum,
    getDateFormat,
    getSqlCondition,
    getServiceError, // 处理错误信息
    getSqlDropDownData,
    handleSqlDropDownNewRecord,
    onChange: handleMasterChange, // 主表数据变化
    onDataChange: handleTableChange, // 表格数据变化
    onGetDataSet: handleGetDataSet,
    onGetTreeDataSet: handleGetTreeDataSet, // 获取树型数据
    onSaveState: handleSaveState,
    onFilterDropDownData: handleFilterDropDownData,
    onGetSqlConditionValues: handleGetSqlConditionValues, // 获取查询时sql条件
    onTableSelectRowChange: handleTableSelectRowChange, // 表格行单击事件
    onSendSocketMessage: handleSendSocketMessage, // 发送websocket消息
    onProcedureCall: handleProcedureCall, // 执行存储过程
    onDoubleClickNew: handleDoubleClickNew, // 双击事件
    onTableBtnClick: handleTableBtnClick, // 通用表格行按钮操作
    onExecInstructSet: handleExecInstructSet, // 执行指令集
    onMesTableLineAdd: handleMesTableLineAdd, // 表格行新增
    onMesTableLineDel: handleMesTableLineDel, // 表格行删除
    onMesTableLineCopy: handleMesTableLineCopy, // 表格行复制
    onCopyTo: handleCopyTo, // 复制到
    onMergeTableConfig: handleMergeTableConfig, // 合并config配置和所有sButtonEnabled配置
    awaitPromiseReturn: awaitPromiseReturn,
    onSelectCommonPopup: handleSelectCommonPopup,
    onDropDownBlur: handleTableBlur,
    onDel: handleDel, // 删除
    // onBtnExamine: handleAudit,
  };

  // 切换页面时，加载角标数据
  useLoadSubscriptNum({ ...returnProps, handleGetModelConfig });

  // 遍历出需要监听的form表单字段，并放到monitorFieldsMap里
  useGetMonitorFields({ ...returnProps });

  // 数据变化时根据monitorFieldsMap判读是否要修改对应表的显示隐藏并存储到sRulesJsonTotal里
  useSetConfigStatus({ ...returnProps });

  return returnProps;
};

/**
 * 使用useXlyCallback钩子函数，在callbackRefresh改变时重新执行callback函数
 * @param {number} callbackRefresh - callbackRefresh值
 * @param {Function} callback - callback函数
 * @param {Object} state - callback函数返回值
 * @param {Function} clearCallback - 清除callback函数的钩子函数
 */
const useXlyCallback = (callbackRefresh, callback, state, clearCallback) => {
  useEffect(
    () => {
      if (typeof callback === "function") {
        callback(state);
        clearCallback();
      }
    },
    [callbackRefresh]
  );
};

// 切换页面时，加载角标数据
const useLoadSubscriptNum = props => {
  const { sModelsId } = props;
  const mesPaneStr = localStorage.xlybusinesscurrentMesPane;
  const mesPane = commonUtils.convertStrToObj(mesPaneStr);
  const { currentContent, sModelsId: sModelsId1 } = mesPane;

  useEffect(
    async () => {
      if (sModelsId !== sModelsId1) return;
      if (
        currentContent !== "scheduledTasks" &&
        currentContent !== "productionExec"
      )
        return;

      instructSet({
        ...props,
        btnConfig: {
          showName: "角标",
          sInstruct: JSON.stringify([
            {
              opr: "opensql",
              data: [
                {
                  sql:
                    "call Sp_mes_scheduled_tasks_pending(${sMachineGuid},${sTeamId})",
                  srcDataset: "userinfo",
                  newDataset: "counter",
                  sSqlCondition:
                    "userinfo.sMachineGuid,userinfo.sTeamId.sTeamId"
                }
              ]
            },
            {
              opr: "ifdo",
              conditions: [
                {
                  conditionEmpty: "counter",
                  commands: [
                    {
                      opr: "newempty",
                      newDataset: "counter"
                    }
                  ]
                }
              ]
            },
            {
              opr: "edit",
              desDataset: "counter",
              sValue: "*"
            }
          ])
        },
        inscallback: nextProps => {
          const { counterData = [] } = nextProps;
          const [counterRow = {}] = counterData;
          const { table0 = 0, table1 = 0, table2 = 0, table3 = 0 } = counterRow;
          props.dispatch({
            type: "app/setCounter",
            payload: { table0, table1, table2, table3 }
          });
        }
      });
    },
    [sModelsId1]
  );
};

// 遍历出需要监听的form表单字段
const useGetMonitorFields = props => {
  const { bFinish } = props;
  useEffect(
    () => {
      if (!bFinish) return;

      // 过滤出所有config
      const configList = Object.keys(props)
        .filter(
          item => item.indexOf("Config") > -1 && props[item]?.gdsconfigformslave
        )
        .map(item => ({
          tablename: item.replace("Config", ""),
          config: props[item]
        }));

      // 过滤出含有sButtonEnabled配置的字段
      const monitorFieldsMap = configList.reduce((pre, item) => {
        const { tablename, config } = item;
        const configFilter = config.gdsconfigformslave.filter(
          item => item.sButtonEnabled
        );

        if (configFilter.length) {
          pre[tablename] = configFilter;
        }
        return pre;
      }, {});

      props.onSaveState({ monitorFieldsMap });
    },
    [bFinish]
  );
};

// 数据变化时根据monitorFieldsMap判读是否要修改对应表的显示隐藏
const useSetConfigStatus = props => {
  const { monitorFieldsMap = {} } = props;

  const monitorFields = Object.keys(monitorFieldsMap).reduce(
    (pre, tablename) => {
      const configList = monitorFieldsMap[tablename];
      const tableData = props[`${tablename}Data`] || [];
      const tableRowData = tableData[0] || {};
      pre[tablename] = [];
      configList.forEach(config => {
        const fieldValue = tableRowData[config.sName];
        pre[tablename].push(fieldValue === undefined ? "" : fieldValue);
      });
      return pre;
    },
    {}
  );

  useEffect(
    () => {
      if (commonUtils.isEmptyObject(monitorFields)) return;

      const monitorTableList = Object.keys(monitorFields);

      const sRulesJsonTotal = {
        showColumn: [],
        hideColumn: [],
        mustColumn: [],
        readOnlyColumn: []
      };

      monitorTableList.forEach(tablename => {
        const configs = monitorFieldsMap[tablename];
        const tableData = props[`${tablename}Data`] || [];
        const currentRecord = tableData[0] || {};
        configs.forEach(config => {
          const { sButtonEnabled: sButtonEnabledStr } = config;
          const sButtonEnabled = commonUtils.convertStrToObj(
            sButtonEnabledStr,
            []
          );

          sButtonEnabled.forEach(sButtonEnabledItem => {
            const {
              showColumn = [],
              hideColumn = [],
              mustColumn = [],
              readOnlyColumn = [],
              condition = []
            } = sButtonEnabledItem;

            let failFlag = false; // 未成功匹配标记
            for (let i = 0; i < condition.length; i++) {
              const conditionItem = condition[i];
              const { jsCondition } = conditionItem;
              if (jsCondition) {
                failFlag = !commonFunc.getEvalResult({
                  props,
                  str: jsCondition,
                  currentRecord,
                  defaultvalue: false
                });
                if (failFlag) {
                  break;
                }
              }
            }
            if (!failFlag) {
              sRulesJsonTotal.showColumn = [
                ...sRulesJsonTotal.showColumn,
                ...showColumn.map(
                  item => (item?.includes(".") ? item : `${tablename}.${item}`)
                )
              ];
              sRulesJsonTotal.hideColumn = [
                ...sRulesJsonTotal.hideColumn,
                ...hideColumn.map(
                  item => (item?.includes(".") ? item : `${tablename}.${item}`)
                )
              ];
              sRulesJsonTotal.mustColumn = [
                ...sRulesJsonTotal.mustColumn,
                ...mustColumn.map(
                  item => (item?.includes(".") ? item : `${tablename}.${item}`)
                )
              ];
              sRulesJsonTotal.readOnlyColumn = [
                ...sRulesJsonTotal.readOnlyColumn,
                ...readOnlyColumn.map(
                  item => (item?.includes(".") ? item : `${tablename}.${item}`)
                )
              ];
            }
          });
        });
      });

      // console.log("=====sRulesJsonTotal", sRulesJsonTotal);
      props.onSaveState({ sRulesJsonTotal });
    },
    [JSON.stringify(monitorFields)]
  );
};

const awaitPromiseReturn = async () => {
  let iCount = 0;
  await new Promise(resolve => setTimeout(resolve, 300));
  while (window.instructSetLock) {
    await new Promise(resolve => setTimeout(resolve, 100));
    console.log("等待执行", iCount);
    if (iCount > 30) break;
    iCount++;
  }
};

export default useCommonBase;