qiangmj / ebc-Mes

/**
 * Created by mar105 on 2019-02-25.
 */
/* eslint-disable */
import { message, Modal } from 'antd';
import moment from 'moment';
import * as commonUtils from '../../utils/utils';
import * as commonFunc from './commonFunc'; /* 通用单据方法 */
import * as commonConfig from '../../utils/config';
import * as commonServices from '../../services/services';
import imgCheck from '../../assets/hasChecked.svg'; /* 已审核ICON */
import imgInvalid from '../../assets/haveCancel.png'; /* 已作废ICON */
import imgChecking from '../../assets/haveChecking.svg'; /* 审核中 */

// -----------------------------------------------------------------------

/** 验证表格数据是否正确 */
export function validateTable(configData, validateData, props, key) {
  let bResult = true;
  if (commonUtils.isNotEmptyArr(configData) && commonUtils.isNotEmptyArr(validateData)) {
    const notEmptyConfigData = configData.gdsconfigformslave.filter(item => item.bNotEmpty && item.sName !== '');
    const notZeroConfigData = configData.gdsconfigformslave.filter(item => item.bNotZero && item.sName !== '');
    for (const row of validateData) {
      for (const item of notEmptyConfigData) {
        this.firstDataIndex = commonUtils.isNotEmptyObject(item.sName) ? item.sName.substring(0, 1) : ''; /*   控件首字母(数据格式:字符串)   */
        if (commonUtils.isEmpty(row[item.sName])) {
          message.error(item.showName + commonFunc.showMessage(props.app.commonConst, 'isNotNull')); // 从表不能为空！
          if (commonUtils.isNotEmptyObject(props) && commonUtils.isNotEmptyObject(key)) {
            props.onSaveState({ activeKey: key, loading: false });
          }
          bResult = false;
          break;
        } else if (commonUtils.isNotEmptyObject(item.sName) && item.sName.toLowerCase().endsWith('price')) {
          if (row[item.sName] === 0) {
            message.error(item.showName + commonFunc.showMessage(props.app.commonConst, 'isNotZero')); // 不能为0！
            if (commonUtils.isNotEmptyObject(props) && commonUtils.isNotEmptyObject(key)) {
              props.onSaveState({ activeKey: key, loading: false });
            }
            bResult = false;
            break;
          }
        } else if (commonUtils.isNotEmptyObject(item.sName) && item.sName === 'dSinglePQty' && commonUtils.isNotEmptyNumber(row.iPrintMode) && row.iPrintMode !== 4) {
          const { masterData } = props;
          if (row[item.sName] === 0 && commonUtils.isNotEmptyObject(masterData) && !masterData.bBillOutside) {
            message.error(item.showName + commonFunc.showMessage(props.app.commonConst, 'isNotZero')); // 不能为0！
            if (commonUtils.isNotEmptyObject(props) && commonUtils.isNotEmptyObject(key)) {
              props.onSaveState({ activeKey: key, loading: false });
            }
            bResult = false;
            break;
          }
        }
      }
      for (const item of notZeroConfigData) {
        this.firstDataIndex = commonUtils.isNotEmptyObject(item.sName) ? item.sName.substring(0, 1) : ''; /*   控件首字母(数据格式:字符串)   */
        if (bResult && (this.firstDataIndex === 'i' || this.firstDataIndex === 'd') && (commonUtils.isEmpty(row[item.sName]) || row[item.sName] === 0)) {
          message.error(item.showName + commonFunc.showMessage(props.app.commonConst, 'isNotZeroNull')); // 数字型不能为空或为0！
          if (commonUtils.isNotEmptyObject(props) && commonUtils.isNotEmptyObject(key)) {
            props.onSaveState({ activeKey: key, loading: false });
          }
          bResult = false;
          break;
        }
      }
      if (!bResult) break;
    }
  }
  return bResult;
}

/** 验证表格数据是否正确 */
export function validateMaster(configData, validateObj, props, key) {
  let bResult = true;
  const validateData = commonUtils.isNotEmptyObject(validateObj) ? [validateObj] : [];
  if (commonUtils.isNotEmptyArr(configData) && commonUtils.isNotEmptyArr(validateData)) {
    const notEmptyConfigData = configData.gdsconfigformslave.filter(item => item.bNotEmpty && item.bVisible && item.sName !== '');
    const notZeroConfigData = configData.gdsconfigformslave.filter(item => item.bNotZero && item.bVisible && item.sName !== '');
    for (const row of validateData) {
      for (const item of notEmptyConfigData) {
        this.firstDataIndex = commonUtils.isNotEmptyObject(item.sName) ? item.sName.substring(0, 1) : ''; /*   控件首字母(数据格式:字符串)   */
        if (commonUtils.isEmpty(row[item.sName])) {
          message.error(item.showName + commonFunc.showMessage(props.app.commonConst, 'isNotNull')); // 从表不能为空！
          if (commonUtils.isNotEmptyObject(props) && commonUtils.isNotEmptyObject(key)) {
            props.onSaveState({ activeKey: key, loading: false });
          }
          bResult = false;
          break;
        } else if (commonUtils.isNotEmptyObject(item.sName) && item.sName.toLowerCase().endsWith('price')) {
          if (row[item.sName] === 0) {
            message.error(item.showName + commonFunc.showMessage(props.app.commonConst, 'isNotZero')); // 不能为0！
            if (commonUtils.isNotEmptyObject(props) && commonUtils.isNotEmptyObject(key)) {
              props.onSaveState({ activeKey: key, loading: false });
            }
            bResult = false;
            break;
          }
        } else if (commonUtils.isNotEmptyObject(item.sName) && item.sName === 'dSinglePQty' && commonUtils.isNotEmptyNumber(row.iPrintMode) && row.iPrintMode !== 4) {
          const { masterData } = props;
          if (row[item.sName] === 0 && commonUtils.isNotEmptyObject(masterData) && !masterData.bBillOutside) {
            message.error(item.showName + commonFunc.showMessage(props.app.commonConst, 'isNotZero')); // 不能为0！
            if (commonUtils.isNotEmptyObject(props) && commonUtils.isNotEmptyObject(key)) {
              props.onSaveState({ activeKey: key, loading: false });
            }
            bResult = false;
            break;
          }
        }
      }
      for (const item of notZeroConfigData) {
        this.firstDataIndex = commonUtils.isNotEmptyObject(item.sName) ? item.sName.substring(0, 1) : ''; /*   控件首字母(数据格式:字符串)   */
        if (bResult && (this.firstDataIndex === 'i' || this.firstDataIndex === 'd') && (commonUtils.isEmpty(row[item.sName]) || row[item.sName] === 0)) {
          message.error(item.showName + commonFunc.showMessage(props.app.commonConst, 'isNotZeroNull')); // 数字型不能为空或为0！
          if (commonUtils.isNotEmptyObject(props) && commonUtils.isNotEmptyObject(key)) {
            props.onSaveState({ activeKey: key, loading: false });
          }
          bResult = false;
          break;
        }
      }
      if (!bResult) break;
    }
  }
  return bResult;
}

/** 验证字段是否合规 如身份号码、手机号码 */
export function validateField(values, props) {
  let bResult = true;
  const { sMobile, sIdCard } = values;
  if (commonUtils.isNotEmptyObject(sMobile) && !(/^1\d{10}$/.test(sMobile))) {
    message.error(commonFunc.showMessage(props.app.commonConst, 'phoneErr')); // 手机号码输入不合规！
    bResult = false;
  }
  const isIDCard2 = /(^\d{15}$)|(^\d{18}$)|(^\d{17}(\d|X|x)$)/;
  if (commonUtils.isNotEmptyObject(sIdCard) && !isIDCard2.test(sIdCard)) {
    message.error(commonFunc.showMessage(props.app.commonConst, 'sIdCardErr')); /* 身份证号码输入不合规 */
    bResult = false;
  }
  if (!bResult) {
    props.onSaveState({ loading: false });
  }
  return bResult;
}
/** 添加审核或者作废图标 */
// eslint-disable-next-line no-unused-vars
export function handleAddIcon(masterData, sModelsType) {
  let imgSrc = '';
  if (commonUtils.isNotEmptyObject(masterData)) {
    const { bInvalid, bCheck, sStatus } = masterData;
    if (bInvalid) {
      imgSrc = imgInvalid;
    } else if (bCheck) {
      if (commonUtils.isNotEmptyStr(sModelsType) && sModelsType.includes('element/')) {
        if (sModelsType.includes('element/customerInfo')) {
          imgSrc = imgCheck;
        } else {
          imgSrc = '';
        }
      } else {
        imgSrc = imgCheck;
      }
    } else if (sStatus === '2') {
      imgSrc = imgChecking;
    }
  }
  return imgSrc;
}

/** 保存数据 */
export async function saveData(param) {
  const {
    token, value, sModelsId, bMachineTask,
  } = param;
  const { optName } = value;
  const dataReturn = (await commonServices.postValueService(
    token, value,
    `${commonConfig.server_host}business/addUpdateDelBusinessData?sModelsId=${sModelsId}`,
  )).data;
  if (bMachineTask) return dataReturn;
  /*   成功的话返回数据   */
  if (dataReturn.code === 1) { /*   成功   */
    message.destroy();
    if (commonUtils.isEmpty(optName)) {
      message.success(dataReturn.msg);
    } else {
      message.success(optName + dataReturn.msg);
    }
    return dataReturn;
  } else if (dataReturn.code === 2) {
    Modal.info({
      // title: '温馨提示',
      content: (
        // eslint-disable-next-line react/react-in-jsx-scope
        <div>
          {dataReturn.msg}
        </div>
      ),
      onOk() {},
    });
  } else if (dataReturn.code === -7) { /* 防呆校验 返回是-7 */
    return dataReturn;
  } else { /*   失败   */
    message.error(dataReturn.msg);
    return false;
  }
}


/** 处理数据格式
 * sTbName 表名
 * saveTmpData 表单数据
 * delTmpData 表单删除数据
 * bAll 不过滤增加数据还是修改数据 */
export function mergeData(name, sTbName, saveTmpData, delTmpData, bAll) {
  const delData = commonUtils.isEmptyArr(delTmpData) ? [] : delTmpData;
  const savesData = commonUtils.isEmptyArr(saveTmpData) ? [] : saveTmpData;
  const returnData = bAll ? savesData : savesData.filter(item => item.handleType === 'add' || item.handleType === 'update');
  if (commonUtils.isNotEmptyArr(returnData)) {
    returnData.forEach((item) => { delete item.iIncrement; });
  }
  return { name, sTable: sTbName, column: [...returnData, ...delData] };
}

