qiangmj / ebc-Mes

/* eslint-disable array-callback-return,no-undef,guard-for-in,object-curly-newline,prefer-destructuring */
/* 用于存放涉及逻辑的通用方法 */
import React from 'react';
import moment from 'moment';
import ShowTableCell from './ShowTableCell';
import * as utils from '../../utils/utils';

const masterPrefix = 'master.'; /*   主表前缀数据格式:字符串)   */
const slavePrefix = 'slave.'; /*   从表前缀数据格式:字符串)   */

/** 把主表字段绑定要相应的控件上 */
export function mapPropsToFields(masterData, Form) {
  const result = {};
  Object.keys(masterData).forEach((child) => {
    const firstKey = child.substring(0, 1);
    if (firstKey !== 't') {
      result[child] = Form.createFormField({ value: masterData[child] });
    } else {
      const dateFormat = 'YYYY-MM-DD HH:mm:ss'; /* 日期控件显示格式 */
      const value = masterData[child] !== null ? moment(masterData[child], dateFormat) : null;
      result[child] = Form.createFormField({ value });
    }
  });
  return result;
}

/** 把从表字段绑定要相应的控件上 */
export function mapPropsToFieldsSlave(slaveData, Form) {
  /*   待用数据声明   */
  const result = []; /*   返回值   */
  const dateFormat = 'YYYY-MM-DD HH:mm:ss'; /*   日期控件显示格式   */
  /*   执行条件   */
  if (utils.isNotEmptyArr(slaveData)) {
    /*   遍历每一行从表数据   */
    for (const each of slaveData) {
      /*   返回值的内部对象   */
      const resultObj = {};
      /*   遍历每一行从表对象的key   */
      for (const key of Object.keys(each)) {
        /*   获取key的首字母用于判断类型   */
        const firstKey = key.substring(0, 1);
        /*   日期格式的稍作转换   */
        const value = firstKey === 't' ? utils.convertObjToMoment(each[key], dateFormat) : each[key];
        /*   返回值内部对象赋值   */
        resultObj[key] = Form.createFormField({ value });
      }
      /*   返回值赋值   */
      result.push(resultObj);
    }
  }
  /*   返回值   */
  return result;
}

/** 系统参数日期格式化 */
export function getDateFormat(systemData) {
  if (utils.isUndefined(systemData)) {
    return 'YYYY-MM-DD';
  }
  const sCbxDateTime = systemData.filter(item => (item.sName === 'CbxDateTime'));
  const [{ sValue }] = sCbxDateTime;
  let dateFormat = 'YYYY-MM-DD';
  if (sValue !== undefined) {
    if (sValue === '1') {
      dateFormat = 'YYYY-MM-DD HH:mm:ss';
    } else if (sValue === '3') {
      dateFormat = 'HH:mm:ss';
    }
  }
  return dateFormat;
}


/** 列表显示日期格式化 */
export function getDate(props, data) {
  const { systemData } = props.app;
  const sCbxDateTime = systemData.filter(item => (item.sName === 'CbxDateTime'));
  const [{ sValue }] = sCbxDateTime;
  if (sValue !== undefined) {
    const dataSplit = data.split(' ');
    if (sValue === '2') {
      data = dataSplit[0];
    } else if (sValue === '3') {
      data = dataSplit[1];
    }
  }
  return data;
}

/** 获取主表显示的控件集 */
export function getMasterShowConfig(masterConfig, masterShowConfig) {
  if (utils.isEmptyArr(masterShowConfig)) {
    const masterConfigData = masterConfig.gdsconfigformslave;
    masterShowConfig = masterConfigData.filter(item => item.sName !== '' && item.bVisible && item.showName !== '');
  }
  return masterShowConfig;
}

/** 获取主表默认值 */
export function getDefaultMasterData(masterShowConfig) {
  const masterData = {};
  masterShowConfig.forEach((childConfig) => {
    const { sDefault, sName } = childConfig;
    if (sDefault !== '') {
      masterData[sName] = sDefault;
    }
  });
  return masterData;
}
/** 根据表配置获取表头 */
export function getHeaderConfig(config, column) {
  if (utils.isEmptyArr(column)) {
    const tableConfig = config.gdsconfigformslave;
    for (const child of tableConfig) {
      if (child.sName !== '' && child.bVisible && child.showName !== '') {
        column.push({
          title: child.showName,
          dataIndex: child.sName,
          width: child.iFitWidth,
        });
      }
    }
  }
  return column;
}

