/* 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 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({});

  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 });

    // 班组报工特殊处理
    // if (state.sModelsId === "12710101117087404588200") {
    //   const { userinfo = {} } = app;
    //   const globalData = commonUtils.convertStrToObj(
    //     localStorage.xlybusinessglobalData
    //   );
    //   const iInterface =
    //     globalData.currentWorkOrderInfo?.iInterface || userinfo.iInterface;
    //   const iIndex = formData.findIndex(item => item.sGrd === "table1");
    //   if (iIndex !== -1) {
    //     const iIndex1 = formData[iIndex].gdsconfigformslave.findIndex(
    //       item => item.sName === "sBoardNo"
    //     );
    //     if (iIndex1 !== -1) {
    //       if (iInterface === 10) {
    //         // 包装的托盘计数信息托盘板号改为包装板号
    //         formData[iIndex].gdsconfigformslave[iIndex1].showName = "包装板号";
    //       } else if (iInterface === 9) {
    //         // 品检的托盘计数信息托盘板号改为质检板号
    //         formData[iIndex].gdsconfigformslave[iIndex1].showName = "质检板号";
    //       }
    //     }
    //   }
    // }

    handleSaveState({ formData });
  }, []);

  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) => {
    const cbState = {};
    if (typeof callback === "function") {
      cbState.callbackRefresh = callbackRefresh + 1;
      cbState.callback = callback;
    }
    dispatch(["saveState", { ...values, ...cbState }]);
  };

  /**
   * 获取模型配置
   * @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 configReturn = (await commonServices.getService(token, configUrl))
      .data;
    let formData = [];
    if (configReturn.code === 1) {
      const [configData] = configReturn.dataset.rows;
      formData = configData.formData;
    } else {
      getServiceError(configReturn);
    }
    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 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 (this.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];
              }
            }
          }
        }
      });
    }
    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 = (
    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 };
      }
    }
    if (isWait) {
      return { ...tableData[iIndex], ...changeValue, handleType };
    } else {
      const rowDataOld = JSON.parse(JSON.stringify(tableData[iIndex]));
      tableData[iIndex] = { ...tableData[iIndex], ...changeValue, handleType };
      handleSaveState(
        { [`${name}Data`]: tableData, sUseInfo: "" },
        nextProps => {
          costomPageFun({
            props: {
              ...nextProps,
              rowDataOld,
              onSaveState: handleSaveState,
              handleExecInstructSet
            },
            tableName: name,
            sFieldName,
            actionName: "mesTableChange"
          });
        }
      );
    }
  };

  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 } = returnData;
    if (code === 1) {
      message.success(msg);
      onSuccess && onSuccess(true);
    } 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;
    const dbclickPopConfig = tableConfig.gdsconfigformslave?.find(
      item =>
        item.sControlName && item.sControlName.toLowerCase() === "dbclickpop"
    );
    if (!dbclickPopConfig) return;

    let { sActiveId, sActiveName } = dbclickPopConfig;

    // 如果行数据里有sFormId， 则取sFormId作为弹窗的表单id
    const { sFormId, sMaintenanceLevel } = record;
    if (sFormId) {
      if (!sMaintenanceLevel) return;

      sActiveId = sFormId;
      sActiveName = sMaintenanceLevel;
      if (sMaintenanceLevel === "日常保养") {
        sActiveName = "设备日保养";
      } else if (
        sMaintenanceLevel === "一级保养" ||
        sMaintenanceLevel === "1级保养"
      ) {
        sActiveName = "设备一级保养";
      }

      if (
        ["101251240115016050003838930", "12710101117207650035150"].includes(
          sFormId
        )
      ) {
        sActiveId = "17102090670002643282020454509600";
      }
    }

    if (sActiveId) {
      // 获取sqlCondition值
      const sParentConditions = getSqlCondition(dbclickPopConfig, name, record);

      // 弹窗展示
      props.onOpenCommonModal({
        type: "commonModal",
        sActiveId,
        title: sActiveName,
        sParentConditions,
        parentProps: {
          ...returnProps
        },
        onOk: data => {
          console.log("=====onOk", data);
        },
        onCancel: () => {
          console.log("=====onCancel");
        }
      });
    }
  };

  // 通用表格行按钮操作
  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 = ({ tableName, config, record }) => {
    const { sActiveId, sActiveName } = config;
  };

  // 合并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 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
  };

  // 切换页面时，加载角标数据
  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;