/** 处理表格传入数据格式 */
export function getTableTypes(name, props) {
  const returnTypes = {
    name,
    app: props.app,
    formId: props.sModelsId,
    getSqlDropDownData: props.getSqlDropDownData,
    getSqlCondition: props.getSqlCondition,
    handleSqlDropDownNewRecord: props.handleSqlDropDownNewRecord,
    getFloatNum: props.getFloatNum,
    getDateFormat: props.getDateFormat,
    onDataChange: props.onDataChange,
    onUploadChange: props.onUploadChange,
    onBeforeUpload: props.onBeforeUpload,
    onModalCancel: props.onModalCancel,
    onLookRow: props.onDataRowLook,
    onAddRow: props.onDataRowAdd,
    onModalRow: props.onDataRowModal,
    onBtnChoose: props.onBtnChoose,
    onCopyRow: props.onDataRowCopy,
    onCopyAllRow: props.onDataRowCopyAll,
    onDelRow: props.onDataRowDel,
    onDownloadRow: props.onDataRowDownload,
    onShowParamRow: props.onDataRowShowParam,
    onSelectRowChange: props.onTableSelectRowChange,
    onDoubleClick: props.onDoubleClick,
    onDoubleClickNew: props.onDoubleClickNew,
    onViewClick: props.onViewClick,
    onFieldDoubleClick: props.onFieldDoubleClick, /* 字段双击弹出 */
    onDropDownBlur: props.onDropDownBlur,
    onViewChoose: props.onViewChoose,
    onContextMenu: props.onContextMenu,
    onExpand: props.onExpand,
    onRowMove: props.onRowMove,
    onSaveState: props.onSaveState,
    onSelectCommonPopup: props.onSelectCommonPopup,
    onSelectCommonPopupProduct: props.onSelectCommonPopupProduct,
    onSelectDialog: props.onSelectDialog,
    onPartNameClick: props.onPartNameClick, /* 生产排程工艺流程字段弹窗 - 生产进度详情 */
    onCheckChange: props.onCheckParamChange,
    // OnGetFilterData: props.OnGetFilterData,
    selectedRowKeys: props[`${name}SelectedRowKeys`],
    expKeys: props.expKeys,
    // headerColumn: props[`${name}Column`],
    headerColumn: commonUtils.isNotEmptyArr(props[`${name}GroupColumn`]) ? props[`${name}GroupColumn`] : props[`${name}Column`],
    config: props[`${name}Config`],
    data: props[`${name}Data`],
    totalData: props[`${name}Total`],
    totalData1: props[`${name}Total1`],
    enabled: props.enabled,
    rowSelectionType: 'checkbox', // 表格选择是单选还是多选择
    tableProps: {}, // 表格属性
    isKeyUsesId: true, // 表格是否使用sId作为key 如果不传就是随机
    previewImage: props.previewImage, /* 预览图片地址 */
    previewVisible: props.previewVisible, /* 图片预览弹窗 */
    bMutiSelect: commonUtils.isEmptyArr(props[`${name}Config`]) ? false : props[`${name}Config`].bMutiSelect, /* 表格是否多选 */
    bisMutiSelect: commonUtils.isNotEmptyObject(props[`${name}Config`]) && commonUtils.isNotEmptyArr(props[`${name}Config`].gdsconfigformslave) && commonUtils.isNotEmptyArr(props[`${name}Config`].gdsconfigformslave.filter(item => item.sControlName === 'bisMutiSelect')) ? props[`${name}Config`].gdsconfigformslave.filter(item => item.sControlName === 'bisMutiSelect')[0].bVisible : false, /* 表格是否显示多选框 */
    isDragAndDrop: false, // 是否可以进行可以行移动
    onFilterDropDownData: props.onFilterDropDownData,
    sUseInfo: props.sUseInfo,
    dispatch: props.dispatch,
    sortedInfo: props.sortedInfo || {},
    bPagination: commonUtils.isEmptyArr(props[`${name}Config`]) ? true : props[`${name}Config`].bPagination, /* 表格是否分页 默认分页 */
    realizeHeight: commonUtils.isEmpty(props.realizeHeight) ? 0 : props.realizeHeight, /* Modal拖动向下偏移高度 */

    onMesTableLineAdd: props.onMesTableLineAdd,
    onMesTableLineDel: props.onMesTableLineDel,
    onMesTableLineCopy: props.onMesTableLineCopy,
    onMergeTableConfig: props.onMergeTableConfig,
    parentProps: props,
  };
  return returnTypes;
}

/** 处理表单传入数据格式 */
export function getShowTypes(name, props) {
  return {
    name,
    bTable: true,
    bViewTable: true,
    enabled: true,
    formItemLayout: {
      labelCol: {
        flex: '120px',
      },
      wrapperCol: { flex: "auto" }
    },
    getSqlDropDownData: props.getSqlDropDownData,
    getSqlCondition: props.getSqlCondition,
    handleSqlDropDownNewRecord: props.handleSqlDropDownNewRecord,
    getFloatNum: props.getFloatNum,
    getDateFormat: props.getDateFormat,
    // onChange: props.onChange,
    onChange: () => {},
    formRoute: props.formRoute,
  }
}

/**   结算日期计算   */
export function getGeyPayDate(masterData) {
  /*   待用数据声明   */
  const {
    tDeliverDate, sGetPayType, iMonth, iDay, iAfterDeliverDay, tInvoiceDate,
  } = masterData; /*   再从主表中取到需要用的数据   */
  let { tCreateDate } = masterData;
  let tCreateDateValue = commonUtils.convertObjToMomentDefault(tCreateDate, commonUtils.dateFormatA); /*   格式化日期   */
  let tDeliverDateValue = commonUtils.convertObjToMomentDefault(tDeliverDate, commonUtils.dateFormatA); /*   格式化日期   */
  if (commonUtils.isNotEmptyObject(tInvoiceDate)) { /*  销售对账，采购对账若设置开票日期，则根据开票日期计算   */
    tCreateDateValue = tInvoiceDate;
    tDeliverDateValue = tInvoiceDate;
    tCreateDate = moment(tInvoiceDate).format(commonUtils.dateFormatA);
  }
  /*   存在结算类型,那么才做相应的处理   */
  if (commonUtils.isNotEmptyStr(sGetPayType)) {
    /*   待用数据声明   */
    let tGetPayDate = '';
    /*   结算方式   */
    if (sGetPayType === 'now') { /*   现结()   */
      tGetPayDate = tCreateDateValue;
    } else if (sGetPayType === 'month') { /*   月结(当前天大于月结天的向后顺延一个月)   */
      tGetPayDate = moment(tCreateDate).add(iMonth, 'months').format(commonUtils.dateFormatA);
      let tDate = commonUtils.convertObjToMomentDefault(tGetPayDate, commonUtils.dateFormatA);
      tDate = moment(tDate).add(1, 'months').format(commonUtils.dateFormatA);
      tDate = moment(tDate).set('date', 1).format(commonUtils.dateFormatA);
      tDate = moment(tDate).add(-1, 'days').format(commonUtils.dateFormatA);
      const iEndDay = moment(tDate).get('date');
      tGetPayDate = moment(tGetPayDate).set('date', iEndDay > iDay ? iDay : iEndDay);

      const tCurrentDay = moment(tCreateDate).get('date'); /* 当前Day */
      if (tCurrentDay <= iDay) {
        tGetPayDate = moment(tGetPayDate).format(commonUtils.dateFormatA);
      } else {
        tGetPayDate = moment(tGetPayDate).add(1, 'months').format(commonUtils.dateFormatA);
      }
    } else if (sGetPayType === 'deliver') { /*   按送货日期来   */
      tGetPayDate = moment(tDeliverDateValue).add(iAfterDeliverDay, 'days').format(commonUtils.dateFormatA);
    }
    return tGetPayDate;
  }
  /*   返回值   */
  return masterData.tGetPayDate;
}