export function getListHeader(config, column) {
  if (utils.isEmptyArr(column)) {
    const tableConfig = config.gdsconfigformslave;
    for (const child of tableConfig) {
      if (child.sName !== '' && child.bVisible && child.showName !== '') {
        column.push({
          title: child.showName,
          dataIndex: child.sName,
          width: child.iFitWidth,
          render: text => <ShowTableCell dataIndex={child.sName} value={text} width={child.iFitWidth} />,
        });
      }
    }
  }
  return column;
}


/** 获取表格宽度 */
export function getScrollX(columns) {
  let scrollX = 37;
  for (const each of columns) {
    scrollX += each.width;
  }
  return scrollX;
}


/** 控制主表控件是否渲染 */
export function setIsMasterRender(isMasterRender, renderArr) {
  for (const item of Object.keys(isMasterRender)) {
    isMasterRender[item] = renderArr.indexOf(item) >= 0;
  }
  return { ...isMasterRender };
}

/** 获取从表显示的控件集 */
export function getSlaveShowConfig(slaveConifg, slaveShowConfig) {
  if (utils.isEmptyArr(slaveShowConfig)) {
    const slaveConfigData = slaveConifg.gdsconfigformslave;
    slaveShowConfig = slaveConfigData.filter(item => item.sName !== '' && item.bVisible && item.showName !== '');
  }
  return slaveShowConfig;
}

/**   控制从表控件是否渲染(数据格式:{sSlaveId1:{sProductId:true,sProductUnit:false},sSlaveId2:{sProductId:false,sProductUnit:true}})   */
export function setIsSlaveRender(props) {
  const { slaveData, slaveColumn } = props;
  let { showSlaveRender } = props;
  showSlaveRender = utils.isUndefined(showSlaveRender) ? {} : showSlaveRender;
  const isSlaveRender = [];
  for (const eachSlave of slaveData) {
    const renderEach = showSlaveRender[eachSlave.sId];
    const obj = {};
    for (const eachSlaveColumn of slaveColumn) {
      obj[eachSlaveColumn.dataIndex] = (utils.isNotEmptyObject(renderEach) && utils.isNotUndefined(renderEach[eachSlaveColumn.dataIndex]));
    }
    isSlaveRender[eachSlave.sId] = obj;
  }
  props.isSlaveRender = { ...isSlaveRender };
  return props;
}

/**   控制从表控件是否渲染(渲染整列)   */
export function setIsSlaveRenderArr(isSlaveRender, showSlaveRender) {
  if (utils.isNotEmptyArr(isSlaveRender)) {
    for (const key of Object.keys(isSlaveRender)) {
      const row = isSlaveRender[key];
      for (const cell of Object.keys(row)) {
        row[cell] = showSlaveRender.indexOf(cell) >= 0;
      }
    }
  }
  return isSlaveRender;
}

/** 根据配置和权限，筛选出显示的按钮 */
export function getShowBtn(props) {
  const menuData = [];
  const { masterConfig, gdsjurisdiction, btnData, report } = props;
  const { gdsconfigformslave } = masterConfig; /* 获取权限集合 */
  /*   初始赋值数据值声明   */
  const btnShowData = [...btnData];
  /*  配置先过滤出按钮或则页签的集合    */
  const baseCondition = gdsconfigformslave.filter(item => item.sName === '' && item.showName !== '');

  /** 根据权限，筛选出显示的按钮  */
  gdsjurisdiction.forEach((child) => {
    const index = btnShowData.findIndex(item => item.sControlName === child.sAction);
    if (index > -1) {
      btnShowData.splice(index, 1);
    }
  });

  /** 权限筛选后根据配置，筛选出显示的按钮 */
  baseCondition.forEach((child) => {
    const index = btnShowData.findIndex(item => item.sControlName === child.sControlName && !child.bVisible);
    if (index > -1) {
      btnShowData.splice(index, 1);
    }
  });
  /*  筛选出一级菜单    */
  const parMenu = btnShowData.filter(item => !item.sControlName.includes('.'));
  /*  初始值的二级菜单    */
  const childMenu = btnShowData.filter(item => item.sControlName.includes('.'));

  /** 配置后匹配二级菜单 */
  parMenu.forEach((childPar) => {
    const { pIdentify, sControlName } = childPar;
    childPar.child = [];
    /** 匹配相应的子菜单 */
    const childData = childMenu.filter(item => item.sControlName.startsWith(`${sControlName}.`));
    if (utils.isNotEmptyArr(childData)) {
      childPar.child.push(...childData);
    }

    if (sControlName === 'BtnPrint') {
      /*   打印的二级菜单集合   */
      const reportChild = [];
      for (const each of report) {
        reportChild.push({
          sControlName: `BtnPrint.${each.sReportName}`,
          showName: each.sReportName,
          disabled: false,
          sId: each.sId,
        });
      }
      childPar.child.push(...reportChild);
    }

    if (pIdentify !== '') {
      /*   复制到、上查、下查、复制从的二级菜单集合   */
      const pIdentifyChild = baseCondition.filter(item => item.sControlName.startsWith(childPar.pIdentify) && item.bVisible);
      const pIdentifyEachChild = [];
      for (const each of pIdentifyChild) {
        const slaveCopeTo = [];
        const obj = {};
        if (pIdentify === 'BtnCopyTo_') {
          const pIdentifyOfBtnCopyToChild = baseCondition.filter(item => item.sControlName.startsWith('BtnCopyTo_'));
          for (const item of pIdentifyOfBtnCopyToChild) {
            const { sAssignField } = item;
            const splitArray = item.sControlName.split('_');
            if (splitArray.length === 2) {
              /*  返回新对象——主表赋值  */
              obj.masterCopeTo = utils.returnObjValue(sAssignField);
            } else {
              /* 返回新对象 */
              const slaveChild = utils.returnObjValue(sAssignField);
              slaveCopeTo.push(slaveChild);
            }
          }
          if (utils.isNotEmptyArr(slaveCopeTo)) {
            obj.slaveCopeTo = slaveCopeTo;
          }
        }
        /*   将上查、下查的三级菜单数据存入   */
        if (pIdentify === 'BtnUpCheck.' || pIdentify === 'BtnDownCheck.') {
          if (each.sControlName === props.toolBarSearchUpDownThirdMenuKey) {
            obj.thirdMenu = props.toolBarSearchUpDownThirdMenuData;
          }
        }
        pIdentifyEachChild.push({
          sControlName: each.sControlName,
          showName: each.showName,
          sId: each.sId,
          disabled: false,
          sActiveId: utils.strUndefinedToEmpty(each.sActiveId),
          ...obj,
        });
      }
      childPar.child.push(...pIdentifyEachChild);
    }
    menuData.push(childPar);
  });
  return menuData;
}

/**   通用失败   */
export function handleCommonFail(props, data) {
  /*   待用数据声明   */
  const { dispatch } = props;
  /*   错误处理   */
  dispatch({ type: 'app/throwError', payload: data });
  /*   返回值赋值   */
  props.pageLoading = false;
  /*   返回值   */
  return props;
}

// ----------------------------获取sqlCondition start---------------------------- //
/**   获取sqlCondition对象   */
export function getSqlCondition(sSqlCondition, sSlaveId, slaveData, masterData) {
  /*   返回值声明   */
  const obj = {};
  /*   执行条件   */
  if (utils.isNotEmptyStr(sSqlCondition)) {
    /*   逗号分割sqlCondition为数组   */
    const arr = sSqlCondition.split(',');
    /*   遍历sqlCondition数组   */
    for (let key of arr) {
      /*   去掉空格   */
      key = key.trim();
      /*   获取sqlCondition对应key的value   */
      const value = this.getSqlConditionData(
        key,
        sSlaveId,
        slaveData,
        masterData,
      );
      /*   可用的value进行返回值赋值   */
      if (value) {
        obj[key.replace(masterPrefix, '').replace(slavePrefix, '')] = value;
      }
    }
  }
  /*   返回值   */
  return obj;
}

/*   获取sqlCondition数据   */
export function getSqlConditionData(key, sSlaveId, slaveData, masterData) {
  if (key.startsWith(masterPrefix)) { /*   从主表中获取数据   */
    return this.getSqlConditionByMaster(key.replace(masterPrefix, ''), masterData);
  } else if (key.startsWith(slavePrefix)) { /*   从从表中获取数据   */
    return this.getSqlConditionBySlave(
      key.replace(slavePrefix, ''),
      slaveData,
      sSlaveId,
    );
  } else { /*   从主表和从表中一起获取数据   */
    return this.getSqlConditionByMasterSlave(
      key,
      masterData,
      slaveData,
      sSlaveId,
    );
  }
}