/**   输入数量, 价格, 税码, 计算计算金额，不含税金额，不含税价格，税额，外币金额，外币税额   */
export function getCalculateByPrice(app, type, masterData, tableDataRow, sFieldName) {
  /*   执行条件   */
  /*   待用数据赋值   */
  const { dNetPrice, dNetMoney } = app.decimals;
  const { sModelsType } = app.currentPane;
  const dProductQty = commonUtils.convertToNum(tableDataRow[`d${type}Qty`]); /* 数量 */
  const dProductPrice = commonUtils.convertToNum(tableDataRow[`d${type}Price`]); /* 价格 */
  const dProductForeignPrice = commonUtils.convertToNum(tableDataRow[`d${type}ForeignPrice`]); /* 外币单价 */
  const dNProductPrice = commonUtils.convertToNum(tableDataRow[`dN${type}Price`]); /* 产品价格 */
  let dProductForeignMoney = commonUtils.convertToNum(tableDataRow[`d${type}ForeignMoney`]); /* 外币金额 */
  let dProductMoney = commonUtils.convertToNum(tableDataRow[`d${type}Money`]); /* 本币金额 */
  const dLossMoney = commonUtils.convertToNum(tableDataRow.dLossMoney); /* 报损金额 */

  const dTaxRate = commonUtils.convertToNum(tableDataRow.dTaxRate); /* 税率 */
  let dCurrencyRate = commonUtils.convertIsNotNumToNumber1(masterData.dCurrencyRate); /* 汇率 */
  /* 报价单模块，工单模块、产品工艺卡 汇率取从表 */
  if (commonUtils.isNotEmptyObject(sModelsType) && (sModelsType.includes('manufacture/') || sModelsType.includes('quotation/') || sModelsType.includes('processCard'))) {
    dCurrencyRate = commonUtils.convertIsNotNumToNumber1(tableDataRow.dCurrencyRate); /* 汇率 */
  }
  if (sFieldName === `d${type}ForeignPrice`) {
    dProductForeignMoney = commonUtils.convertFixNum(dProductQty * dProductForeignPrice, dNetMoney); /* 外币金额 */
    dProductMoney = commonUtils.convertFixNum(dCurrencyRate !== 0 ? dProductForeignMoney * dCurrencyRate : 0, dNetMoney); /* 金额 */
  } else {
    dProductMoney = commonUtils.convertFixNum(dProductQty * dProductPrice, dNetMoney); /* 金额 */
    dProductForeignMoney = commonUtils.convertFixNum(dCurrencyRate !== 0 ? dProductMoney / dCurrencyRate : 0, dNetMoney); /* 外币金额 */
  }
  const dNProductMoney = commonUtils.convertFixNum(dProductQty * dNProductPrice, dNetMoney); /* 产品金额 */
  const dProductNoTaxMoney = commonUtils.convertFixNum(dProductMoney / (1 + (dTaxRate / 100)), dNetMoney); /* 不含税金额 */
  const dProductNoTaxPrice = commonUtils.convertFixNum(dProductQty !== 0 ? dProductNoTaxMoney / dProductQty : 0, dNetPrice); /* 不含税价 */
  const dProductTaxMoney = commonUtils.convertFixNum(dProductMoney - dProductNoTaxMoney, dNetMoney); /* 税额 */

  const dProductTaxForeignMoney = commonUtils.convertFixNum(dCurrencyRate !== 0 ? dProductTaxMoney / dCurrencyRate : 0, dNetMoney); /* 外币税额 */

  /* 采购对账, 发外对账中改变数量与金额 同步dNSrcNoMoney = 单价*数量 */
  const dSrcNoCheckMoney = commonUtils.convertFixNum(dProductQty * dProductPrice, dNetMoney); /* 金额 */

  if (commonUtils.isNotEmptyNumber(dLossMoney)) { /* 减去报损 重新算金额 */
    tableDataRow = getCalculateMoneyByLossMoney(app, type, masterData, tableDataRow, dSrcNoCheckMoney, dLossMoney); /*  dSrcNoCheckMoney = dLossMoney 重新算外币金额 */
    dProductForeignMoney = tableDataRow[`d${type}ForeignMoney`];
    dProductMoney = tableDataRow[`d${type}Money`];
  }
  /*   数据赋值   */

  if (tableDataRow.bSalesMaterials) { /* 材料销售 */
    type = 'Product';
  }
  if (sFieldName !== `d${type}Money`) {
    tableDataRow[`d${type}Money`] = commonUtils.convertFixNum(dProductMoney, dNetMoney);
  }
  if (sFieldName !== `dN${type}Money`) {
    tableDataRow[`dN${type}Money`] = commonUtils.convertFixNum(dNProductMoney, dNetMoney);
  }
  if (sFieldName !== `d${type}NoTaxMoney`) {
    tableDataRow[`d${type}NoTaxMoney`] = commonUtils.convertFixNum(dProductNoTaxMoney, dNetMoney);
  }
  if (sFieldName !== `d${type}NoTaxPrice`) {
    tableDataRow[`d${type}NoTaxPrice`] = commonUtils.convertFixNum(dProductNoTaxPrice, dNetPrice);
  }
  if (sFieldName !== `d${type}TaxMoney`) {
    tableDataRow[`d${type}TaxMoney`] = commonUtils.convertFixNum(dProductTaxMoney, dNetMoney);
  }
  if (sFieldName !== `d${type}ForeignMoney`) {
    tableDataRow[`d${type}ForeignMoney`] = commonUtils.convertFixNum(dProductForeignMoney, dNetMoney);
  }
  if (sFieldName !== `d${type}TaxForeignMoney`) {
    tableDataRow[`d${type}TaxForeignMoney`] = commonUtils.convertFixNum(dProductTaxForeignMoney, dNetMoney);
  }
  if (sFieldName !== 'dSrcNoCheckMoney') {
    tableDataRow.dSrcNoCheckMoney = commonUtils.convertFixNum(dSrcNoCheckMoney, dNetMoney);
  }
  /*   返回值   */
  return tableDataRow;
}

/**   输入数量, 价格, 税码, 计算计算金额，不含税金额，不含税价格，税额，外币金额，外币税额   */
export function getCalculateByPriceNew(app, type, masterData, tableDataRow, sFileName) {
  /*   执行条件   */
  /*   待用数据赋值   */
  const { dNetPrice, dNetMoney } = app.decimals;
  const { sModelsType } = app.currentPane;
  const dProductQty = commonUtils.convertToNum(tableDataRow[`d${type}Qty`]); /* 数量 */
  const dProofingMoney = commonUtils.convertToNum(tableDataRow.dProofingMoney); /* 打样金额 */
  const dPlateMoney = commonUtils.convertToNum(tableDataRow.dPlateMoney); /* 制版金额 */
  const dKnifeMouldMoney = commonUtils.convertToNum(tableDataRow.dKnifeMouldMoney); /* 刀模金额 */
  let dProductForeignPrice = commonUtils.convertToNum(tableDataRow[`d${type}ForeignPrice`]); /* 外币单价 */
  let dNProductPrice = commonUtils.convertToNum(tableDataRow[`dN${type}Price`]); /* 产品价格 */
  let dProductPrice = commonUtils.convertToNum(tableDataRow[`d${type}Price`]); /* 本币单价 */
  let dProductForeignMoney = commonUtils.convertToNum(tableDataRow[`d${type}ForeignMoney`]);
  let dProductMoney = commonUtils.convertToNum(tableDataRow[`d${type}Money`]); /* 本币金额 */
  const dTaxRate = commonUtils.convertToNum(tableDataRow.dTaxRate); /* 税率 */
  let dCurrencyRate = commonUtils.convertIsNotNumToNumber1(masterData.dCurrencyRate); /* 汇率 */
  const dLossMoney = commonUtils.convertToNum(tableDataRow.dLossMoney); /* 报损金额 */
  /* 报价单模块，工单模块、产品工艺卡 汇率取从表 */
  if (commonUtils.isNotEmptyObject(sModelsType) && (sModelsType.includes('manufacture/') || sModelsType.includes('quotation/') || sModelsType.includes('processCard'))) {
    dCurrencyRate = commonUtils.convertIsNotNumToNumber1(tableDataRow.dCurrencyRate); /* 汇率 */
  }
  let dNProductMoney = commonUtils.convertFixNum(dProductQty * dNProductPrice, dNetMoney); /* 产品金额 */
  const dOtherMoney = commonUtils.convertFixNum(dProofingMoney + dPlateMoney + dKnifeMouldMoney, dNetMoney); /* 打样金额+制版金额+刀模金额 */
  if (sFileName === `dN${type}Price` || sFileName === `d${type}Qty`) {
    if (dProductQty === 0) {
      dProductForeignPrice = dNProductPrice !== 0 ? dNProductPrice : 0;
      dProductForeignMoney = 0;
    } else if (dOtherMoney > 0) {
      dProductForeignMoney = commonUtils.convertFixNum(dNProductMoney + dProofingMoney + dPlateMoney + dKnifeMouldMoney, dNetMoney); /* 外币金额 */
      dProductForeignPrice = dProductQty !== 0 ? commonUtils.convertFixNum(dProductForeignMoney / dProductQty, dNetPrice) : 0;
    } else if (dOtherMoney === 0) { /* 若其他费用为0 则产品单价=外币单价，产品金额=外币金额 */
      if (sFileName === `dN${type}Price`) {
        dProductForeignPrice = dNProductPrice;
      }
      dProductForeignMoney = commonUtils.convertFixNum(dProductQty * dProductForeignPrice, dNetMoney); /* 外币金额 */
    }
  } else if (sFileName === `d${type}ForeignPrice`) {
    dProductForeignMoney = commonUtils.convertFixNum(dProductQty * dProductForeignPrice, dNetMoney); /* 外币金额 */
    dNProductMoney = commonUtils.convertFixNum(dProductForeignMoney - dProofingMoney - dPlateMoney - dKnifeMouldMoney, dNetMoney);
    dNProductPrice = dProductQty !== 0 ? commonUtils.convertFixNum(dNProductMoney / dProductQty, dNetPrice) : dProductForeignPrice;
  } else if (sFileName === `d${type}Price`) {
    if (dProductQty === 0) {
      dProductForeignPrice = dProductPrice !== 0 ? commonUtils.convertFixNum(dCurrencyRate !== 0 ? dProductPrice / dCurrencyRate : 0, dNetPrice) : 0;
      dNProductPrice = dProductForeignPrice;
    } else {
      dProductMoney = commonUtils.convertFixNum(dProductQty * dProductPrice, dNetMoney);
      dProductForeignMoney = commonUtils.convertFixNum(dCurrencyRate !== 0 ? dProductMoney / dCurrencyRate : 0, dNetMoney);
      dProductForeignPrice = commonUtils.convertFixNum(dProductForeignMoney / dProductQty, dNetPrice);
      dNProductMoney = commonUtils.convertFixNum(dProductForeignMoney - dProofingMoney - dPlateMoney - dKnifeMouldMoney, dNetMoney);
      dNProductPrice = commonUtils.convertFixNum(dNProductMoney / dProductQty, dNetPrice);
    }
  }
  if (sFileName !== `d${type}Price` && sFileName !== `d${type}Money`) {
    dProductMoney = commonUtils.convertFixNum(dCurrencyRate !== 0 ? dProductForeignMoney * dCurrencyRate : 0, dNetMoney); /* 金额 */
    dProductPrice = dProductQty !== 0 && dOtherMoney > 0 ? commonUtils.convertFixNum(dProductMoney / dProductQty, dNetPrice) : commonUtils.convertFixNum(dCurrencyRate !== 0 ? dProductForeignPrice * dCurrencyRate : 0, dNetPrice); /* 本位币单价 */
  }
  /* 销售对账 改变数量与金额 同步dNSrcNoMoney = 外币金额 */
  const dSrcNoCheckMoney = dProductForeignMoney; /* 金额 */
  if (commonUtils.isNotEmptyNumber(dLossMoney)) { /* 减去报损 重新算金额 */
    tableDataRow = getCalculateMoneyByLossMoney(app, type, masterData, tableDataRow, dSrcNoCheckMoney, dLossMoney); /*  dSrcNoCheckMoney = dLossMoney 重新算外币金额 */
    dProductForeignMoney = tableDataRow[`d${type}ForeignMoney`];
    dProductMoney = tableDataRow[`d${type}Money`];
  }

  const dProductNoTaxMoney = commonUtils.convertFixNum(dProductMoney / (1 + (dTaxRate / 100)), dNetMoney); /* 不含税金额 */
  const dProductNoTaxPrice = commonUtils.convertFixNum(dProductQty !== 0 ? dProductNoTaxMoney / dProductQty : 0, dNetPrice); /* 不含税价 */
  const dProductTaxMoney = commonUtils.convertFixNum(dProductMoney - dProductNoTaxMoney, dNetMoney); /* 税额 */
  // dProductForeignMoney = commonUtils.convertFixNum(dCurrencyRate !== 0 ? dProductMoney / dCurrencyRate : 0, dNetMoney); /* 外币金额 */
  const dProductTaxForeignMoney = commonUtils.convertFixNum(dCurrencyRate !== 0 ? dProductTaxMoney / dCurrencyRate : 0, dNetMoney); /* 外币税额 */
  /*   数据赋值   */
  if (sFileName !== `d${type}Price`) {
    tableDataRow[`d${type}Price`] = dProductPrice;
  }
  if (sFileName !== `dN${type}Price`) {
    tableDataRow[`dN${type}Price`] = dNProductPrice;
  }
  if (sFileName !== `d${type}ForeignPrice`) {
    tableDataRow[`d${type}ForeignPrice`] = dProductForeignPrice;
  }
  if (sFileName !== `d${type}Money`) {
    tableDataRow[`d${type}Money`] = commonUtils.convertFixNum(dProductMoney, dNetMoney);
  }
  if (sFileName !== `dN${type}Money`) {
    tableDataRow[`dN${type}Money`] = commonUtils.convertFixNum(dNProductMoney, dNetMoney);
  }
  if (sFileName !== `d${type}NoTaxMoney`) {
    tableDataRow[`d${type}NoTaxMoney`] = commonUtils.convertFixNum(dProductNoTaxMoney, dNetMoney);
  }
  if (sFileName !== `d${type}NoTaxPrice`) {
    tableDataRow[`d${type}NoTaxPrice`] = commonUtils.convertFixNum(dProductNoTaxPrice, dNetPrice);
  }
  if (sFileName !== `d${type}TaxMoney`) {
    tableDataRow[`d${type}TaxMoney`] = commonUtils.convertFixNum(dProductTaxMoney, dNetMoney);
  }
  if (sFileName !== `d${type}ForeignMoney`) {
    tableDataRow[`d${type}ForeignMoney`] = commonUtils.convertFixNum(dProductForeignMoney, dNetMoney);
  }
  if (sFileName !== `d${type}TaxForeignMoney`) {
    tableDataRow[`d${type}TaxForeignMoney`] = commonUtils.convertFixNum(dProductTaxForeignMoney, dNetMoney);
  }
  if (sFileName !== 'dSrcNoCheckMoney') {
    tableDataRow.dSrcNoCheckMoney = commonUtils.convertFixNum(dSrcNoCheckMoney, dNetMoney);
  }
  /*   返回值   */
  return tableDataRow;
}

/**   输入报损数量   */
export function getCalculatedLossMoney(app, masterData, tableDataRow, type) {
  /*   执行条件   */
  /*   待用数据赋值   */
  const { dNetMoney } = app.decimals;
  const dLossQty = commonUtils.convertToNum(tableDataRow.dLossQty); /* 报损换算数量 */
  const dProductPrice = commonUtils.convertToNum(tableDataRow[`d${type}Price`]);
  const dLossMoney = commonUtils.convertFixNum(dLossQty * dProductPrice, dNetMoney);
  const dProductQty = commonUtils.convertToNum(tableDataRow.dProductQty); /* 数量 */
  const dTaxRate = commonUtils.convertToNum(tableDataRow.dTaxRate); /* 税率   */
  /*   数据赋值   */
  tableDataRow.dLossMoney = commonUtils.convertFixNum(dLossMoney, dNetMoney);
  const dCurrencyRate = commonUtils.convertIsNotNumToNumber1(masterData.dCurrencyRate); /* 汇率 */
  const dSrcNoCheckMoney = commonUtils.isNull(tableDataRow.dSrcNoCheckMoney, 0);
  if (commonUtils.isNotEmptyNumber(dSrcNoCheckMoney) && commonUtils.isNotEmptyNumber(dLossMoney)) {
    const dMoney = commonUtils.convertFixNum(dSrcNoCheckMoney - dLossMoney, dNetMoney);
    if (type === 'Product') {
      const dProductMoney = commonUtils.convertFixNum(dCurrencyRate !== 0 ? dMoney * dCurrencyRate : 0, dNetMoney); /* 本位币金额 */
      tableDataRow.dProductForeignMoney = dMoney;/* 产品外币金额 = 源单金额 - 报损金额 */
      tableDataRow.dProductMoney = dProductMoney;/* 产品金额 = 产品外币金额 * 汇率 */
      const dProductNoTaxMoney = commonUtils.convertFixNum(dProductMoney / (1 + (dTaxRate / 100)), dNetMoney); /* 不含税金额 */
      const dProductNoTaxPrice = commonUtils.convertFixNum(dProductQty !== 0 ? dProductNoTaxMoney / dProductQty : 0, dNetMoney); /* 不含税价 */
      const dProductTaxMoney = commonUtils.convertFixNum(dProductMoney - dProductNoTaxMoney, dNetMoney); /* 税额 */
      const dProductTaxForeignMoney = commonUtils.convertFixNum(dCurrencyRate !== 0 ? dProductTaxMoney / dCurrencyRate : 0, dNetMoney); /* 外币税额 */
      tableDataRow.dProductNoTaxMoney = dProductNoTaxMoney; /* 不含税金额 */
      tableDataRow.dProductNoTaxPrice = dProductNoTaxPrice; /* 不含税价 */
      tableDataRow.dProductTaxMoney = dProductTaxMoney; /* 税额 */
      tableDataRow.dProductTaxForeignMoney = dProductTaxForeignMoney; /* 外币税额 */
    } else if (type === 'Materials') {
      tableDataRow[`d${type}Money`] = dMoney;/* 产品金额 = 产品外币金额 * 汇率 */
      const dProductNoTaxMoney = commonUtils.convertFixNum(dMoney / (1 + (dTaxRate / 100)), dNetMoney); /* 不含税金额 */
      // const dProductNoTaxPrice = commonUtils.convertFixNum(dProductQty !== 0 ? dProductNoTaxMoney / dProductQty : 0, dNetPrice); /* 不含税价 */
      const dProductTaxMoney = commonUtils.convertFixNum(dMoney - dProductNoTaxMoney, dNetMoney); /* 税额 */
      tableDataRow[`d${type}NoTaxMoney`] = dProductNoTaxMoney; /* 不含税金额 */
      // tableDataRow[`d${type}NoTaxPrice`] = dProductNoTaxPrice; /* 不含税价 */
      tableDataRow[`d${type}TaxMoney`] = dProductTaxMoney; /* 税额 */
    }
  }
  /*   返回值   */
  return tableDataRow;
}

// 由海口新明同步过来，按朱总需求修改2021.11.26
/**   输入数量, 计算箱包(反算）   */
export function getCalculatedReserveBags1(tableDataRow, sFieldName) {
  /*   执行条件  || sFieldName === 'dTrunkQty'  */
  if (sFieldName === 'dProductQty' || sFieldName === 'dPackQty' || sFieldName === 'dGiveQty') {
    /* 数量 */
    const dProductQty = commonUtils.convertToNum(tableDataRow.dProductQty) + commonUtils.convertToNum(tableDataRow.dGiveQty);
    /* 数量/箱 */
    const dPackQty = commonUtils.convertToNum(tableDataRow.dPackQty);
    /* 包数量 */
    const dTrunkQty = dPackQty !== 0 ? Math.floor(dProductQty / dPackQty) : 0;
    /* 零头数量 */
    const dFractionQty = dPackQty !== 0 ? dProductQty - (dPackQty * dTrunkQty) : 0;
    /*   数据赋值   */
    tableDataRow.dTrunkQty = commonUtils.convertStrToNumberUndefined(dTrunkQty);
    tableDataRow.dFractionQty = commonUtils.convertStrToNumberUndefined(dFractionQty);
  } else if (sFieldName === 'dTrunkQty') {
    /* 数量 */
    const dProductQty = commonUtils.convertToNum(tableDataRow.dProductQty) + commonUtils.convertToNum(tableDataRow.dGiveQty);
    /* 数量/箱 */
    const dTrunkQty = commonUtils.convertToNum(tableDataRow.dTrunkQty);
    /* 包数量 */
    const dPackQty = dTrunkQty !== 0 ? Math.floor(dProductQty / dTrunkQty) : 0;
    /* 零头数量 */
    const dFractionQty = dPackQty !== 0 ? dProductQty - (dPackQty * dTrunkQty) : 0;
    /*   数据赋值   */
    tableDataRow.dPackQty = commonUtils.convertStrToNumberUndefined(dPackQty);
    tableDataRow.dFractionQty = commonUtils.convertStrToNumberUndefined(dFractionQty);
  } else if (sFieldName === 'dFractionQty') {
    /* 数量/箱 */
    const dPackQty = commonUtils.convertToNum(tableDataRow.dPackQty);
    /* 包数量 */
    const dTrunkQty = commonUtils.convertToNum(tableDataRow.dTrunkQty);
    /* 零头数量 */
    const dFractionQty = commonUtils.convertToNum(tableDataRow.dFractionQty);
    /* 数量 */
    // eslint-disable-next-line no-mixed-operators
    const dProductQty = (dPackQty * dTrunkQty) + dFractionQty - commonUtils.convertToNum(tableDataRow.dGiveQty);
    /* 零头数量 */
    /*   数据赋值   */
    tableDataRow.dProductQty = commonUtils.convertStrToNumberUndefined(dProductQty);
  }
  /*   返回值   */
  return tableDataRow;
}