/*   从主表中获取sqlCondition数据   */
export function getSqlConditionByMaster(key, masterData) {
  return masterData[key];
}

/*   从从表中获取sqlCondition数据   */
export function getSqlConditionBySlave(key, slaveData, sSlaveId) {
  /*   获取从表的本条数据   */
  const slaveObj = slaveData.filter(item => item.sId === sSlaveId);
  /*   返回值   */
  return utils.isNotEmptyArr(slaveObj) ? slaveObj[0][key] : null;
}

/*   从主从表中获取sqlCondition数据   */
export function getSqlConditionByMasterSlave(key, masterData, slaveData, sSlaveId) {
  /*   先从主表中获取数据   */
  let value = this.getSqlConditionByMaster(key, masterData);
  /*   再从从表中获取数据   */
  if (!value && utils.isNotEmptyStr(sSlaveId)) {
    value = this.getSqlConditionBySlave(key, slaveData, sSlaveId);
  }
  /*   返回值   */
  return value;
}
// ----------------------------获取sqlCondition end  ---------------------------- //

// ----------------------------单据渲染start---------------------------- //
// -------------------------主表单据渲染start------------------------- //
/**   设置主表渲染   */
export function setMasterRender(masterShowConfig, masterShowRender) {
  /*   填充主表渲染容器(默认值都给false)   */
  let isMasterRender = setMasterRenderTrueOrFalse(masterShowConfig, false);
  /*   设置主表渲染容器值   */
  isMasterRender = setMasterRenderContainerValue(isMasterRender, masterShowRender);
  /*   返回值   */
  return isMasterRender;
}

/**   设置主表渲染(全是true或false)   */
export function setMasterRenderTrueOrFalse(masterShowConfig, value) {
  /*   返回值声明   */
  const isMasterRender = {};
  /*   主表配置有值才进行容器赋值,否则就返回空对象了   */
  if (utils.isNotEmptyArr(masterShowConfig)) {
    /*   遍历主表配置结构:[{},{},{}...]   */
    for (const each of masterShowConfig) {
      /*   sName为key,初始值都是false   */
      isMasterRender[each.sName] = value;
    }
  }
  /*   返回值   */
  return isMasterRender;
}

/**   设置主表渲染容器值   */
export function setMasterRenderContainerValue(isMasterRender, masterShowRender) {
  /*   如果没设置渲染数组就直接返回都是false的渲染容器即可   */
  if (utils.isNotEmptyArr(masterShowRender)) {
    /*   渲染数组有值的话就遍历并把在渲染容器中对应的sName都变成true   */
    for (const sName of masterShowRender) {
      isMasterRender[sName] = true;
    }
  }
  /*   返回值   */
  return isMasterRender;
}
// -------------------------主表单据渲染end  ------------------------- //

// -------------------------从表单据渲染start------------------------- //
/**   设置从表渲染   */
export function setSlaveRender(slaveShowConfig, slaveData, slaveShowRender) {
  /*   填充从表表渲染容器(默认值都给false)   */
  let isSlaveRender = setSlaveRenderTrueOrFalse(slaveShowConfig, slaveData, false);
  /*   设置从表渲染容器值   */
  isSlaveRender = setSlaveRenderContainerValue(isSlaveRender, slaveShowRender);
  /*   返回值   */
  return isSlaveRender;
}

/**   设置从表渲染(全是true或false)   */
export function setSlaveRenderTrueOrFalse(slaveShowConfig, slaveData, value) {
  /*   返回值声明,数据结构{sSlaveId1:{sProductId:true,sProductQty:false},sSlaveId2:{sProductId:true,sProductQty:false},sSlaveId3:{sProductId:true,sProductQty:false}...}   */
  const isSlaveRender = {};
  /*   从表配置和从表数据都必须有值才进行容器赋值,否则就返回空对象了   */
  if (utils.isNotEmptyArr(slaveShowConfig) && utils.isNotEmptyArr(slaveData)) {
    /*   遍历从表数据:[{},{},{}...]   */
    for (const eachSlaveData of slaveData) {
      /*   声明容器内部对象   */
      const isSlaveRenderEach = {};
      /*   遍历从表配置:[{},{},{}...]   */
      for (const eachSlaveShowConfig of slaveShowConfig) {
        /*   给每一个从表配置内部对象赋默认值为false   */
        isSlaveRenderEach[eachSlaveShowConfig.sName] = value;
      }
      /*   给渲染容器对象的row赋值   */
      isSlaveRender[eachSlaveData.sId] = isSlaveRenderEach;
    }
  }
  /*   返回值   */
  return isSlaveRender;
}