// 由海口新明同步过来，按朱总需求修改2021.11.26
/**   输入数量, 计算箱包   */
export function getCalculatedReserveBags(tableDataRow, sFieldName) {
  /*   执行条件  || sFieldName === 'dTrunkQty'  */
  if (sFieldName === 'dProductQty' || sFieldName === 'dGiveQty') { /* 输入数量,算包数 及零头 */
    /* 数量 */
    const dProductQty = commonUtils.convertToNum(tableDataRow.dProductQty) + commonUtils.convertToNum(tableDataRow.dGiveQty);
    /* 数量/箱 */
    const dPackQty = commonUtils.convertToNum(tableDataRow.dPackQty);
    /* 包数量 */
    const dTrunkQty = dPackQty !== 0 ? Math.floor(dProductQty / dPackQty) : 0;
    /* 零头数量 */
    const dFractionQty = dPackQty !== 0 ? dProductQty - (dPackQty * dTrunkQty) : 0;
    /*   数据赋值   */
    tableDataRow.dTrunkQty = commonUtils.convertStrToNumberUndefined(dTrunkQty);
    tableDataRow.dFractionQty = commonUtils.convertStrToNumberUndefined(dFractionQty);
  } else if (sFieldName === 'dTrunkQty' || sFieldName === 'dPackQty' || sFieldName === 'dFractionQty') { /* 输入包数或零头数量 算总数 */
    /* 数量/箱 */
    const dPackQty = commonUtils.convertToNum(tableDataRow.dPackQty);
    /* 包数量 */
    const dTrunkQty = commonUtils.convertToNum(tableDataRow.dTrunkQty);
    /* 零头数量 */
    const dFractionQty = commonUtils.convertToNum(tableDataRow.dFractionQty);
    /* 数量 */
    // eslint-disable-next-line no-mixed-operators
    const dProductQty = (dPackQty * dTrunkQty) + dFractionQty - commonUtils.convertToNum(tableDataRow.dGiveQty);
    /*   数据赋值   */
    tableDataRow.dProductQty = commonUtils.convertStrToNumberUndefined(dProductQty);
  }
  /*   返回值   */
  return tableDataRow;
}

/**   根据金额，具体计算价格，不含税金额，不含税价格，税额，外币金额，外币税额   */
export function getCalculateMoney(app, masterData, tableDataRow, type, sFieldName) {
  /*   执行条件   */
  /*   待用数据赋值   */
  const { dNetPrice, dNetMoney } = app.decimals;
  const { sModelsType } = app.currentPane;
  const dProductQty = commonUtils.convertToNum(tableDataRow[`d${type}Qty`]); /* 数量 */
  const dTaxRate = commonUtils.convertToNum(tableDataRow.dTaxRate); /* 税率 */
  let dCurrencyRate = commonUtils.convertIsNotNumToNumber1(masterData.dCurrencyRate); /* 汇率 */
  /* 报价单模块，工单模块、产品工艺卡 汇率取从表 */
  if (commonUtils.isNotEmptyObject(sModelsType) && (sModelsType.includes('manufacture/') || sModelsType.includes('quotation/') || sModelsType.includes('processCard'))) {
    dCurrencyRate = commonUtils.convertIsNotNumToNumber1(tableDataRow.dCurrencyRate); /* 汇率 */
  }
  let dProductForeignMoney = commonUtils.convertToNum(tableDataRow[`d${type}ForeignMoney`]); /* 外币金额 */
  const dProductMoney = commonUtils.convertToNum(tableDataRow[`d${type}Money`]); /* 金额 */
  /* 输入外币金额计算本位币 外币*汇率 =本位币金额 */
  if (sFieldName === `d${type}ForeignMoney`) {
    const dProductStandardMoney = commonUtils.convertFixNum(dCurrencyRate !== 0 ? dProductForeignMoney * dCurrencyRate : 0, dNetMoney); /* 本位币金额 */
    tableDataRow[`d${type}Money`] = commonUtils.convertFixNum(dProductStandardMoney, dNetMoney);
  } else {
    dProductForeignMoney = commonUtils.convertFixNum(dCurrencyRate !== 0 ? dProductMoney / dCurrencyRate : 0, dNetMoney); /* 外币金额 */
  }
  const dProductPrice = commonUtils.convertFixNum(dProductQty !== 0 ? dProductMoney / dProductQty : 0, dNetPrice); /* 价格 */
  const dProductNoTaxMoney = commonUtils.convertFixNum(dProductMoney / (1 + (dTaxRate / 100)), dNetMoney); /* 不含税金额 */
  const dProductNoTaxPrice = commonUtils.convertFixNum(dProductQty !== 0 ? dProductNoTaxMoney / dProductQty : 0, dNetPrice); /* 不含税价 */
  const dProductTaxMoney = commonUtils.convertFixNum(dProductMoney - dProductNoTaxMoney, dNetMoney); /* 税额 */
  // const dProductForeignMoney = commonUtils.convertFixNum(dCurrencyRate !== 0 ? dProductMoney / dCurrencyRate : 0, dNetMoney); /* 外币金额 */
  const dProductTaxForeignMoney = commonUtils.convertFixNum(dCurrencyRate !== 0 ? dProductTaxMoney / dCurrencyRate : 0, dNetMoney); /* 外币税额 */
  /*   数据赋值   */
  if (sFieldName !== `d${type}Price`) {
    tableDataRow[`d${type}Price`] = commonUtils.convertFixNum(dProductPrice, dNetPrice);
  }
  if (sFieldName !== `d${type}NoTaxMoney`) {
    tableDataRow[`d${type}NoTaxMoney`] = commonUtils.convertFixNum(dProductNoTaxMoney, dNetMoney);
  }
  if (sFieldName !== `d${type}NoTaxPrice`) {
    tableDataRow[`d${type}NoTaxPrice`] = commonUtils.convertFixNum(dProductNoTaxPrice, dNetPrice);
  }
  if (sFieldName !== `d${type}TaxMoney`) {
    tableDataRow[`d${type}TaxMoney`] = commonUtils.convertFixNum(dProductTaxMoney, dNetMoney);
  }
  if (sFieldName !== `d${type}ForeignMoney`) {
    tableDataRow[`d${type}ForeignMoney`] = commonUtils.convertFixNum(dProductForeignMoney, dNetMoney);
  }
  if (sFieldName !== `d${type}TaxForeignMoney`) {
    tableDataRow[`d${type}TaxForeignMoney`] = commonUtils.convertFixNum(dProductTaxForeignMoney, dNetMoney);
  }
  return tableDataRow;
}

/**   根据金额，具体计算价格，不含税金额，不含税价格，税额，外币金额，外币税额   */
export function getCalculateMoneyNew(app, masterData, tableDataRow, type, sFieldName) {
  /*   执行条件   */
  /*   待用数据赋值   */
  const { dNetPrice, dNetMoney } = app.decimals;
  const { sModelsType } = app.currentPane;
  const dProductQty = commonUtils.convertToNum(tableDataRow[`d${type}Qty`]); /* 数量 */
  const dTaxRate = commonUtils.convertToNum(tableDataRow.dTaxRate); /* 税率 */
  let dCurrencyRate = commonUtils.convertIsNotNumToNumber1(masterData.dCurrencyRate); /* 汇率 */
  /* 报价单模块，工单模块、产品工艺卡 汇率取从表 */
  if (commonUtils.isNotEmptyObject(sModelsType) && (sModelsType.includes('manufacture/') || sModelsType.includes('quotation/') || sModelsType.includes('processCard'))) {
    dCurrencyRate = commonUtils.convertIsNotNumToNumber1(tableDataRow.dCurrencyRate); /* 汇率 */
  }
  let dProductMoney = commonUtils.convertToNum(tableDataRow[`d${type}Money`]); /* 本币金额 */
  let dProductForeignMoney = commonUtils.convertToNum(tableDataRow[`d${type}ForeignMoney`]); /* 外币金额 */
  let dNProductMoney = commonUtils.convertToNum(tableDataRow[`dN${type}Money`]); /* 产品金额 */
  let dNProductPrice = commonUtils.convertToNum(tableDataRow[`dN${type}Price`]); /* 产品价格 */
  const dProofingMoney = commonUtils.convertToNum(tableDataRow.dProofingMoney); /* 打样金额 */
  const dPlateMoney = commonUtils.convertToNum(tableDataRow.dPlateMoney); /* 制版金额 */
  const dKnifeMouldMoney = commonUtils.convertToNum(tableDataRow.dKnifeMouldMoney); /* 刀模金额 */
  /* 输入产品金额、打样金额、制版金额、刀模金额 计算外币金额 */
  if (sFieldName === `dN${type}Money` || sFieldName === 'dProofingMoney' || sFieldName === 'dPlateMoney' || sFieldName === 'dKnifeMouldMoney') {
    dProductForeignMoney = commonUtils.convertFixNum(dNProductMoney + dProofingMoney + dPlateMoney + dKnifeMouldMoney, dNetMoney); /* 外币金额 */
    dProductMoney = commonUtils.convertFixNum(dCurrencyRate !== 0 ? dProductForeignMoney * dCurrencyRate : 0, dNetMoney); /* 本位币金额 */
  } else if (sFieldName === `d${type}Money`) {
    dProductForeignMoney = commonUtils.convertFixNum(dCurrencyRate !== 0 ? dProductMoney / dCurrencyRate : 0, dNetMoney); /*  外币金额 */
    dNProductMoney = commonUtils.convertFixNum(dProductForeignMoney - dProofingMoney - dPlateMoney - dKnifeMouldMoney, dNetMoney); /* 产品金额 */
  } else {
    /* 输入外币金额计算本位币、产品金额 外币*汇率 =本位币金额 */
    dProductMoney = commonUtils.convertFixNum(dCurrencyRate !== 0 ? dProductForeignMoney * dCurrencyRate : 0, dNetMoney); /* 本位币金额 */
    dNProductMoney = commonUtils.convertFixNum(dProductForeignMoney - dProofingMoney - dPlateMoney - dKnifeMouldMoney, dNetMoney); /* 产品金额 */
  }
  dNProductPrice = commonUtils.convertFixNum(dProductQty !== 0 ? dNProductMoney / dProductQty : dNProductPrice, dNetPrice); /* 产品价格 */
  const dProductForeignPrice = commonUtils.convertFixNum(dProductQty !== 0 ? dProductForeignMoney / dProductQty : 0, dNetPrice); /* 外币价格 */
  const dProductPrice = commonUtils.convertFixNum(dProductQty !== 0 ? dProductMoney / dProductQty : 0, dNetPrice); /* 本位币价格 */
  const dProductNoTaxMoney = commonUtils.convertFixNum(dProductMoney / (1 + (dTaxRate / 100)), dNetMoney); /* 不含税金额 */
  const dProductNoTaxPrice = commonUtils.convertFixNum(dProductQty !== 0 ? dProductNoTaxMoney / dProductQty : 0, dNetPrice); /* 不含税价 */
  const dProductTaxMoney = commonUtils.convertFixNum(dProductMoney - dProductNoTaxMoney, dNetMoney); /* 税额 */
  // const dProductForeignMoney = commonUtils.convertFixNum(dCurrencyRate !== 0 ? dProductMoney / dCurrencyRate : 0, dNetMoney); /* 外币金额 */
  const dProductTaxForeignMoney = commonUtils.convertFixNum(dCurrencyRate !== 0 ? dProductTaxMoney / dCurrencyRate : 0, dNetMoney); /* 外币税额 */

  if (tableDataRow.bSalesMaterials) { /* 材料销售 */
    type = 'Product';
  }

  /*   数据赋值   */
  if (sFieldName !== `dN${type}Money`) {
    tableDataRow[`dN${type}Money`] = dNProductMoney; /* 产品金额 */
  }
  if (sFieldName !== `d${type}ForeignMoney`) {
    tableDataRow[`d${type}ForeignMoney`] = dProductForeignMoney; /* 外币金额 */
  }
  if (sFieldName !== `d${type}Money`) {
    tableDataRow[`d${type}Money`] = dProductMoney; /* 本币金额 */
  }
  if (sFieldName !== `dN${type}Price`) {
    tableDataRow[`dN${type}Price`] = commonUtils.convertFixNum(dNProductPrice, dNetPrice);
  }
  if (sFieldName !== `d${type}ForeignPrice`) {
    tableDataRow[`d${type}ForeignPrice`] = commonUtils.convertFixNum(dProductForeignPrice, dNetPrice);
  }
  if (sFieldName !== `d${type}Price`) {
    tableDataRow[`d${type}Price`] = commonUtils.convertFixNum(dProductPrice, dNetPrice);
  }
  if (sFieldName !== `d${type}NoTaxMoney`) {
    tableDataRow[`d${type}NoTaxMoney`] = commonUtils.convertFixNum(dProductNoTaxMoney, dNetMoney);
  }
  if (sFieldName !== `d${type}NoTaxPrice`) {
    tableDataRow[`d${type}NoTaxPrice`] = commonUtils.convertFixNum(dProductNoTaxPrice, dNetPrice);
  }
  if (sFieldName !== `d${type}TaxMoney`) {
    tableDataRow[`d${type}TaxMoney`] = commonUtils.convertFixNum(dProductTaxMoney, dNetMoney);
  }
  // tableDataRow[`d${type}ForeignMoney`] = commonUtils.convertFixNum(dProductForeignMoney, dNetMoney);
  if (sFieldName !== `d${type}TaxForeignMoney`) {
    tableDataRow[`d${type}TaxForeignMoney`] = commonUtils.convertFixNum(dProductTaxForeignMoney, dNetMoney);
  }
  return tableDataRow;
}