/**   设置从表渲染容器值   */
export function setSlaveRenderContainerValue(isSlaveRender, slaveShowRender) {
  /*   如果没设置渲染对象就直接返回都是false的渲染容器即可   */
  if (utils.isNotEmptyObject(slaveShowRender) && utils.isNotEmptyObject(isSlaveRender)) {
    /*   渲染对象有值的话就遍历并把在渲染容器中对应的sName都变成true   */
    for (const sSlaveId of Object.keys(slaveShowRender)) {
      /*   获取渲染对象中的从表数据   */
      const valueArr = slaveShowRender[sSlaveId];
      /*   获取渲染容器中对应的从表row   */
      const isSlaveRenderEach = isSlaveRender[sSlaveId];
      /*   如果如安然对象的从表数据有值,则把这个值付给渲染对象   */
      if (utils.isNotEmptyArr(valueArr)) {
        /*   循环赋值   */
        for (const key of valueArr) {
          isSlaveRenderEach[key] = true;
        }
      }
    }
  }
  /*   返回值   */
  return isSlaveRender;
}

/**   设置从表渲染(整列渲染)   */
export function setSlaveCellRender(slaveShowConfig, slaveData, slaveShowRender) {
  /*   填充从表表渲染容器(默认值都给false)   */
  let isSlaveRender = setSlaveRenderTrueOrFalse(slaveShowConfig, slaveData, false);
  /*   设置从表渲染容器值   */
  isSlaveRender = setSlaveCellRenderContainerValue(isSlaveRender, slaveShowRender);
  /*   返回值   */
  return isSlaveRender;
}

/**   设置从表渲染容器值(整列渲染)   */
export function setSlaveCellRenderContainerValue(isSlaveRender, slaveShowRender) {
  /*   如果没设置渲染数组就直接返回都是false的渲染容器即可   */
  if (utils.isNotEmptyArr(slaveShowRender)) {
    /*   渲染对象有值的话就遍历并把在渲染容器中对应的sName都变成true   */
    for (const key of Object.keys(isSlaveRender)) {
      const isSlaveRenderEach = isSlaveRender[key];
      /*   循环赋值   */
      for (const sName of Object.keys(isSlaveRenderEach)) {
        isSlaveRenderEach[sName] = slaveShowRender.indexOf(sName) >= 0;
      }
    }
  }
  /*   返回值   */
  return isSlaveRender;
}
// -------------------------从表单据渲染end  ------------------------- //
// ----------------------------单据渲染end  ---------------------------- //

// ----------------------------合计列start---------------------------- //
/**   添加合计列数据   */
export function addDataTotal(slaveShowConfig, dataTotal, slaveData, isNeed) {
  /*   获取待合计字段   */
  const slaveTotal = [];
  const dataTotalColumn = this.getDataTotalColumn(slaveShowConfig, dataTotal);
  /*   从表配置,从表数据和待合计字段都不为空的时候才进行数据合计   */
  if (utils.isNotEmptyArr(slaveShowConfig) && utils.isNotEmptyObject(dataTotalColumn) && utils.isNotEmptyArr(slaveData)) {
    /*   获取合计对象   */
    const totalObj = getTotalObj(slaveShowConfig, slaveData, dataTotalColumn, isNeed);
    /*   添加合计对象   */
    slaveTotal.push(totalObj);
  }
  /*   返回值   */
  return slaveTotal;
}