/**   输入不含税价格, 计算不含税金额，税额，金额，价格，外币金额，外币税额   */
export function getCalculateNoTaxPrice(app, masterData, tableDataRow, type) {
  /*   执行条件   */
  /*   待用数据赋值   */
  const { dNetPrice, dNetMoney } = app.decimals;
  const { sModelsType } = app.currentPane;
  const dProductQty = commonUtils.convertToNum(tableDataRow[`d${type}Qty`]); /* 数量 */
  const dProductNoTaxPrice = commonUtils.convertToNum(tableDataRow[`d${type}NoTaxPrice`]); /* 不含税价 */
  const dTaxRate = commonUtils.convertToNum(tableDataRow.dTaxRate); /* 税率 */
  let dCurrencyRate = commonUtils.convertIsNotNumToNumber1(masterData.dCurrencyRate); /* 汇率 */
  /* 报价单模块，工单模块、产品工艺卡 汇率取从表 */
  if (commonUtils.isNotEmptyObject(sModelsType) && (sModelsType.includes('manufacture/') || sModelsType.includes('quotation/') || sModelsType.includes('processCard'))) {
    dCurrencyRate = commonUtils.convertIsNotNumToNumber1(tableDataRow.dCurrencyRate); /* 汇率 */
  }
  const dProductNoTaxMoney = commonUtils.convertFixNum(dProductQty * dProductNoTaxPrice, dNetMoney); /* 不含税金额 */
  const dProductTaxMoney = commonUtils.convertFixNum(dProductNoTaxMoney * (dTaxRate / 100), dNetMoney); /* 税额 */
  const dProductMoney = commonUtils.convertFixNum(dProductNoTaxMoney + dProductTaxMoney, dNetMoney); /* 金额 */
  const dProductPrice = commonUtils.convertFixNum(dProductQty !== 0 ? dProductMoney / dProductQty : 0, dNetPrice); /* 价格 */
  const dProductForeignMoney = commonUtils.convertFixNum(dCurrencyRate !== 0 ? dProductMoney / dCurrencyRate : 0, dNetMoney); /* 外币金额 */
  const dProductTaxForeignMoney = commonUtils.convertFixNum(dCurrencyRate !== 0 ? dProductTaxMoney / dCurrencyRate : 0, dNetMoney); /* 外币税额 */
  /*   数据赋值   */
  tableDataRow[`d${type}NoTaxMoney`] = commonUtils.convertFixNum(dProductNoTaxMoney, dNetMoney);
  tableDataRow[`d${type}TaxMoney`] = commonUtils.convertFixNum(dProductTaxMoney, dNetMoney);
  tableDataRow[`d${type}Money`] = commonUtils.convertFixNum(dProductMoney, dNetMoney);
  tableDataRow[`d${type}Price`] = commonUtils.convertFixNum(dProductPrice, dNetPrice);
  tableDataRow[`d${type}ForeignMoney`] = commonUtils.convertFixNum(dProductForeignMoney, dNetMoney);
  tableDataRow[`d${type}TaxForeignMoney`] = commonUtils.convertFixNum(dProductTaxForeignMoney, dNetMoney);
  /*   返回值   */
  return tableDataRow;
}

/**   输入不含税金额， 计算不含税价格，税额，金额，价格，外币金额，外币税额   */
export function getCalculateNoTaxMoney(app, masterData, tableDataRow, type) {
  /*   执行条件   */
  /*   待用数据赋值   */
  const { dNetPrice, dNetMoney } = app.decimals;
  const { sModelsType } = app.currentPane;
  const dProductQty = commonUtils.convertToNum(tableDataRow[`d${type}Qty`]);
  const dProductNoTaxMoney = commonUtils.convertToNum(tableDataRow[`d${type}NoTaxMoney`]);
  const dTaxRate = commonUtils.convertToNum(tableDataRow.dTaxRate);
  let dCurrencyRate = commonUtils.convertIsNotNumToNumber1(masterData.dCurrencyRate);
  /* 报价单模块，工单模块、产品工艺卡 汇率取从表 */
  if (commonUtils.isNotEmptyObject(sModelsType) && (sModelsType.includes('manufacture/') || sModelsType.includes('quotation/') || sModelsType.includes('processCard'))) {
    dCurrencyRate = commonUtils.convertIsNotNumToNumber1(tableDataRow.dCurrencyRate); /* 汇率 */
  }
  const dProductNoTaxPrice = commonUtils.convertFixNum(dProductQty !== 0 ? dProductNoTaxMoney / dProductQty : 0, dNetPrice); /* 不含税价格 */
  const dProductTaxMoney = commonUtils.convertFixNum(dProductNoTaxMoney * (dTaxRate / 100), dNetMoney); /* 税额 */
  const dProductMoney = commonUtils.convertFixNum(dProductNoTaxMoney + dProductTaxMoney, dNetMoney); /* 金额 */
  const dProductPrice = commonUtils.convertFixNum(dProductQty !== 0 ? dProductMoney / dProductQty : 0, dNetPrice); /* 价格 */
  const dProductForeignMoney = commonUtils.convertFixNum(dCurrencyRate !== 0 ? dProductMoney / dCurrencyRate : 0, dNetMoney); /* 外币金额 */
  const dProductTaxForeignMoney = commonUtils.convertFixNum(dCurrencyRate !== 0 ? dProductTaxMoney / dCurrencyRate : 0, dNetMoney); /* 外币税额 */
  /*   数据赋值   */
  tableDataRow[`d${type}NoTaxPrice`] = commonUtils.convertFixNum(dProductNoTaxPrice, dNetPrice);
  tableDataRow[`d${type}TaxMoney`] = commonUtils.convertFixNum(dProductTaxMoney, dNetMoney);
  tableDataRow[`d${type}Money`] = commonUtils.convertFixNum(dProductMoney, dNetMoney);
  tableDataRow[`d${type}Price`] = commonUtils.convertFixNum(dProductPrice, dNetPrice);
  tableDataRow[`d${type}ForeignMoney`] = commonUtils.convertFixNum(dProductForeignMoney, dNetMoney);
  tableDataRow[`d${type}TaxForeignMoney`] = commonUtils.convertFixNum(dProductTaxForeignMoney, dNetMoney);
  /*   返回值   */
  return tableDataRow;
}

/**   手动输入税额， 计算不含税金额，不含税金额为金额-税额   */
export function getCalculateTaxMoney(app, masterData, tableDataRow, type) {
  /*   执行条件   */
  /*   待用数据赋值   */
  const { dNetMoney } = app.decimals;
  const dProductTaxMoney = commonUtils.convertToNum(tableDataRow[`d${type}TaxMoney`]);/* 税额 */
  const dProductMoney = commonUtils.convertToNum(tableDataRow[`d${type}Money`]);/* 金额 */
  const dProductNoTaxMoney = commonUtils.convertFixNum(dProductMoney - dProductTaxMoney, dNetMoney); /* 不含税金额 */
  /*   数据赋值   */
  tableDataRow[`d${type}NoTaxMoney`] = commonUtils.convertFixNum(dProductNoTaxMoney, dNetMoney);
  /*   返回值   */
  return tableDataRow;
}

/**   有报损情况下， 计算dSrcNoCheckMoney -  税额 */
export function getCalculateMoneyByLossMoney(app, type, masterData, tableDataRow, dSrcNoCheckMoney, dLossMoney) {
  /*   执行条件   */
  /*   待用数据赋值   */
  const { dNetMoney } = app.decimals;
  const dProductForeignMoney = commonUtils.convertFixNum(dSrcNoCheckMoney - dLossMoney, dNetMoney);
  const dCurrencyRate = commonUtils.convertIsNotNumToNumber1(masterData.dCurrencyRate); /* 汇率 */
  const dProductMoney = commonUtils.convertFixNum(dCurrencyRate !== 0 ? dProductForeignMoney * dCurrencyRate : 0, dNetMoney); /* 本位币金额 */
  /*   数据赋值   */
  tableDataRow[`d${type}ForeignMoney`] = dProductForeignMoney;
  tableDataRow[`d${type}Money`] = dProductMoney; /* 金额 */
  /*   返回值   */
  return tableDataRow;
}