/**   获取合计列数据   */
export function getDataTotalColumn(slaveShowConfig, dataTotal) {
  /*   如果接口传了合计字段那就用接口的合计字段   */
  if (utils.isNotEmptyObject(dataTotal)) {
    return dataTotal;
  }
  /*   返回值   */
  const dataTotalColumn = {};
  /*   如果存在从表配置   */
  if (utils.isNotEmptyArr(slaveShowConfig)) {
    /*   遍历从表配置   */
    for (const each of slaveShowConfig) {
      /*   将需要合计的sName存入合计列对象中   */
      if (each.bSum) {
        dataTotalColumn[each.sName] = 0;
      }
    }
  }
  /*   返回值   */
  return dataTotalColumn;
}

/**   获取合计对象   */
export function getTotalObj(slaveShowConfig, slaveDataNoTotal, dataTotalColumn, isNeed) {
  /*   待用数据声明   */
  const sId = utils.createSid(); /*   唯一标示   */
  const totalObj = {
    dataTotal: true,
    key: sId,
    sId,
  };/*   统计对象的必须数据   */
  /*   遍历表头   */
  for (const each of slaveShowConfig) {
    /*   获取sName   */
    const sName = each.sName;
    /*   给合计对象添加属性和值   */
    totalObj[sName] = getStatisticsValue(sName, slaveDataNoTotal, dataTotalColumn, isNeed);
  }
  /*   返回值   */
  return totalObj;
}

/**   获取统计值   */
export function getStatisticsValue(sName, slaveDataNoTotal, dataTotalColumn, isNeed) {
  /*   返回值声明   */
  let res = '';
  /*   过滤出需要统计的列   */
  if (utils.isNotUndefined(dataTotalColumn[sName])) {
    /*   判断是否需要统计(需要统计的话要遍历从表,不需要的话就直接取dataTotal中的数据)   */
    if (isNeed) { /*   把需要统计的列sum起来   */
      for (const each of slaveDataNoTotal) {
        res = utils.convertStrToNumber0(res) + utils.convertStrToNumber0(each[sName]);
      }
    } else { /*   不需要的统计的话直接取dataTotal中的值   */
      res = dataTotalColumn[sName];
    }
  }
  /*   返回值   */
  return res;
}
// ----------------------------合计列end  ---------------------------- //

// ----------------------------复制到start---------------------------- //
/*   复制到主表赋值   */
export function getCopyToMasterAssign(masterData, masterAssign) {
  /*   返回值声明   */
  const masterAssignData = {};
  /*   两个集合都不为空才执行赋值,要不就直接返回空数组就好了   */
  if (utils.isNotEmptyObject(masterAssign) && utils.isNotEmptyObject(masterData)) {
    /*   遍历赋值数据   */
    for (const targetKey of Object.keys(masterAssign)) {
      /*   获取主表的数据key   */
      const key = masterAssign[targetKey];
      /*   主表值   */
      const value = masterData[key];
      /*   给这个目标key赋值   */
      if (utils.isNotUndefined(value)) {
        masterAssignData[targetKey] = value;
      }
    }
  }
  /*   返回值   */
  return masterAssignData;
}

/*   复制到从表赋值   */
export function getCopyToSlaveAssign(slaveData, slaveAssign, masterData) {
  /*   返回值声明   */
  const slaveAssignData = [];
  /*   两个集合都不为空才执行赋值,要不就直接返回空数组就好了   */
  if (utils.isNotEmptyArr(slaveAssign) && utils.isNotEmptyArr(slaveData)) {
    /*   暂时先取从表的第一条,之后再调整为动态的   */
    const slaveAssignFirst = slaveAssign[0];
    /*   遍历从表数据   */
    for (const each of slaveData) {
      /*   合计行不处理   */
      if (!each.dataTotal) {
        /*   创建从表sId   */
        const sId = utils.createSid();
        /*   每一行的容器对象声明   */
        const slaveAssignDataEach = {
          sId,
          key: sId,
        };
        /*   遍历从表数据的每一个key   */
        for (const key of Object.keys(each)) {
          const targetKey = utils.getObjKeyByValue(slaveAssignFirst, key);
          /*   如果该赋值字段存在,则给数据赋值   */
          if (utils.isNotUndefined(targetKey)) {
            slaveAssignDataEach[targetKey] = targetKey.startsWith('#') && targetKey.endsWith('#') ? masterData[key] : each[key];
          }
        }
        /*   容器赋值   */
        slaveAssignData.push(slaveAssignDataEach);
      }
    }
  }
  /*   返回值   */
  return slaveAssignData;
}

// ----------------------------复制到end  ---------------------------- //