/* 自定义onChange事件  */
export function getKeyUpEvent(name, sFieldName, tableConfig, masterData, tableDataRow, isWait, dataCollection) {
  let tableDataRowNew = {};
  const newCopyTo = {};
  if (name === 'master') {
    tableDataRowNew = masterData;
  } else {
    tableDataRowNew = tableDataRow;
    newCopyTo.slave = tableDataRow;
  }
  if (commonUtils.isNotEmptyObject(tableConfig) && commonUtils.isNotEmptyArr(tableConfig.gdsconfigformslave)) {
    const iConfigIndex = tableConfig.gdsconfigformslave.findIndex(item => item.sName === sFieldName);
    if (iConfigIndex > -1) {
      newCopyTo.master = masterData;
      // eslint-disable-next-line prefer-destructuring
      const sAssignField = tableConfig.gdsconfigformslave[iConfigIndex].sOnChangeAssignField;
      console.log('sAssignField:', sAssignField);
      /* keyUp联动其他表 */
      if (commonUtils.isNotEmptyObject(sAssignField) && sAssignField.includes('_')) {
        const addState = {};
        /* 主表联动其他表格 */
        if (name === 'master') {
          const sAssignFieldObj = sAssignField.split(',');
          if (commonUtils.isNotEmptyArr(sAssignFieldObj)) {
            sAssignFieldObj.forEach((sAssignFieldItem) => {
              const leftFiled = sAssignFieldItem; /* 每一个赋值字段 */
              if (commonUtils.isNotEmptyObject(leftFiled)) {
                const tbName = leftFiled.substring(0, leftFiled.indexOf('_'));
                const tableData = dataCollection[tbName];
                if (commonUtils.isNotEmptyArr(tableData)) {
                  const sOnChangeAssignFieldNew = leftFiled.replace(`${tbName}_all.`, '').trim();
                  tableData.forEach((item, index) => {
                    newCopyTo[tbName] = item;
                    const tableRow = { ...item, ...commonFunc.getAssignFieldValue(sOnChangeAssignFieldNew, item, newCopyTo) }; // 取赋值字段
                    tableRow.handleType = commonUtils.isEmpty(tableRow.handleType) ? 'update' : tableRow.handleType;
                    tableData[index] = tableRow;
                  });
                  addState[tbName] = tableData;
                  masterData.handleType = commonUtils.isEmpty(masterData.handleType) ? 'update' : masterData.handleType;
                  addState.master = masterData;
                  addState.bMultiTable = true;
                }
                return addState;
              }
            });
          }
        } else if (name === 'slave') {
          /* 从表改变汇总到主表 */


        }
      } else if (commonUtils.isNotEmptyObject(sAssignField)) { /* 单表keyUp事件 */
        tableDataRowNew = { ...tableDataRowNew, ...commonFunc.getAssignFieldValue(sAssignField, tableDataRowNew, newCopyTo) }; // 取赋值字段
        let { handleType } = masterData;
        if (name !== 'master') {
          // eslint-disable-next-line prefer-destructuring
          handleType = tableDataRow.handleType;
        }
        tableDataRowNew.handleType = commonUtils.isEmpty(handleType) ? 'update' : handleType;
        if (isWait) {
          return tableDataRowNew;
        }
      } else {
        return {};
      }
    }
  }
}

/**   根据不同的模块，选出具体计算不同模块的计算方式等   */
export function getCalculateAllMoney(app, type, sFieldName, masterData, tableDataRow) {
  /*   待用数据声明   */
  /*   不同的数据进行不同的处理  */
  const sCkxDirectSolutionPack = commonUtils.isNotEmptyObject(app.systemData) && commonUtils.isNotEmptyObject(app.systemData.filter(item => item.sName === 'CkxDirectSolutionPack')) ?
    app.systemData.filter(item => item.sName === 'CkxDirectSolutionPack')[0].sValue : '0'; /* 默认反算 */

  if (sFieldName === 'sMaterialsStyle' || sFieldName === 'dAuxiliaryQty' || sFieldName === `d${type}Price` || sFieldName === `dN${type}Price` || sFieldName === `d${type}ForeignPrice` || sFieldName === 'sTaxId' || sFieldName === 'sTaxName' || sFieldName === 'sSupplyId' || sFieldName === 'sSupplyName' || sFieldName === 'sProcessName') {
    if (type === 'Product') {
      tableDataRow = getCalculateByPriceNew(app, type, masterData, tableDataRow, sFieldName);
    } else {
      tableDataRow = getCalculateByPrice(app, type, masterData, tableDataRow, sFieldName);
    }
  } else if (sFieldName === `d${type}Qty`) {
    if (sCkxDirectSolutionPack === '0') { /* 箱包反算 */
      tableDataRow = getCalculatedReserveBags(tableDataRow, sFieldName);
    } else { /* 箱包正算 */
      tableDataRow = getCalculatedReserveBags1(tableDataRow, sFieldName);
    }

    if (type === 'Product') {
      tableDataRow = getCalculateByPriceNew(app, type, masterData, tableDataRow, sFieldName);
    } else {
      tableDataRow = getCalculateByPrice(app, type, masterData, tableDataRow, sFieldName);
    }
  } else if (sFieldName === `d${type}ForeignMoney`) { /* 外币金额 */
    tableDataRow = getCalculateMoneyNew(app, masterData, tableDataRow, type, sFieldName);
  } else if (sFieldName === `d${type}Money`) {
    tableDataRow = getCalculateMoneyNew(app, masterData, tableDataRow, type, sFieldName);
  } else if (sFieldName === 'dNProductMoney') {
    tableDataRow = getCalculateMoneyNew(app, masterData, tableDataRow, type, sFieldName);
  } else if (sFieldName === 'dProofingMoney') {
    tableDataRow = getCalculateMoneyNew(app, masterData, tableDataRow, type, sFieldName);
  } else if (sFieldName === 'dPlateMoney') {
    tableDataRow = getCalculateMoneyNew(app, masterData, tableDataRow, type, sFieldName);
  } else if (sFieldName === 'dKnifeMouldMoney') {
    tableDataRow = getCalculateMoneyNew(app, masterData, tableDataRow, type, sFieldName);
  } else if (sFieldName === `d${type}NoTaxPrice`) {
    tableDataRow = getCalculateNoTaxPrice(app, masterData, tableDataRow, type);
  } else if (sFieldName === `d${type}NoTaxMoney`) {
    tableDataRow = getCalculateNoTaxMoney(app, masterData, tableDataRow, type);
  } else if (sFieldName === 'dAuxiliaryLossQty' || sFieldName === 'dLossQty') {
    tableDataRow = getCalculatedLossMoney(app, masterData, tableDataRow, type);
  } else if (sFieldName === 'dTrunkQty' || sFieldName === 'dFractionQty' || sFieldName === 'dPackQty' || sFieldName === 'dGiveQty') {
    if (sCkxDirectSolutionPack === '0') { /* 箱包反算 */
      tableDataRow = getCalculatedReserveBags(tableDataRow, sFieldName);
    } else { /* 箱包正算 */
      tableDataRow = getCalculatedReserveBags1(tableDataRow, sFieldName);
    }

    if (sFieldName === 'dFractionQty' || sFieldName === 'dTrunkQty' || sFieldName === 'dPackQty') { /* 包数、每包数量、零头数量改变时候 重算金额 */
      tableDataRow = getCalculateByPriceNew(app, type, masterData, tableDataRow, `d${type}Qty`);
    }
  } else if (sFieldName === `d${type}TaxMoney`) {
    tableDataRow = getCalculateTaxMoney(app, masterData, tableDataRow, type);
  }
  return tableDataRow;
}

/** 根据一系列判断，计算出其相应的单位类型 */
export function handleUnitType(app, resultValue) {
  const {
    dGramWeight, sMaterialsStyle, sMaterialsUnit, sAuxiliaryUnit,
  } = resultValue;
  const bReel = resultValue.bReel !== undefined ? resultValue.bReel : false;
  const sStyle = sMaterialsStyle !== undefined ? sMaterialsStyle.indexOf('*') : -1;
  let sMUnit = 'other';
  const unitT = commonFunc.showMessage(app.commonConst, 't');
  const unitKg = commonFunc.showMessage(app.commonConst, 'kg');
  const unitM2 = commonFunc.showMessage(app.commonConst, 'm2');
  let unitM = false;
  if (sAuxiliaryUnit === 'm' || sAuxiliaryUnit === 'M' || sAuxiliaryUnit === '米') {
    unitM = true;
  }
  if (sMaterialsUnit === unitT && sStyle > -1 && dGramWeight > 0) {
    sMUnit = 't';
  } else if (sMaterialsUnit === unitKg && sStyle > -1 && dGramWeight > 0) {
    sMUnit = 'kg';
  } else if (sMaterialsUnit === unitM2 && !bReel && sStyle > -1) {
    sMUnit = 'm2';
  } else if (sMaterialsUnit === unitM2 && bReel && sStyle > -1) {
    sMUnit = 'm2Reel';
  } else if (sMaterialsUnit === unitT && unitM && sStyle === -1 && dGramWeight > 0) {
    sMUnit = 'tNo';
  } else if (sMaterialsUnit === unitKg && unitM && sStyle === -1 && dGramWeight > 0) {
    sMUnit = 'kgNo';
  } else if ((sMaterialsUnit === unitM2) && bReel && sStyle === -1) {
    sMUnit = 'm2ReelNo';
  }
  return sMUnit;
}


/**   根据数量算出换算数量   */
export function getMaterialsQty(app, tableDataRow, sAuxiliaryFieldName, sFieldName) {
  /* 根据库存数量计算其换算数量 - 正算 */
  let {
    dGramWeight, sMaterialsStyle, [sAuxiliaryFieldName]: dAuxiliaryQty, dCoefficient,
  } = tableDataRow;
  dCoefficient = commonUtils.convertIsNotNumToNumber1(dCoefficient); /* 系数 */
  const sType = handleUnitType(app, tableDataRow);

  sMaterialsStyle = sMaterialsStyle === undefined ? '' : sMaterialsStyle;
  dAuxiliaryQty = commonUtils.convertToNum(dAuxiliaryQty);
  let dMaterialsQty = 0;
  dGramWeight = commonUtils.convertToNum(dGramWeight);

  const sMStyleO = sMaterialsStyle !== undefined ? sMaterialsStyle.split('*')[0] : '';
  const sMStyleT = sMaterialsStyle !== undefined ? sMaterialsStyle.split('*')[1] !== '' ? sMaterialsStyle.split('*')[1] : 1 : '';
  if (tableDataRow.sAuxiliaryUnit === sType) {
    dMaterialsQty = dAuxiliaryQty;
  } else if (sType === 't' || sType === 'kg') {
    /* 按重量 */
    const multiple = sType === 't' ? 1000000000000 : 1000000000;
    dMaterialsQty = ((dAuxiliaryQty * (sMStyleO * sMStyleT) * dGramWeight) / multiple).toFixed(6);
  } else if (sType === 'm2') {
    dMaterialsQty = ((dAuxiliaryQty * (sMStyleO * sMStyleT)) / 1000000).toFixed(6);
  } else if (sType === 'm2Reel') {
    dMaterialsQty = ((dAuxiliaryQty * (sMStyleO * sMStyleT)) / 1000).toFixed(6);
  } else if (sType === 'tNo' || sType === 'kgNo') {
    const multiple = sType === 'tNo' ? 1000000000 : 1000000;
    dMaterialsQty = ((dAuxiliaryQty * sMStyleO * dGramWeight) / multiple).toFixed(6);
  } else if (sType === 'm2ReelNo') {
    dMaterialsQty = ((dAuxiliaryQty * sMStyleO) / 1000).toFixed(6);
  } else {
    /**
     * 修改日期：2021-04-02
     * 修改人：吕杰
     * 区域：以下 1 行
     * BUG：-
     * 说明：修复计算精度
     * 原代码：dMaterialsQty = dAuxiliaryQty * dCoefficient;
     */
    dMaterialsQty = (dAuxiliaryQty * dCoefficient).toFixed(6);
  }
  tableDataRow[sFieldName] = dMaterialsQty;
  return tableDataRow;
}

/** 计算库存数量--反算 */
export function getAuxiliaryQty(app, tableDataRow, sFieldName, sAuxiliaryFieldName) {
  let {
    sMaterialsStyle, [sFieldName]: dMaterialsQty, dGramWeight, dCoefficient,
  } = tableDataRow;
  sMaterialsStyle = sMaterialsStyle === undefined ? '' : sMaterialsStyle;
  dMaterialsQty = commonUtils.convertToNum(dMaterialsQty);
  dGramWeight = commonUtils.convertToNum(dGramWeight);
  dCoefficient = commonUtils.convertIsNotNumToNumber1(dCoefficient); /* 系数 */
  let dAuxiliaryQty = 0;
  const sType = handleUnitType(app, tableDataRow);

  const sMStyleO = sMaterialsStyle !== undefined ? sMaterialsStyle.split('*')[0] : '';
  const sMStyleT = sMaterialsStyle !== undefined ? sMaterialsStyle.split('*')[1] !== '' ? sMaterialsStyle.split('*')[1] : 1 : '';
  if (tableDataRow.sAuxiliaryUnit === sType) {
    dAuxiliaryQty = dMaterialsQty;
  } else if (sType === 't' || sType === 'kg') {
    /* 按重量 */
    const multiple = sType === 't' ? 1000000000000 : 1000000000;
    dAuxiliaryQty = ((dMaterialsQty * multiple) / dGramWeight / (sMStyleO * sMStyleT)).toFixed(0);
  } else if (sType === 'm2') {
    dAuxiliaryQty = ((dMaterialsQty * 1000000) / (sMStyleO * sMStyleT)).toFixed(2);
  } else if (sType === 'm2Reel') {
    dAuxiliaryQty = ((dMaterialsQty * 1000) / (sMStyleO * sMStyleT)).toFixed(2);
  } else if (sType === 'tNo' || sType === 'kgNo') {
    const multiple = sType === 'tNo' ? 1000000000 : 1000000;
    dAuxiliaryQty = ((dMaterialsQty * multiple) / dGramWeight / sMStyleO).toFixed(0);
  } else if (sType === 'm2ReelNo') {
    dAuxiliaryQty = (dMaterialsQty * 1000) / sMStyleO;
  } else {
    dAuxiliaryQty = dMaterialsQty / dCoefficient;
  }
  tableDataRow[sAuxiliaryFieldName] = dAuxiliaryQty;
  return tableDataRow;
}


/**   根据数量用公式处理   */
export async function getFormulaValue(param) {
  /* 根据库存数量计算其换算数量 - 正算 */
  const {
    token, sModelsId, masterData, tableDataRow, sComputeId, sFormulaIdType,
  } = param;
  let result = '';
  const value = {
    sHandleType: 'getResult',
    replaceData: { /* 数据列集合Map形式 */
      billMaster: masterData, /* 单据主表 */
      billSlave: tableDataRow, /* 单据从表 */
    },
    sFormulaId: sComputeId, /* 计算公式ID */
    sFormulaIdType, /* 计算类型（正算、反算） */
    sClientType: '1',
  };
  const url = `${commonConfig.server_host}replaceField/checkReplaceField?sModelsId=${sModelsId}`;
  const dataReturn = (await commonServices.postValueService(token, value, url)).data;
  /*   成功的话返回数据   */
  if (dataReturn.code === 1) { /*   成功   */
    result = dataReturn.dataset.rows[0].sResult;
  } else { /*   失败   */
    // message.error(dataReturn.msg);
    return 0;
  }
  return result;
}
/**   获取发外公式ID   */
export async function getOutSideProcessFormula(param) {
  /* 根据库存数量计算其换算数量 - 正算 */
  const {
    token, sModelsId, sSupplyId, sProcessId,
  } = param;
  let result = '';
  /* 根据客户id,工序id获取公式ID */
  const url = `${commonConfig.server_host}calculationFormula/getFormulaBySupplyIdProcessId?sModelsId=${sModelsId}`;
  const value = {
    sSupplyId,
    sProcessId,
  };
  const dataReturn = (await commonServices.postValueService(token, value, url)).data;
  if (dataReturn.code === 1) {
    if (commonUtils.isNotEmptyArr(dataReturn.dataset.rows)) {
      result = dataReturn.dataset.rows[0].sFormulaId;/* 获取公式ID */
    }
  } else {
    result = '';
  }
  return result;
}

export function getShowTableSelectTypes(name, props, sReturnField) {
  const returnTypes = {
    name,
    app: props.app,
    formId: props.sModelsId,
    data: props[`${name}Data`],
    disabled: !props.enabled,
    sReturnFieldName: sReturnField === undefined ? 'value' : sReturnField,
    onDoubleClick: props.onButtonChange,
  };
  return returnTypes;
}

/** Tree 传入数据格式 */
export function getTreeTypes(name, props) {
  const returnTypes = {
    name,
    app: props.app,
    formId: props.sModelsId,
    checkable: props.checkable === undefined ? true : props.checkable,
    disabled: !props.enabled,
    defaultExpandAll: props.defaultExpandAll ? props.defaultExpandAll : false,
    sKeyName: props[`${name}KeyName`] === undefined ? 'key' : props[`${name}KeyName`],
    sFieldName: props[`${name}sShowName`] === undefined ? 'showName' : props[`${name}sFieldName`],
    treeData: props[`${name}Data`] === undefined ? [] : props[`${name}Data`],
    checkedKeys: props[`${name}CheckedKeys`] === undefined ? [] : props[`${name}CheckedKeys`],
    selectedKeys: props[`${name}SelectedKeys`] === undefined ? [] : props[`${name}SelectedKeys`],
    allCheckKeys: props[`${name}AllCheckKeys`] === undefined ? [] : props[`${name}AllCheckKeys`],
    disabledCheckedKeys: props.disabledCheckedKeys === undefined ? [] : props.disabledCheckedKeys,
    onCheck: props.onTreeCheck === undefined ? undefined : props.onTreeCheck.bind(this, name),
    onSetTreeOptionKeys: props.onSetTreeOptionKeys === undefined ? undefined : props.onSetTreeOptionKeys.bind(this, name),
    showLine: props.showLine,
    isSearch: props.isSearch,
    onSearch: props.onSearch,
    onSelect: props.onTreeSelect,
    checkedAll: true,
    unChecked: true,
    multiple: props.multiple === undefined ? false : props.multiple,
  };
  return returnTypes;
}

/** 输入框 传入数据格式 */
export function getWriteTypes(name, props) {
  const returnTypes = {
    componentName: name,
    gdsconfigformmasterId: props.gdsconfigformmasterId,
    uploading: props.uploading,
    ...props,
  };
  return returnTypes;
}

/** 保存数据 */
export async function clearSocketData(param) {
  message.destroy();
  const { token, value, sModelsId } = param;
  const { optName } = value;
  const dataReturn = (await commonServices.postValueService( token, value, `${commonConfig.server_host}sysWebsocket/clearUserOperationRecord?sModelsId=${sModelsId}` )).data;
  /*   成功的话返回数据   */
  if (dataReturn.code === 1) { /*   成功   */
    if (!commonUtils.isEmpty(optName)) {
      message.success(optName + dataReturn.msg);
    }
    return dataReturn;
  } else { /*   失败   */
    message.error(dataReturn.msg);
    return false;
  }
}
/*
* title:主题
* bVisibleMemo:是否可是操作
* memoField:修改的字段
* currRecord:当前修改的数据
* data:数据
* props
* */
export function createMemoProps(name, props) {
  const { sCurrMemoProps } = props;
  if (commonUtils.isNotEmptyObject(sCurrMemoProps) && commonUtils.isEmptyStr(sCurrMemoProps.title)) {
    sCurrMemoProps.title = '详细';
    sCurrMemoProps.name = name;
  }
  const sMemoProps = {
    ...sCurrMemoProps,
    dataSource: props[`${name}Data`],
    onSaveState: props.onSaveState,
    onGetMemo: props.onGetMemo,
    onGetMemoCancel: props.onGetMemoCancel,
  };
  return sMemoProps;
}

/** 处理图表传入数据格式 */
export function getCharTypes(name, configList, configAndData, props, otherSetting) {
  const returnTypes = {
    ...otherSetting,
    name,
    app: props.app,
    formId: props.sModelsId,
    charConfigAndData: configAndData, /* 总图表配置及数据 */
    charConfigList: configList, /* 配置集 */
    gdsformconst: [], /* 常量 */
    charMenu: [], /* 图表右查询菜单 */
  };
  return returnTypes;
}

/** 处理图表传入数据格式 */
export function getCharConfig(name, charType, dataID, order, width, height) {
  return {
    showName: name,
    iWidth: width,
    sCharType: charType,
    sDataID: dataID,
    iHeight: height,
    iOrder: order,
    sId: dataID + order,
  };
}