Source/UBCS/ubcs-service/ubcs-code/src/main/java/com/vci/ubcs/code/service/impl/MdmProductCodeServiceImpl.java

@@ -1,743 +1,797 @@
package com.vci.ubcs.code.service.impl;

import com.vci.ubcs.code.constant.MdmEngineConstant;
import com.vci.ubcs.code.dao.CodeAllCodeDaoI;
import com.vci.ubcs.code.mapper.CodeSerialValueMapper;
import com.alibaba.nacos.common.utils.StringUtils;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.BeanUtils;
import com.vci.ubcs.code.bo.CodeClassifyFullInfoBO;
import com.vci.ubcs.code.dto.CodeOrderSecDTO;
import com.vci.ubcs.code.entity.CodeAllCode;
import com.vci.ubcs.code.entity.CodeSerialValue;
import com.vci.ubcs.code.enumpack.CodeCutTypeEnum;
import com.vci.ubcs.code.enumpack.CodeGetValueTypeEnum;
import com.vci.ubcs.code.enumpack.CodeLevelTypeEnum;
import com.vci.ubcs.code.enumpack.CodeSecTypeEnum;
import com.vci.ubcs.code.lifecycle.CodeAllCodeLC;
import com.vci.ubcs.code.entity.CodeAllCodeDO;
import com.vci.ubcs.code.entity.CodeSerialValueDO;
import com.vci.ubcs.code.service.MdmProductCodeServiceI;
import com.vci.corba.common.VCIError;
import com.vci.starter.web.constant.QueryOptionConstant;
import com.vci.starter.web.constant.RegExpConstant;
import com.vci.starter.web.exception.VciBaseException;
import com.vci.starter.web.pagemodel.PageHelper;
import com.vci.starter.web.pagemodel.SessionInfo;
import com.vci.starter.web.util.VciBaseUtil;
import com.vci.starter.web.util.VciDateUtil;
import com.vci.web.enumpck.OsCodeFillTypeEnum;
import com.vci.web.pageModel.BatchCBO;
import com.vci.web.service.WebBoServiceI;
import com.vci.web.service.impl.FormulaServiceImpl;
import com.vci.web.util.WebUtil;
import org.apache.commons.lang3.StringUtils;
import com.vci.ubcs.code.bo.CodeClassifyFullInfoBO;
import com.vci.ubcs.code.dto.CodeOrderSecDTO;
import com.vci.ubcs.code.mapper.CodeSerialValueMapper;
import com.vci.ubcs.code.service.ICodeWupinService;
import com.vci.ubcs.code.service.MdmEngineService;
import com.vci.ubcs.code.service.MdmProductCodeService;
import com.vci.ubcs.code.vo.pagemodel.CodeBasicSecVO;
import com.vci.ubcs.code.vo.pagemodel.CodeClassifyTemplateVO;
import com.vci.ubcs.code.vo.pagemodel.CodeClassifyVO;
import com.vci.ubcs.code.vo.pagemodel.CodeRuleVO;
import com.vci.ubcs.starter.exception.VciBaseException;
import com.vci.ubcs.starter.revision.model.BaseModel;
import com.vci.ubcs.starter.util.DefaultAttrAssimtUtil;
import com.vci.ubcs.starter.util.MdmBtmTypeConstant;
import com.vci.ubcs.starter.web.constant.QueryOptionConstant;
import com.vci.ubcs.starter.web.constant.RegExpConstant;
import com.vci.ubcs.starter.web.enumpck.OsCodeFillTypeEnum;
import com.vci.ubcs.starter.web.util.VciBaseUtil;
import com.vci.ubcs.starter.web.util.VciDateUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils;
import plm.bs.bom.clientobject.ClientBusinessObject;

import javax.annotation.Resource;
import java.util.*;
import java.util.concurrent.atomic.AtomicReference;
import java.util.stream.Collectors;

import static com.vci.web.other.BdSelectInputCharAspect.SEP;

/**
 * 生成编码的服务
 * @author weidy
 * @date 2022-3-6
 */
import static com.vci.ubcs.code.constant.MdmEngineConstant.*;
@Service
public class MdmProductCodeServiceImpl implements MdmProductCodeServiceI {
public class MdmProductCodeServiceImpl  implements MdmProductCodeService {

    /**
     * 业务数据的服务
     */
    @Autowired
    @Lazy
   private WebBoServiceI boService;
   /**
    * 流水号的相关的信息
    */
   @Resource
   private CodeSerialValueMapper serialValueMapper;

    /**
     * 所有的编码的内容
     */
    @Autowired
    private CodeAllCodeDaoI allCodeMapper;
   /**
    * 所有的编码的内容
    */
   @Resource
   private CodeAllCodeServiceImpl codeAllCodeService;

    /**
     * 流水号的相关的信息
     */
    @Autowired
    private CodeSerialValueMapper serialValueMapper;
   /**
    * 所有的编码的内容
    */
   @Resource
   private ICodeWupinService iCodeWupinService;
   /**
    * 所有的编码的内容
    */
   @Resource
   @Lazy
   private MdmEngineService mdmEngineService;

    /**
     * 公式的服务
     */
    @Autowired
    private FormulaServiceImpl formulaService;
    /**
     * 生成编码--并且保存数据
     *
     * @param classifyFullInfoBO 分类的全部信息
     * @param templateVO         模板的显示对象
     * @param ruleVO             编码规则的显示对象
     * @param secDTOList         各个码段的值
     * @param dataCBOList        业务数据
     */
    @Override
    public synchronized List<String> productCodeAndSaveData(CodeClassifyFullInfoBO classifyFullInfoBO, CodeClassifyTemplateVO templateVO,
                                             CodeRuleVO ruleVO, List<CodeOrderSecDTO> secDTOList, List<ClientBusinessObject> dataCBOList) {
        BatchCBO batchCBO = new BatchCBO();
        WebUtil.setPersistence(false);
        dataCBOList = dataCBOList.stream().sorted(((o1, o2) -> o1.getCreateTime().compareTo(o2.getCreateTime()))).collect(Collectors.toList());
        batchCBO.getCreateCbos().addAll(dataCBOList);
        List<String> codeList = new ArrayList<>();
   /**
    * 公式的服务
    */
   @Autowired
   private FormulaServiceImpl formulaService;

        /*****
         * 保证并发的时候，最大流水号都对的，但是这种加锁有弊端
         *
         */
   @Override
   @Transactional(rollbackFor = VciBaseException.class)
   public List<String> productCodeAndSaveData(CodeClassifyFullInfoBO classifyFullInfoBO, CodeClassifyTemplateVO templateVO, CodeRuleVO ruleVO, List<CodeOrderSecDTO> secDTOList, List<BaseModel> dataCBOList) throws Exception {
//      BatchCBO batchCBO = new BatchCBO();
//      WebUtil.setPersistence(false);
      dataCBOList = dataCBOList.stream().sorted(((o1, o2) -> o1.getCreateTime().compareTo(o2.getCreateTime()))).collect(Collectors.toList());
//      batchCBO.getCreateCbos().addAll(dataCBOList);
      List<String> codeList = new ArrayList<>();

        if(dataCBOList.stream().anyMatch(cbo->StringUtils.isNotBlank(cbo.getId()) && StringUtils.isNotBlank(cbo.getAttributeValue(MdmEngineConstant.CODE_SEC_LENGTH_FIELD)))){
            //是历史数据导入
            //历史数据执行的时候，这个系统会很卡
            //主要是为了录入最大流水号和allcode
            SessionInfo sessionInfo = VciBaseUtil.getCurrentUserSessionInfo();
            List<CodeAllCodeDO> allCodeDOList = new ArrayList<>();
            Map<String/**流水依据**/,Map<String/**码段的主键**/,Double/**最大流水号**/>> maxSerialMap = new HashMap<>();
            dataCBOList.parallelStream().forEach(cbo->{
                VciBaseUtil.setCurrentUserSessionInfo(sessionInfo);
                String code = cbo.getId();
                List<String> serialUnitList = new ArrayList<>();
                String[] secLengths = cbo.getAttributeValue(MdmEngineConstant.CODE_SEC_LENGTH_FIELD).split("#");
                List<CodeBasicSecVO> secVOList = ruleVO.getSecVOList().stream().sorted(((o1, o2) -> o1.getOrderNum().compareTo(o2.getOrderNum()))).collect(Collectors.toList());
                Map<String/**码段的主键**/,String/**码段的值**/> serialValueMap = new HashMap<>();
                Map<String, CodeBasicSecVO> secVOMap = secVOList.stream().collect(Collectors.toMap(s -> s.getOid(), t -> t));
                for (int i = 0; i < secLengths.length; i++) {
                    CodeBasicSecVO secVO = secVOList.get(i);
                    String thisSecValue  = "";
                    if(i == 0){
                        thisSecValue = code.contains("#")?code.substring(0,code.indexOf("#")):code;
                    } else if(i == secLengths.length-1){
                        //最后
                        thisSecValue =  code.contains("#")?code.substring(code.lastIndexOf("#")):code;
                    }else {
                        int start = 0;
                        for (int j = 0; j < i; j++) {
                            start += VciBaseUtil.getInt(secLengths[j]) + 1;
                        }
                        thisSecValue = code.substring(start,start+VciBaseUtil.getInt(secLengths[1]));
                    }
                    if(VciBaseUtil.getBoolean(secVO.getSerialDependFlag())){
                        serialUnitList.add(thisSecValue);
                    }
                    if(CodeSecTypeEnum.CODE_SERIAL_SEC.getValue().equalsIgnoreCase(secVO.getSectype())){
                        serialValueMap.put(secVO.getOid(),thisSecValue);
                    }
                }
                String serialUnitString = serialUnitList.size() == 0 ? MdmEngineConstant.EMPTY_SERIAL_UNIT : serialUnitList.stream().collect(Collectors.joining(MdmEngineConstant.SERIAL_UNIT_SPACE));
                List<String> serialUnFileStringList = new ArrayList<>();
                if(!CollectionUtils.isEmpty(serialValueMap)){
                    serialValueMap.forEach((secOid,secValue)->{
                        //要看是不是补位的
                        CodeBasicSecVO secVO = secVOMap.get(secOid);
                        Double serialDb = null;
                        if(OsCodeFillTypeEnum.NONE.getValue().equalsIgnoreCase(secVO.getCodeFillType())){
                            //不补码
                            //把所有不是数字的去掉，因为可能会是老数据，新规则
                            serialDb = VciBaseUtil.getDouble(killUnNumberChar(secValue));
                        }else {
                            //左右填充的，我们需要
                            serialDb = VciBaseUtil.getDouble(killUnNumberChar(killFillChar(secValue,secVO.getCodeFillSeparator(),
                                    OsCodeFillTypeEnum.LEFT.getValue().equalsIgnoreCase(secVO.getCodeFillType()))));
                        }
                        Map<String, Double> thisUnitMaxMap = maxSerialMap.getOrDefault(serialUnitString, new HashMap<>());
                        thisUnitMaxMap.put(secOid,serialDb);
                        maxSerialMap.put(serialUnitString,thisUnitMaxMap);
                        serialUnFileStringList.add(String.valueOf(serialDb));
                    });
                }
                CodeAllCodeDO allCodeDO = new CodeAllCodeDO();
                allCodeDO.setCodeClassifyOid(classifyFullInfoBO.getCurrentClassifyVO().getOid());
                allCodeDO.setCodeRuleOid(ruleVO.getOid());
                allCodeDO.setId(cbo.getId());
                allCodeDO.setCodeClassifyTemplateOid(templateVO.getOid());
                allCodeDO.setCreateCodeBtm(cbo.getBtmName());
                allCodeDO.setCreateCodeOid(cbo.getOid());
                allCodeDO.setSerialUnit(serialUnitString);
                allCodeDO.setUnFillSerial(serialUnFileStringList.stream().collect(Collectors.joining(MdmEngineConstant.SERIAL_VALUE_SPACE)));
                allCodeDO.setLcStatus(cbo.getLcStatus());
                allCodeDOList.add(allCodeDO);
            });
            //处理最大的流水号
            List<CodeSerialValueDO> addSerialValueList = new ArrayList<>();
            List<CodeSerialValueDO> editSerialValueList = new ArrayList<>();
            maxSerialMap.forEach((serialUnit,secOidMaxMap)->{
                secOidMaxMap.forEach((secOid,maxSerial)->{
                    Map<String, String> conditionMap = new HashMap<>();
                    conditionMap.put("codeRuleOid", ruleVO.getOid());
                    conditionMap.put("serialUnit", serialUnit);
                    //这个字段是为了解决多个流水的问题
                    conditionMap.put("codeSecOid", secOid);
                    List<CodeSerialValueDO> serialValueDOS = serialValueMapper.selectByCondition(conditionMap, new PageHelper(-1));
                    if (!CollectionUtils.isEmpty(serialValueDOS)) {
                        CodeSerialValueDO serialValueDO = serialValueDOS.get(0);
                        if(VciBaseUtil.getDouble(serialValueDO.getMaxSerial())<maxSerial){
                            serialValueDO.setMaxSerial(String.valueOf(maxSerial));
                            editSerialValueList.add(serialValueDO);
                        }
                    }else{
                        //没有
                        CodeSerialValueDO serialValueDO = new CodeSerialValueDO();
                        serialValueDO.setCodeRuleOid(ruleVO.getOid());
                        serialValueDO.setSerialUnit(serialUnit);
                        serialValueDO.setCodeSecOid(secOid);
                        serialValueDO.setMaxSerial(maxSerial.toString());
                        addSerialValueList.add(serialValueDO);
                    }
                });
            });
            if(!CollectionUtils.isEmpty(addSerialValueList)){
                batchCBO.copyFromOther(serialValueMapper.batchInsert(addSerialValueList));
            }
            if(!CollectionUtils.isEmpty(editSerialValueList)){
                batchCBO.copyFromOther(serialValueMapper.batchUpdate(editSerialValueList));
            }
            //处理allCode
            if(!CollectionUtils.isEmpty(allCodeDOList)){
                    Map<String, List<CodeAllCodeDO>> ruleGroup = allCodeDOList.stream().collect(Collectors.groupingBy(s -> s.getCodeRuleOid()));
                Map<String, CodeAllCodeDO> codeDOMap = allCodeDOList.stream().collect(Collectors.toMap(s -> s.getCodeRuleOid() + SEP + s.getId(), t -> t));
                List<CodeAllCodeDO> addCodeDOs = new ArrayList<>();
                List<CodeAllCodeDO> editCodeDOs = new ArrayList<>();
                ruleGroup.forEach((ruleOid,allCodeDOS)->{
                    VciBaseUtil.switchCollectionForOracleIn(allCodeDOS).stream().forEach(codeDOs->{
                        Map<String,String> conditionMap = new HashMap<>();
                        conditionMap.put("coderuleoid",ruleOid);
                        conditionMap.put("id",QueryOptionConstant.IN + "(" + VciBaseUtil.toInSql(codeDOs.stream().map(s->s.getId()).collect(Collectors.toList()).toArray(new String[0])) + ")");
                        List<CodeAllCodeDO> existCodes = allCodeMapper.selectByCondition(conditionMap, new PageHelper(-1));
                        if(!CollectionUtils.isEmpty(existCodes)){
                            existCodes.stream().forEach(existCode->{
                                String rule_id = existCode.getCodeRuleOid() + SEP + existCode.getId();
                                if(codeDOMap.containsKey(rule_id)){
                                    CodeAllCodeDO newCodeDO = codeDOMap.get(rule_id);
                                    existCode.setCreateCodeOid(newCodeDO.getOid());
                                    existCode.setCreateCodeBtm(newCodeDO.getCreateCodeBtm());
                                    existCode.setCodeClassifyTemplateOid(newCodeDO.getCodeClassifyTemplateOid());
                                    existCode.setCodeClassifyOid(newCodeDO.getCodeClassifyOid());
                                    existCode.setLcStatus(newCodeDO.getLcStatus());
                                    editCodeDOs.add(existCode);
                                }
                            });
                        }
                    });
                });
                if(!CollectionUtils.isEmpty(editCodeDOs)){
                    Set<String> exitIds = editCodeDOs.stream().map(s -> s.getCodeRuleOid() + SEP + s.getId()).collect(Collectors.toSet());
                    addCodeDOs = allCodeDOList.stream().filter(s -> !exitIds.contains(s.getCodeRuleOid() + SEP + s.getId())).collect(Collectors.toList());
                }else{
                    addCodeDOs = allCodeDOList;
                }
                if(!CollectionUtils.isEmpty(editCodeDOs)){
                    batchCBO.copyFromOther(allCodeMapper.batchUpdate(editCodeDOs));
                }
                if(!CollectionUtils.isEmpty(addCodeDOs)){
                    batchCBO.copyFromOther(allCodeMapper.batchInsert(addCodeDOs));
                    Map<String, String> statusMap = addCodeDOs.stream().collect(Collectors.toMap(s -> s.getOid(), s -> s.getLcStatus()));
                    batchCBO.getCreateCbos().stream().filter(s -> StringUtils.equalsIgnoreCase("codeallcode",s.getBtmName())).forEach(s -> {
                        s.setLcStatus(statusMap.get(s.getOid()));
                        try {
                            s.setAttributeValue("lcstatus",statusMap.get(s.getOid()));
                        } catch (VCIError e) {
                            e.printStackTrace();
                        }
                    });
                }
            }
            WebUtil.setPersistence(true);
            boService.persistenceBatch(batchCBO);
            return codeList;
        }else {
            List<CodeBasicSecVO> secVOList = ruleVO.getSecVOList().stream().sorted(((o1, o2) -> o1.getOrderNum().compareTo(o2.getOrderNum()))).collect(Collectors.toList());
            List<String> serialUnitList = new LinkedList<>();
            List<String> secValueList = new ArrayList<>();
            Map<String, String> secValueMap = secDTOList.stream().collect(Collectors.toMap(s -> s.getSecOid(), s -> s.getSecValue()));
            List<CodeBasicSecVO> serialSecVOList = new ArrayList<>();
            List<CodeBasicSecVO> attrSecVOList = new ArrayList<>();
            for (int i = 0; i < secVOList.size(); i++) {
                CodeBasicSecVO secVO = secVOList.get(i);
                switchSecValue(secVO, secValueMap, classifyFullInfoBO, serialSecVOList, attrSecVOList, serialUnitList, secValueList);
            }
            //处理属性码段和流水码段
            Map<String/**流水码段的主键**/, Map<String/**流水依据**/, Double>> lastMaxSerialValueMap = new HashMap<>();
            List<CodeAllCodeDO> allCodeDOList = new ArrayList<>();
      /*****
       * 保证并发的时候，最大流水号都对的，但是这种加锁有弊端
       *
       */

            //已经存储的最大流水号的内容
            Map<String/**码段的主键**/, Map<String, CodeSerialValueDO>> maxSerialValueMap = new HashMap<>();
      if(dataCBOList.stream().anyMatch(cbo-> StringUtils.isNotBlank(cbo.getId()))
//         && StringUtils.isNotBlank(cbo.getAttributeValue(CODE_SEC_LENGTH_FIELD))
         ){
         //是历史数据导入
         //历史数据执行的时候，这个系统会很卡
         //主要是为了录入最大流水号和allcode
//         SessionInfo sessionInfo = VciBaseUtil.getCurrentUserSessionInfo();
         List<CodeAllCode> allCodeDOList = new ArrayList<>();
         Map<String/**流水依据**/, Map<String/**码段的主键**/,Double/**最大流水号**/>> maxSerialMap = new HashMap<>();
         dataCBOList.parallelStream().forEach(cbo->{
//            VciBaseUtil.setCurrentUserSessionInfo(sessionInfo);
            String code = cbo.getId();
            List<String> serialUnitList = new ArrayList<>();
            String[] secLengths = cbo.getData().get(CODE_SEC_LENGTH_FIELD).split("#");
            cbo.getData().remove(CODE_SEC_LENGTH_FIELD);//将此key除去
            cbo.getData().remove(IMPORT_ROW_INDEX);//将此key除去
            List<CodeBasicSecVO> secVOList = ruleVO.getSecVOList().stream().sorted(((o1, o2) -> o1.getOrderNum().compareTo(o2.getOrderNum()))).collect(Collectors.toList());
            Map<String/**码段的主键**/,String/**码段的值**/> serialValueMap = new HashMap<>();
            Map<String, CodeBasicSecVO> secVOMap = secVOList.stream().collect(Collectors.toMap(s -> s.getOid(), t -> t));
            for (int i = 0; i < secLengths.length; i++) {
               CodeBasicSecVO secVO = secVOList.get(i);
               String thisSecValue  = "";
               if(i == 0){
                  thisSecValue = code.contains("#")?code.substring(0,code.indexOf("#")):code;
               } else if(i == secLengths.length-1){
                  //最后
                  thisSecValue =  code.contains("#")?code.substring(code.lastIndexOf("#")):code;
               }else {
                  int start = 0;
                  for (int j = 0; j < i; j++) {
                     start += VciBaseUtil.getInt(secLengths[j]) + 1;
                  }
                  thisSecValue = code.substring(start,start+VciBaseUtil.getInt(secLengths[1]));
               }
               if(VciBaseUtil.getBoolean(secVO.getSerialDependFlag())){
                  serialUnitList.add(thisSecValue);
               }
               if(CodeSecTypeEnum.CODE_SERIAL_SEC.getValue().equalsIgnoreCase(secVO.getSecType())){
                  serialValueMap.put(secVO.getOid(),thisSecValue);
               }
            }
            String serialUnitString = serialUnitList.size() == 0 ? EMPTY_SERIAL_UNIT : serialUnitList.stream().collect(Collectors.joining(SERIAL_UNIT_SPACE));
            List<String> serialUnFileStringList = new ArrayList<>();
            if(!CollectionUtils.isEmpty(serialValueMap)){
               serialValueMap.forEach((secOid,secValue)->{
                  //要看是不是补位的
                  CodeBasicSecVO secVO = secVOMap.get(secOid);
                  Double serialDb = null;
                  if(OsCodeFillTypeEnum.NONE.getValue().equalsIgnoreCase(secVO.getCodeFillType())){
                     //不补码
                     //把所有不是数字的去掉，因为可能会是老数据，新规则
                     serialDb = VciBaseUtil.getDouble(killUnNumberChar(secValue));
                  }else {
                     //左右填充的，我们需要
                     serialDb = VciBaseUtil.getDouble(killUnNumberChar(killFillChar(secValue,secVO.getCodeFillSeparator(),
                        OsCodeFillTypeEnum.LEFT.getValue().equalsIgnoreCase(secVO.getCodeFillType()))));
                  }
                  Map<String, Double> thisUnitMaxMap = maxSerialMap.getOrDefault(serialUnitString, new HashMap<>());
                  thisUnitMaxMap.put(secOid,serialDb);
                  maxSerialMap.put(serialUnitString,thisUnitMaxMap);
                  serialUnFileStringList.add(String.valueOf(serialDb));
               });
            }
            CodeAllCode allCodeDO = new CodeAllCode();
            DefaultAttrAssimtUtil.addDefaultAttrAssimt(allCodeDO, MdmBtmTypeConstant.CODE_ALL_CODE);
            allCodeDO.setCodeClassifyOid(classifyFullInfoBO.getCurrentClassifyVO().getOid());
            allCodeDO.setCodeRuleOid(ruleVO.getOid());
            allCodeDO.setId(cbo.getId());
            allCodeDO.setCodeClassifyTemplateOid(templateVO.getOid());
            allCodeDO.setCreateCodeBtm(cbo.getBtmname());
            allCodeDO.setCreateCodeOid(cbo.getOid());
            allCodeDO.setSerialUnit(serialUnitString);
            allCodeDO.setUnFillSerial(serialUnFileStringList.stream().collect(Collectors.joining(SERIAL_VALUE_SPACE)));
            allCodeDO.setLcStatus(cbo.getLcStatus());
            allCodeDOList.add(allCodeDO);
         });
         //处理最大的流水号
         List<CodeSerialValue> addSerialValueList = new ArrayList<>();
         List<CodeSerialValue> editSerialValueList = new ArrayList<>();
         maxSerialMap.forEach((serialUnit,secOidMaxMap)->{
            secOidMaxMap.forEach((secOid,maxSerial)->{
//               Map<String, String> conditionMap = new HashMap<>();
//               conditionMap.put("codeRuleOid", ruleVO.getOid());
//               conditionMap.put("serialUnit", serialUnit);
//               //这个字段是为了解决多个流水的问题
//               conditionMap.put("codeSecOid", secOid);
               QueryWrapper<CodeSerialValue> queryWrapper = new QueryWrapper<>();
               queryWrapper.eq("codeRuleOid", ruleVO.getOid());
               queryWrapper.eq("serialUnit", serialUnit);
               queryWrapper.eq("codeSecOid", secOid);

            for (int i = 0; i < dataCBOList.size(); i++) {
                ClientBusinessObject cbo = dataCBOList.get(i);
                List<String> thisSecValueList = new LinkedList<>();
                for (int j = 0; j < secValueList.size(); j++) {
                    thisSecValueList.add(secValueList.get(j));
                }
                List<String> thisSerialUnitList = new LinkedList<>();
                //因为流水依据每次可能不一样，所以每次都拷贝一份
                for (int j = 0; j < serialUnitList.size(); j++) {
                    thisSerialUnitList.add(serialUnitList.get(j));
                }
                //先看看有没有属性的码段
                boolean attrSevIsSerialDepend = CollectionUtils.isEmpty(attrSecVOList) ? false : (attrSecVOList.stream().anyMatch(s -> VciBaseUtil.getBoolean(s.getSerialDependFlag())));
                switchAttrSecValue(attrSecVOList, cbo, thisSecValueList, attrSevIsSerialDepend, thisSerialUnitList);
               List<CodeSerialValue> serialValueDOS = serialValueMapper.selectList(queryWrapper);
//               .selectByCondition(conditionMap, new PageHelper(-1));
               if (!CollectionUtils.isEmpty(serialValueDOS)) {
                  CodeSerialValue serialValueDO = serialValueDOS.get(0);
                  if(VciBaseUtil.getDouble(serialValueDO.getMaxSerial())<maxSerial){
                     serialValueDO.setMaxSerial(String.valueOf(maxSerial));
                     editSerialValueList.add(serialValueDO);
                  }
               }else{
                  //没有
                  CodeSerialValue serialValueDO = new CodeSerialValue();
                  serialValueDO.setCodeRuleOid(ruleVO.getOid());
                  serialValueDO.setSerialUnit(serialUnit);
                  serialValueDO.setCodeSecOid(secOid);
                  serialValueDO.setMaxSerial(maxSerial.toString());
                  addSerialValueList.add(serialValueDO);
               }
            });
         });
         if(!CollectionUtils.isEmpty(addSerialValueList)){
//            batchCBO.copyFromOther(serialValueMapper.batchInsert(addSerialValueList));
            for (CodeSerialValue codeSerialValue : addSerialValueList) {
               serialValueMapper.insert(codeSerialValue);
            }
//            serialValueMapper.ba

                String serialUnitString = thisSerialUnitList.size() == 0 ? MdmEngineConstant.EMPTY_SERIAL_UNIT : thisSerialUnitList.stream().collect(Collectors.joining(MdmEngineConstant.SERIAL_UNIT_SPACE));
                switchSerialSecValue(serialSecVOList, attrSevIsSerialDepend, ruleVO, serialUnitString, maxSerialValueMap, thisSecValueList, lastMaxSerialValueMap, i == 0);
         }
         if(!CollectionUtils.isEmpty(editSerialValueList)){
            for (CodeSerialValue codeSerialValue : editSerialValueList) {
               serialValueMapper.updateById(codeSerialValue);
            }

                //组装编码的值
                cbo.setId(thisSecValueList.stream().collect(Collectors.joining()));
                codeList.add(cbo.getId());
                StringBuilder sb = new StringBuilder();
                //把码段里面都找一下流水号
                for (int j = 0; j < serialSecVOList.size(); j++) {
                    CodeBasicSecVO secVO = serialSecVOList.get(j);
                    Double serialValue = lastMaxSerialValueMap.getOrDefault(secVO.getOid(), new HashMap<>()).getOrDefault(serialUnitString, 0d);
                    if (serialValue != null) {
                        sb.append(String.valueOf(serialValue.longValue())).append(MdmEngineConstant.SERIAL_VALUE_SPACE);
                    }
                }
                //要存储最后的全部allcode
                wrapperAllCode(classifyFullInfoBO, ruleVO, cbo, templateVO, allCodeDOList, serialUnitString, sb.toString());
            }
            batchCBO.copyFromOther(allCodeMapper.batchInsert(allCodeDOList));
            saveSerialValue(batchCBO, ruleVO, lastMaxSerialValueMap, maxSerialValueMap);

            Map<String, String> statusMap = allCodeDOList.stream().collect(Collectors.toMap(s -> s.getOid(), s -> s.getLcStatus()));
            batchCBO.getCreateCbos().stream().filter(s -> StringUtils.equalsIgnoreCase("codeallcode",s.getBtmName())).forEach(s -> {
                s.setLcStatus(statusMap.get(s.getOid()));
                try {
                    s.setAttributeValue("lcstatus",statusMap.get(s.getOid()));
                } catch (VCIError e) {
                    e.printStackTrace();
                }
            });
//            batchCBO.copyFromOther(serialValueMapper.batchUpdate(editSerialValueList));
         }
         //处理allCode
         if(!CollectionUtils.isEmpty(allCodeDOList)){
            Map<String,List<CodeAllCode>> ruleGroup = allCodeDOList.stream().collect(Collectors.groupingBy(s -> s.getCodeRuleOid()));
            Map<String, CodeAllCode> codeDOMap = allCodeDOList.stream().collect(Collectors.toMap(s -> s.getCodeRuleOid() + "${SEP}" + s.getId(), t -> t));
            List<CodeAllCode> addCodeDOs = new ArrayList<>();
            List<CodeAllCode> editCodeDOs = new ArrayList<>();
            ruleGroup.forEach((ruleOid,allCodeDOS)->{
               VciBaseUtil.switchCollectionForOracleIn(allCodeDOS).stream().forEach(codeDOs->{
//                  Map<String,String> conditionMap = new HashMap<>();
//                  conditionMap.put("coderuleoid",ruleOid);
//                  conditionMap.put("id",QueryOptionConstant.IN + "(" + VciBaseUtil.toInSql(codeDOs.stream().map(s->s.getId()).collect(Collectors.toList()).toArray(new String[0])) + ")");
                  QueryWrapper<CodeAllCode> allCodeWrapper = new QueryWrapper<>();
                  allCodeWrapper.eq("coderuleoid",ruleOid);
                  allCodeWrapper.in("id", QueryOptionConstant.IN + "(" +
                     VciBaseUtil.toInSql(codeDOs.stream().map(s->s.getId()).collect(Collectors.toList()).toArray(new String[0])) + ")");
                  List<CodeAllCode> existCodes = codeAllCodeService.selectByWrapper(allCodeWrapper);


        }
        WebUtil.setPersistence(true);
        boService.persistenceBatch(batchCBO);
        return codeList;
    }
                  if(!CollectionUtils.isEmpty(existCodes)){
                     existCodes.stream().forEach(existCode->{
                        String rule_id = existCode.getCodeRuleOid() + "${SEP}" + existCode.getId();
                        if(codeDOMap.containsKey(rule_id)){
                           CodeAllCode newCodeDO = codeDOMap.get(rule_id);
                           existCode.setCreateCodeOid(newCodeDO.getOid());
                           existCode.setCreateCodeBtm(newCodeDO.getCreateCodeBtm());
                           existCode.setCodeClassifyTemplateOid(newCodeDO.getCodeClassifyTemplateOid());
                           existCode.setCodeClassifyOid(newCodeDO.getCodeClassifyOid());
                           existCode.setLcStatus(newCodeDO.getLcStatus());
                           editCodeDOs.add(existCode);
                        }
                     });
                  }
               });
            });
            if(!CollectionUtils.isEmpty(editCodeDOs)){
               Set<String> exitIds = editCodeDOs.stream().map(s -> s.getCodeRuleOid() + "${SEP}" + s.getId()).collect(Collectors.toSet());
               addCodeDOs = allCodeDOList.stream().filter(s -> !exitIds.contains(s.getCodeRuleOid() + "${SEP}" + s.getId())).collect(Collectors.toList());
            }else{
               addCodeDOs = allCodeDOList;
            }
            if(!CollectionUtils.isEmpty(editCodeDOs)){
//               batchCBO.copyFromOther(allCodeMapper.batchUpdate(editCodeDOs));
               codeAllCodeService.updateBatchById(editCodeDOs);
            }
            if(!CollectionUtils.isEmpty(addCodeDOs)){
               //batchCBO.copyFromOther(allCodeMapper.batchInsert(addCodeDOs));
               Map<String, String> statusMap = addCodeDOs.stream().collect(Collectors.toMap(s -> s.getOid(), s -> s.getLcStatus()));
               addCodeDOs.stream().filter(s -> StringUtils.equalsIgnoreCase("codeallcode",s.getBtmname())).forEach(s -> {
                  s.setLcStatus(statusMap.get(s.getOid()));
               });
               codeAllCodeService.saveBatch(addCodeDOs);
            }
            mdmEngineService.insertBatchByType(dataCBOList.get(0).getBtmname(),dataCBOList);
         }
//         WebUtil.setPersistence(true);
//         boService.persistenceBatch(batchCBO);
         return codeList;
      }else {
         List<CodeBasicSecVO> secVOList = ruleVO.getSecVOList().stream().sorted(((o1, o2) -> o1.getOrderNum().compareTo(o2.getOrderNum()))).collect(Collectors.toList());
         List<String> serialUnitList = new LinkedList<>();
         List<String> secValueList = new ArrayList<>();
         Map<String, String> secValueMap = secDTOList.stream().collect(Collectors.toMap(s -> s.getSecOid(), s -> s.getSecValue()));
         List<CodeBasicSecVO> serialSecVOList = new ArrayList<>();
         List<CodeBasicSecVO> attrSecVOList = new ArrayList<>();
         for (int i = 0; i < secVOList.size(); i++) {
            CodeBasicSecVO secVO = secVOList.get(i);
            switchSecValue(secVO, secValueMap, classifyFullInfoBO, serialSecVOList, attrSecVOList, serialUnitList, secValueList);
         }
         //处理属性码段和流水码段
         Map<String/**流水码段的主键**/, Map<String/**流水依据**/, Double>> lastMaxSerialValueMap = new HashMap<>();
         List<CodeAllCode> allCodeDOList = new ArrayList<>();

    /**
     * 去除补位字符
     * @param s 字符
     * @param fillString 补位字符
     * @param left 是否左补位
     * @return 替换后的值
     */
    private String killFillChar(String s, String fillString,boolean left){
        Integer index = 0;
        String value = s;
        if(left){
            for (int i = 0; i < s.length(); i++) {
                char c = s.charAt(i);
                if((new String(new char[]{c})).equalsIgnoreCase(fillString)){
                    index = i;
                }
            }
            if(index >0){
                value = value.substring(index);
            }
        }else{
            //从右往左找
            for (int i = s.length()-1; i >=0; i++) {
                char c = s.charAt(i);
                if((new String(new char[]{c})).equalsIgnoreCase(fillString)){
                    index = i;
                }
            }
            if(index >0){
                value = value.substring(0,index);
            }
        }
        return value;
         //已经存储的最大流水号的内容
         Map<String/**码段的主键**/, Map<String, CodeSerialValue>> maxSerialValueMap = new HashMap<>();

    }
         for (int i = 0; i < dataCBOList.size(); i++) {
            BaseModel cbo = dataCBOList.get(i);
            List<String> thisSecValueList = new LinkedList<>();
            for (int j = 0; j < secValueList.size(); j++) {
               thisSecValueList.add(secValueList.get(j));
            }
            List<String> thisSerialUnitList = new LinkedList<>();
            //因为流水依据每次可能不一样，所以每次都拷贝一份
            for (int j = 0; j < serialUnitList.size(); j++) {
               thisSerialUnitList.add(serialUnitList.get(j));
            }
            //先看看有没有属性的码段
            boolean attrSevIsSerialDepend = CollectionUtils.isEmpty(attrSecVOList) ? false : (attrSecVOList.stream().anyMatch(s -> VciBaseUtil.getBoolean(s.getSerialDependFlag())));
            switchAttrSecValue(attrSecVOList, cbo, thisSecValueList, attrSevIsSerialDepend, thisSerialUnitList);

    /**
     * 去掉不是数字的字符
     * @param s 字符
     * @return 替换后的值
     */
    private String killUnNumberChar(String s){
        Integer lastUnNumberIndex = 0;
        for (int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);
            if(!(new String(new char[]{c})).matches(RegExpConstant.NUMBER)){
                lastUnNumberIndex = i;
            }
        }
        String value = s;
        if(lastUnNumberIndex >0){
            value = value.substring(lastUnNumberIndex);
        }
        return value;
    }
            String serialUnitString = thisSerialUnitList.size() == 0 ? EMPTY_SERIAL_UNIT : thisSerialUnitList.stream().collect(Collectors.joining(SERIAL_UNIT_SPACE));
            switchSerialSecValue(serialSecVOList, attrSevIsSerialDepend, ruleVO, serialUnitString, maxSerialValueMap, thisSecValueList, lastMaxSerialValueMap, i == 0);

    /**
     * 回收码值
     *
     * @param btmId                 业务数据的业务类型
     * @param businessOidCollection 业务数据的主键
     * @return 受影响的数据内容
     */
    @Override
    public BatchCBO recycleCode(String btmId, Collection<String> businessOidCollection) {
        boolean oldPersistence =  WebUtil.isPersistence();
        WebUtil.setPersistence(false);
        BatchCBO batchCBO = new BatchCBO();
        VciBaseUtil.switchCollectionForOracleIn(businessOidCollection).stream().forEach(oids-> {
            Map<String, String> conditionMap = new HashMap<>();
            //编码要记录为回收的状态
            conditionMap.put("createcodeoid", QueryOptionConstant.IN + "(" + VciBaseUtil.toInSql(oids.toArray(new String[0])) + ")");
            conditionMap.put("createcodebtm", btmId);
            List<CodeAllCodeDO> allCodeDOS = allCodeMapper.selectByCondition(conditionMap, new PageHelper(-1));
            if (!CollectionUtils.isEmpty(allCodeDOS)) {
                allCodeDOS.stream().forEach(codeDO->{
                    codeDO.setLcStatus(CodeAllCodeLC.TASK_BACK.getValue());
                });
                batchCBO.copyFromOther(allCodeMapper.batchUpdate(allCodeDOS));
            }
        });
        WebUtil.setPersistence(oldPersistence);
        return batchCBO;
    }
            //组装编码的值
            cbo.setId(thisSecValueList.stream().collect(Collectors.joining()));
            codeList.add(cbo.getId());
            StringBuilder sb = new StringBuilder();
            //把码段里面都找一下流水号
            for (int j = 0; j < serialSecVOList.size(); j++) {
               CodeBasicSecVO secVO = serialSecVOList.get(j);
               Double serialValue = lastMaxSerialValueMap.getOrDefault(secVO.getOid(), new HashMap<>()).getOrDefault(serialUnitString, 0d);
               if (serialValue != null) {
                  sb.append(String.valueOf(serialValue.longValue())).append(SERIAL_VALUE_SPACE);
               }
            }
            //要存储最后的全部allcode
            wrapperAllCode(classifyFullInfoBO, ruleVO, cbo, templateVO, allCodeDOList, serialUnitString, sb.toString());
         }
         saveSerialValue( ruleVO, lastMaxSerialValueMap, maxSerialValueMap);

    /**
     * 转换码值的内容
     * @param secVO 码段的内容
     * @param secValueMap 码值的内容，key是码段的主键，value是码值
     * @param classifyFullInfoBO 分类的全部信息
     * @param serialSecVOList 流水码段
     * @param attrSecVOList 属性码段
     * @param serialUnitList 流水依据
     * @param secValueList 码值列表
     */
    private void switchSecValue(CodeBasicSecVO secVO,Map<String,String> secValueMap,
                                CodeClassifyFullInfoBO classifyFullInfoBO,List<CodeBasicSecVO> serialSecVOList,
                                List<CodeBasicSecVO> attrSecVOList, List<String> serialUnitList,
                                List<String> secValueList ){
        CodeSecTypeEnum secType = CodeSecTypeEnum.forValue(secVO.getSectype());
        String secValue = secValueMap.getOrDefault(secVO.getOid(), "");
        switch (secType) {
            case CODE_FIXED_SEC:
                //固定码段的，直接用码值,不论码值的长度是多少，因为可变长度和固定长度是控制在码段管理里面的码值定义的
                break;
            case CODE_DATE_SEC:
                //时间码段，需要将当前时间依据时间格式进行转换.
                //时间码段不涉及到是否补位
                secValue = VciDateUtil.date2Str(new Date(), secVO.getCodeDateFormatStr());
                break;
            case CODE_CLASSIFY_SEC:
                //分类码段的，也是从前端选择了码值即可，不论码值的长度是多少
                break;
            case CODE_LEVEL_SEC:
                //层级码段，需要从分类上获取相应的信息
                if (CodeLevelTypeEnum.MIN.getValue().equalsIgnoreCase(secVO.getCodeLevelType())) {
                    //最小层，因为我们只能在叶子节点上申请编码，所以这个就是当前分类的
                    if (CodeGetValueTypeEnum.CURRENT.getValue().equalsIgnoreCase(secVO.getCodeGetValueType()) || CollectionUtils.isEmpty(classifyFullInfoBO.getParentClassifyVOs())) {
                        //就是当前分类的
                        secValue = classifyFullInfoBO.getCurrentClassifyVO().getId();
                    } else {
                        //我们需要从顶层开始找到当前分类为止
                        secValue = classifyFullInfoBO.getParentClassifyVOs().stream().sorted(((o1, o2) -> o1.getDataLevel().compareTo(o2.getDataLevel()))).map(CodeClassifyVO::getId).collect(Collectors.joining()) + classifyFullInfoBO.getCurrentClassifyVO().getId();
                    }
                } else {
                    //指定层，我们需要通过上级的来获取
                    if (CollectionUtils.isEmpty(classifyFullInfoBO.getParentClassifyVOs())) {
                        //说明当前已经是最高的了
                        secValue = classifyFullInfoBO.getCurrentClassifyVO().getId();
                    } else {
                        //这个我们需要看看,层级是不是大于了最大层级的数
                        List<CodeClassifyVO> parentClassifyVOList = classifyFullInfoBO.getParentClassifyVOs().stream().sorted(((o1, o2) -> o1.getDataLevel().compareTo(o2.getDataLevel()))).collect(Collectors.toList());
                        if (secVO.getCodeLevelValue() > (parentClassifyVOList.size() + 1)) {
                            //指定的层级比当前的层级还大了，所以只能获取当前层级了
                            if (CodeGetValueTypeEnum.CURRENT.getValue().equalsIgnoreCase(secVO.getCodeGetValueType())) {
                                secValue = classifyFullInfoBO.getCurrentClassifyVO().getId();
                            } else {
                                secValue = parentClassifyVOList.stream().map(CodeClassifyVO::getId).collect(Collectors.joining()) + classifyFullInfoBO.getCurrentClassifyVO().getId();
                            }
                        } else {
                            //我们获取其中指定层的内容
                            if (CodeGetValueTypeEnum.CURRENT.getValue().equalsIgnoreCase(secVO.getCodeGetValueType())) {
                                CodeClassifyVO classifyVO = parentClassifyVOList.stream().filter(s -> s.getDataLevel().intValue() == secVO.getCodeLevelValue().intValue()).findFirst().orElseGet(() -> null);
                                if (classifyVO != null) {
                                    secValue = classifyVO.getId();
                                }
                            } else {
                                //小于等于的全部拿出来
                                secValue = parentClassifyVOList.stream().filter(s -> s.getDataLevel().intValue() <= secVO.getCodeLevelValue().intValue()).sorted(((o1, o2) -> o1.getDataLevel().compareTo(o2.getDataLevel()))).map(CodeClassifyVO::getId).collect(Collectors.joining());
                            }
                        }
                    }
                }
                //看看长度是否需要截断
                if (!CodeCutTypeEnum.NONE.getValue().equalsIgnoreCase(secVO.getValueCutType()) &&
                        secVO.getValueCutLength() != null && secVO.getValueCutLength() > 0 && secValue.length() > secVO.getValueCutLength()) {
                    if (CodeCutTypeEnum.RIGHT.getValue().equalsIgnoreCase(secVO.getValueCutType())) {
                        //左截取是从左边剪掉，右截取是从右边剪掉--保留左边
                        secValue = secValue.substring(0, secVO.getValueCutLength());
                    } else {
                        secValue = secValue.substring(secValue.length() - secVO.getValueCutLength());
                    }
                }
                break;
            case CODE_REFER_SEC:
                //引用的在页面上已经选择了，所以直接使用前端上传递的值
                //引用就是参照，可能是其他的分类（业务类型）下的数据，所以只在页面上选择
                break;
            case CODE_ATTR_SEC:
                //属性与引用的区别是，属性是当前数据里的属性，而引用可能是引用其他的分类的（业务类型）
                //因为可能是批量的数据的操作，所以我们这里不能直接处理属性，需要后边一边处理
                secValue = "${attr_" + secVO.getOid() + "}";
                attrSecVOList.add(secVO);
                break;
            case CODE_VARIABLE_SEC:
                //可变码段，是在页面上输入内容
                if (secValue.length() > VciBaseUtil.getInt(secVO.getCodeSecLength())) {
                    throw new VciBaseException("【{0}】这个码段是可变码段，但是现在输入的码值的长度({1})超过了规定的长度{2}", new String[]{secVO.getName(), String.valueOf(secValue.length()), secVO.getCodeSecLength()});
                }
                OsCodeFillTypeEnum fillTypeEnum = OsCodeFillTypeEnum.forValue(secVO.getCodeFillType());
                secValue = fillString(VciBaseUtil.getInt(secVO.getCodeSecLength()), fillTypeEnum, secValue, secVO.getCodeFillSeparator());
                break;
            case CODE_SERIAL_SEC:
                //流水码段
                serialSecVOList.add(secVO);
                secValue = "${" + secVO.getOid() + "}";
            default:
                break;
        }
        if (VciBaseUtil.getBoolean(secVO.getSerialDependFlag())) {
            serialUnitList.add(secValue);
        }
        secValueList.add(secValue);
    }
         Map<String, String> statusMap = allCodeDOList.stream().collect(Collectors.toMap(s -> s.getOid(), s -> s.getLcStatus()));
         allCodeDOList.stream().filter(s -> StringUtils.equalsIgnoreCase("codeallcode",s.getBtmname())).forEach(s -> {
            s.setLcStatus(statusMap.get(s.getOid()));
         });


    /**
     * 补位
     * @param totalLength 总长度
     * @param fillTypeEnum 补位方式
     * @param text 当前的内容
     * @param fillChar 补位的字符
     * @return 不填充位置和长度已经达到/超过的时候不会填充
     */
    private String fillString(int totalLength,OsCodeFillTypeEnum fillTypeEnum,String text,String fillChar){
        if(text.length() >= totalLength || OsCodeFillTypeEnum.NONE.equals(fillTypeEnum)){
            //不用补位了
            return  text;
        }
        int balance = totalLength - text.length();
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < balance; i++) {
            sb.append(fillChar);
        }
        if(OsCodeFillTypeEnum.LEFT.equals(fillTypeEnum)) {
            text = sb.toString() + text;
        }else {
            text = text + sb.toString();
        }
        return  text;
    }
         allCodeDOList.stream().forEach(
            allCode -> {DefaultAttrAssimtUtil.addDefaultAttrAssimt(allCode,"codeallcode");allCode.setLctid("codeAllCodeLC");}
         );

    /**
     * 转换属性码段的值
     * @param attrSecVOList 属性码段的显示对象
     * @param cbo 业务数据，用于获取码段的值
     * @param thisSecValueList 码值的列表
     * @param attrSevIsSerialDepend 是否有作为流水依据
     * @param serialUnitList 流水依据的内容
     */
    private void switchAttrSecValue(List<CodeBasicSecVO> attrSecVOList,ClientBusinessObject cbo,
                                    List<String> thisSecValueList,boolean attrSevIsSerialDepend,
         codeAllCodeService.saveBatch(allCodeDOList);
//         iCodeWupinService.saveBatch(dataCBOList);
         mdmEngineService.insertBatchByType(dataCBOList.get(0).getBtmname(),dataCBOList);

//         batchCBO.getCreateCbos().stream().filter(s -> StringUtils.equalsIgnoreCase("codeallcode",s.getBtmName())).forEach(s -> {
//            s.setLcStatus(statusMap.get(s.getOid()));
//            try {
//               s.setAttributeValue("lcstatus",statusMap.get(s.getOid()));
//            } catch (VCIError e) {
//               e.printStackTrace();
//            }
//         });
      }
//      WebUtil.setPersistence(true);
//      boService.persistenceBatch(batchCBO);
      return codeList;
   }
   /**
    * 转换属性码段的值
    * @param attrSecVOList 属性码段的显示对象
    * @param cbo 业务数据，用于获取码段的值
    * @param thisSecValueList 码值的列表
    * @param attrSevIsSerialDepend 是否有作为流水依据
    * @param serialUnitList 流水依据的内容
    *                       还需要后续的一个移植将会涉及到其他的服务
    */
   private void switchAttrSecValue(List<CodeBasicSecVO> attrSecVOList, BaseModel cbo,
                                    List<String> thisSecValueList, boolean attrSevIsSerialDepend,
                                    List<String> serialUnitList){
        if (!CollectionUtils.isEmpty(attrSecVOList)) {
            attrSecVOList.stream().forEach(attrSevVO -> {
                String value = "";
                if (StringUtils.isNotBlank(attrSevVO.getGetValueClass())) {
                    //使用组合规则来处理的
                    value = getValueByFormulaForCBO(cbo, attrSevVO.getGetValueClass());
                } else {
                    value = cbo.getAttributeValue(attrSevVO.getReferAttributeId());
                }
                if (value == null) {
                    value = "";
                }
                //替换secValueList里面的内容
                for (int j = 0; j < thisSecValueList.size(); j++) {
                    String secValue = thisSecValueList.get(j);
                    if (secValue.equalsIgnoreCase("${attr_" + attrSevVO.getOid() + "}")) {
                        thisSecValueList.set(j, value);
                    }
                }
                if (attrSevIsSerialDepend) {
                    //是流水依赖的话，需要去替换一下
                    for (int j = 0; j < serialUnitList.size(); j++) {
                        String secValue = serialUnitList.get(j);
                        if (secValue.equalsIgnoreCase("${attr_" + attrSevVO.getOid() + "}")) {
                            serialUnitList.set(j, value);
                        }
                    }
                }
            });
        }
    }
      if (!CollectionUtils.isEmpty(attrSecVOList)) {
         attrSecVOList.stream().forEach(attrSevVO -> {
            String value = "";
            if (StringUtils.isNotBlank(attrSevVO.getGetValueClass())) {
               //使用组合规则来处理的
               value = getValueByFormulaForCBO(cbo, attrSevVO.getGetValueClass());
            } else {
               value = cbo.getData().get(attrSevVO.getReferAttributeId());
            }
            if (value == null) {
               value = "";
            }
            //替换secValueList里面的内容
            for (int j = 0; j < thisSecValueList.size(); j++) {
               String secValue = thisSecValueList.get(j);
               if (secValue.equalsIgnoreCase("${attr_" + attrSevVO.getOid() + "}")) {
                  thisSecValueList.set(j, value);
               }
            }
            if (attrSevIsSerialDepend) {
               //是流水依赖的话，需要去替换一下
               for (int j = 0; j < serialUnitList.size(); j++) {
                  String secValue = serialUnitList.get(j);
                  if (secValue.equalsIgnoreCase("${attr_" + attrSevVO.getOid() + "}")) {
                     serialUnitList.set(j, value);
                  }
               }
            }
         });
      }
   }

    /**
     * 使用CBO处理组合规则的内容
     * @param cbo 数据的内容
     * @param rule 规则的内容
     * @return 转换后的
     */
    private String getValueByFormulaForCBO(ClientBusinessObject cbo,String rule){
        Map<String,String> dataMap = new HashMap<>();
        WebUtil.copyValueToMapFromCbos(cbo,dataMap);
        return formulaService.getValueByFormula(dataMap,rule);
    }

    /**
     * 转换流水码段的值
     * @param serialSecVOList 流水码段
     * @param attrSevIsSerialDepend 是否有属性码段参与流水
     * @param ruleVO 规则的内容
     * @param serialUnitString 流水依据
     * @param maxSerialValueMap 最大的流水号
     * @param thisSecValueList 本次的码值
     * @param lastMaxSerialValueMap 封装后
     * @param firstData 是否为第一条数据
     */
    private void switchSerialSecValue(List<CodeBasicSecVO> serialSecVOList,boolean attrSevIsSerialDepend,
                                      CodeRuleVO ruleVO,String serialUnitString,
                                      Map<String/**码段的主键**/,Map<String/**流水依据**/,CodeSerialValueDO>> maxSerialValueMap,List<String> thisSecValueList,
                                      Map<String/**码段的主键**/,Map<String/**流水依据**/, Double>> lastMaxSerialValueMap,boolean firstData){
        if (!CollectionUtils.isEmpty(serialSecVOList)) {
            for (int j = 0; j < serialSecVOList.size(); j++) {
                CodeBasicSecVO secVO = serialSecVOList.get(j);
                if (attrSevIsSerialDepend || firstData) {
                    //如果属性码段也是依赖，则每次都要查询，如果属性码段不是依赖，则只查询一次
                    Map<String, String> conditionMap = new HashMap<>();
                    conditionMap.put("codeRuleOid", ruleVO.getOid());
                    conditionMap.put("serialUnit", serialUnitString);
                    //这个字段是为了解决多个流水的问题
                    conditionMap.put("codeSecOid", secVO.getOid());
                    List<CodeSerialValueDO> serialValueDOS = serialValueMapper.selectByCondition(conditionMap, new PageHelper(-1));
                    if (!CollectionUtils.isEmpty(serialValueDOS)) {
                        Map<String, CodeSerialValueDO> unitSerialMap = maxSerialValueMap.getOrDefault(secVO.getOid(), new HashMap<>());
                        CodeSerialValueDO serialValueDO = serialValueDOS.get(0);
                        unitSerialMap.put(serialValueDO.getSerialUnit(),serialValueDO);
                        maxSerialValueMap.put(secVO.getOid(), unitSerialMap);
                    }
                }
                Double startValue = null;
                if(maxSerialValueMap.containsKey(secVO.getOid()) && maxSerialValueMap.get(secVO.getOid()).containsKey(serialUnitString)){
                    startValue = VciBaseUtil.getDouble(maxSerialValueMap.get(secVO.getOid()).get(serialUnitString).getMaxSerial());
                }
                if(lastMaxSerialValueMap.containsKey(secVO.getOid()) && lastMaxSerialValueMap.get(secVO.getOid()).containsKey(serialUnitString)){
                    //说明多个申请，之前已经加了流水号了
                    startValue = lastMaxSerialValueMap.get(secVO.getOid()).get(serialUnitString);
                }
                Double thisSerialValue = 0d;
                if (startValue == null) {
                    //第一个编码
                    thisSerialValue = VciBaseUtil.getDouble(secVO.getSerialStart());
                } else {
                    //流水号肯定是数字
                    thisSerialValue = startValue + (j + 1) * secVO.getSerialStep();
                }
                //要看是否超过最大的流水值
                if (thisSerialValue >= secVO.getCodeFillLimit()) {
                    throw new VciBaseException("流水号已经超过允许的最大流水值{0}",new String[]{secVO.getCodeFillLimit().toString()});
                }
                //要看补位的内容
                Integer fillLength = VciBaseUtil.getInt(secVO.getCodeFillLength());
                if (fillLength == 0 || fillLength > VciBaseUtil.getInt(secVO.getCodeSecLength())) {
                    //防止在添加的地方没有控制正确
                    fillLength = VciBaseUtil.getInt(secVO.getCodeSecLength());
                }
                String serialString = String.valueOf(thisSerialValue.longValue());
                serialString = fillString(fillLength, OsCodeFillTypeEnum.forValue(secVO.getCodeFillType()), serialString, secVO.getCodeFillSeparator());
                for (int z = 0; z < thisSecValueList.size(); z++) {
                    String secValue = thisSecValueList.get(z);
                    if (secValue.equalsIgnoreCase("${" + secVO.getOid() + "}")) {
                        thisSecValueList.set(z, serialString);
                    }
                }
                Map<String, Double> unitSerialMap = lastMaxSerialValueMap.getOrDefault(secVO.getOid(), new HashMap<>());
                unitSerialMap.put(serialUnitString, thisSerialValue);
                lastMaxSerialValueMap.put(secVO.getOid(),unitSerialMap);
            }
        }
    }
   /**
    * 转换流水码段的值
    * @param serialSecVOList 流水码段
    * @param attrSevIsSerialDepend 是否有属性码段参与流水
    * @param ruleVO 规则的内容
    * @param serialUnitString 流水依据
    * @param maxSerialValueMap 最大的流水号
    * @param thisSecValueList 本次的码值
    * @param lastMaxSerialValueMap 封装后
    * @param firstData 是否为第一条数据
    */
   private void switchSerialSecValue(List<CodeBasicSecVO> serialSecVOList,boolean attrSevIsSerialDepend,
                             CodeRuleVO ruleVO,String serialUnitString,
                             Map<String/**码段的主键**/,Map<String/**流水依据**/,CodeSerialValue>> maxSerialValueMap,List<String> thisSecValueList,
                             Map<String/**码段的主键**/,Map<String/**流水依据**/, Double>> lastMaxSerialValueMap,boolean firstData){
      if (!CollectionUtils.isEmpty(serialSecVOList)) {
         for (int j = 0; j < serialSecVOList.size(); j++) {
            CodeBasicSecVO secVO = serialSecVOList.get(j);
            if (attrSevIsSerialDepend || firstData) {
               //如果属性码段也是依赖，则每次都要查询，如果属性码段不是依赖，则只查询一次
//               Map<String, String> conditionMap = new HashMap<>();
//               conditionMap.put("codeRuleOid", ruleVO.getOid());
//               conditionMap.put("serialUnit", serialUnitString);
//               //这个字段是为了解决多个流水的问题
//               conditionMap.put("codeSecOid", secVO.getOid());
               QueryWrapper<CodeSerialValue> codeSerialWrapper = new QueryWrapper<>();
               codeSerialWrapper.eq("codeRuleOid", ruleVO.getOid());
               codeSerialWrapper.eq("serialUnit", serialUnitString);
               codeSerialWrapper.eq("codeSecOid", secVO.getOid());
               List<CodeSerialValue> serialValueDOS = serialValueMapper.selectList(codeSerialWrapper);
               if (!CollectionUtils.isEmpty(serialValueDOS)) {
                  Map<String, CodeSerialValue> unitSerialMap = maxSerialValueMap.getOrDefault(secVO.getOid(), new HashMap<>());
                  CodeSerialValue serialValueDO = serialValueDOS.get(0);
                  unitSerialMap.put(serialValueDO.getSerialUnit(),serialValueDO);
                  maxSerialValueMap.put(secVO.getOid(), unitSerialMap);
               }
            }
            Double startValue = null;
            if(maxSerialValueMap.containsKey(secVO.getOid()) && maxSerialValueMap.get(secVO.getOid()).containsKey(serialUnitString)){
               startValue = VciBaseUtil.getDouble(maxSerialValueMap.get(secVO.getOid()).get(serialUnitString).getMaxSerial());
            }
            if(lastMaxSerialValueMap.containsKey(secVO.getOid()) && lastMaxSerialValueMap.get(secVO.getOid()).containsKey(serialUnitString)){
               //说明多个申请，之前已经加了流水号了
               startValue = lastMaxSerialValueMap.get(secVO.getOid()).get(serialUnitString);
            }
            Double thisSerialValue = 0d;
            if (startValue == null) {
               //第一个编码
               thisSerialValue = VciBaseUtil.getDouble(secVO.getSerialStart());
            } else {
               //流水号肯定是数字
               thisSerialValue = startValue + (j + 1) * secVO.getSerialStep();
            }
            //要看是否超过最大的流水值
            if (thisSerialValue >= secVO.getCodeFillLimit()) {
               throw new VciBaseException("流水号已经超过允许的最大流水值{0}",new String[]{secVO.getCodeFillLimit().toString()});
            }
            //要看补位的内容
            Integer fillLength = VciBaseUtil.getInt(secVO.getCodeFillLength());
            if (fillLength == 0 || fillLength > VciBaseUtil.getInt(secVO.getCodeSecLength())) {
               //防止在添加的地方没有控制正确
               fillLength = VciBaseUtil.getInt(secVO.getCodeSecLength());
            }
            String serialString = String.valueOf(thisSerialValue.longValue());
            serialString = fillString(fillLength, OsCodeFillTypeEnum.forValue(secVO.getCodeFillType()), serialString, secVO.getCodeFillSeparator());
            for (int z = 0; z < thisSecValueList.size(); z++) {
               String secValue = thisSecValueList.get(z);
               if (secValue.equalsIgnoreCase("${" + secVO.getOid() + "}")) {
                  thisSecValueList.set(z, serialString);
               }
            }
            Map<String, Double> unitSerialMap = lastMaxSerialValueMap.getOrDefault(secVO.getOid(), new HashMap<>());
            unitSerialMap.put(serialUnitString, thisSerialValue);
            lastMaxSerialValueMap.put(secVO.getOid(),unitSerialMap);
         }
      }
   }

    /**
     * 封装存储码值的对象
     * @param classifyFullInfoBO 分类全部的信息
     * @param ruleVO 规则的内容
     * @param cbo 业务数据
     * @param templateVO 模板的信息
     * @param allCodeDOList 所有的码值的对象列表
     */
    private void wrapperAllCode(CodeClassifyFullInfoBO classifyFullInfoBO,CodeRuleVO ruleVO,
                                ClientBusinessObject cbo,CodeClassifyTemplateVO templateVO,
                                List<CodeAllCodeDO> allCodeDOList,String serialUnitString,String serialValueString){
        CodeAllCodeDO allCodeDO = new CodeAllCodeDO();
        allCodeDO.setCodeClassifyOid(classifyFullInfoBO.getCurrentClassifyVO().getOid());
        allCodeDO.setCodeRuleOid(ruleVO.getOid());
        allCodeDO.setId(cbo.getId());
        allCodeDO.setCodeClassifyTemplateOid(templateVO.getOid());
        allCodeDO.setCreateCodeBtm(cbo.getBtmName());
        allCodeDO.setCreateCodeOid(cbo.getOid());
        allCodeDO.setSerialUnit(serialUnitString);
        allCodeDO.setUnFillSerial(serialValueString);
        allCodeDO.setLcStatus(cbo.getLcStatus());
        allCodeDOList.add(allCodeDO);
    }
   /**
    * 转换码值的内容
    * @param secVO 码段的内容
    * @param secValueMap 码值的内容，key是码段的主键，value是码值
    * @param classifyFullInfoBO 分类的全部信息
    * @param serialSecVOList 流水码段
    * @param attrSecVOList 属性码段
    * @param serialUnitList 流水依据
    * @param secValueList 码值列表
    */
   private void switchSecValue(CodeBasicSecVO secVO,Map<String,String> secValueMap,
                        CodeClassifyFullInfoBO classifyFullInfoBO,List<CodeBasicSecVO> serialSecVOList,
                        List<CodeBasicSecVO> attrSecVOList, List<String> serialUnitList,
                        List<String> secValueList ){
      CodeSecTypeEnum secType = CodeSecTypeEnum.forValue(secVO.getSecType());
      String secValue = secValueMap.getOrDefault(secVO.getOid(), "");
      switch (secType) {
         case CODE_FIXED_SEC:
            //固定码段的，直接用码值,不论码值的长度是多少，因为可变长度和固定长度是控制在码段管理里面的码值定义的
            break;
         case CODE_DATE_SEC:
            //时间码段，需要将当前时间依据时间格式进行转换.
            //时间码段不涉及到是否补位
            secValue = VciDateUtil.date2Str(new Date(), secVO.getCodeDateFormatStr());
            break;
         case CODE_CLASSIFY_SEC:
            //分类码段的，也是从前端选择了码值即可，不论码值的长度是多少
            break;
         case CODE_LEVEL_SEC:
            //层级码段，需要从分类上获取相应的信息
            if (CodeLevelTypeEnum.MIN.getValue().equalsIgnoreCase(secVO.getCodeLevelType())) {
               //最小层，因为我们只能在叶子节点上申请编码，所以这个就是当前分类的
               if (CodeGetValueTypeEnum.CURRENT.getValue().equalsIgnoreCase(secVO.getCodeGetValueType()) || CollectionUtils.isEmpty(classifyFullInfoBO.getParentClassifyVOs())) {
                  //就是当前分类的
                  secValue = classifyFullInfoBO.getCurrentClassifyVO().getId();
               } else {
                  //我们需要从顶层开始找到当前分类为止
                  secValue = classifyFullInfoBO.getParentClassifyVOs().stream().sorted(((o1, o2) -> o1.getDataLevel().compareTo(o2.getDataLevel()))).map(CodeClassifyVO::getId).collect(Collectors.joining()) + classifyFullInfoBO.getCurrentClassifyVO().getId();
               }
            } else {
               //指定层，我们需要通过上级的来获取
               if (CollectionUtils.isEmpty(classifyFullInfoBO.getParentClassifyVOs())) {
                  //说明当前已经是最高的了
                  secValue = classifyFullInfoBO.getCurrentClassifyVO().getId();
               } else {
                  //这个我们需要看看,层级是不是大于了最大层级的数
                  List<CodeClassifyVO> parentClassifyVOList = classifyFullInfoBO.getParentClassifyVOs().stream().sorted(((o1, o2) -> o1.getDataLevel().compareTo(o2.getDataLevel()))).collect(Collectors.toList());
                  if (secVO.getCodeLevelValue() > (parentClassifyVOList.size() + 1)) {
                     //指定的层级比当前的层级还大了，所以只能获取当前层级了
                     if (CodeGetValueTypeEnum.CURRENT.getValue().equalsIgnoreCase(secVO.getCodeGetValueType())) {
                        secValue = classifyFullInfoBO.getCurrentClassifyVO().getId();
                     } else {
                        secValue = parentClassifyVOList.stream().map(CodeClassifyVO::getId).collect(Collectors.joining()) + classifyFullInfoBO.getCurrentClassifyVO().getId();
                     }
                  } else {
                     //我们获取其中指定层的内容
                     if (CodeGetValueTypeEnum.CURRENT.getValue().equalsIgnoreCase(secVO.getCodeGetValueType())) {
                        CodeClassifyVO classifyVO = parentClassifyVOList.stream().filter(s -> s.getDataLevel().intValue() == secVO.getCodeLevelValue().intValue()).findFirst().orElseGet(() -> null);
                        if (classifyVO != null) {
                           secValue = classifyVO.getId();
                        }
                     } else {
                        //小于等于的全部拿出来
                        secValue = parentClassifyVOList.stream().filter(s -> s.getDataLevel().intValue() <= secVO.getCodeLevelValue().intValue()).sorted(((o1, o2) -> o1.getDataLevel().compareTo(o2.getDataLevel()))).map(CodeClassifyVO::getId).collect(Collectors.joining());
                     }
                  }
               }
            }
            //看看长度是否需要截断
            if (!CodeCutTypeEnum.NONE.getValue().equalsIgnoreCase(secVO.getValueCutType()) &&
               secVO.getValueCutLength() != null && secVO.getValueCutLength() > 0 && secValue.length() > secVO.getValueCutLength()) {
               if (CodeCutTypeEnum.RIGHT.getValue().equalsIgnoreCase(secVO.getValueCutType())) {
                  //左截取是从左边剪掉，右截取是从右边剪掉--保留左边
                  secValue = secValue.substring(0, secVO.getValueCutLength());
               } else {
                  secValue = secValue.substring(secValue.length() - secVO.getValueCutLength());
               }
            }
            break;
         case CODE_REFER_SEC:
            //引用的在页面上已经选择了，所以直接使用前端上传递的值
            //引用就是参照，可能是其他的分类（业务类型）下的数据，所以只在页面上选择
            break;
         case CODE_ATTR_SEC:
            //属性与引用的区别是，属性是当前数据里的属性，而引用可能是引用其他的分类的（业务类型）
            //因为可能是批量的数据的操作，所以我们这里不能直接处理属性，需要后边一边处理
            secValue = "${attr_" + secVO.getOid() + "}";
            attrSecVOList.add(secVO);
            break;
         case CODE_VARIABLE_SEC:
            //可变码段，是在页面上输入内容
            if (secValue.length() > VciBaseUtil.getInt(secVO.getCodeSecLength())) {
               throw new VciBaseException("【{0}】这个码段是可变码段，但是现在输入的码值的长度({1})超过了规定的长度{2}", new String[]{secVO.getName(), String.valueOf(secValue.length()), secVO.getCodeSecLength()});
            }
            OsCodeFillTypeEnum fillTypeEnum = OsCodeFillTypeEnum.forValue(secVO.getCodeFillType());
            secValue = fillString(VciBaseUtil.getInt(secVO.getCodeSecLength()), fillTypeEnum, secValue, secVO.getCodeFillSeparator());
            break;
         case CODE_SERIAL_SEC:
            //流水码段
            serialSecVOList.add(secVO);
            secValue = "${" + secVO.getOid() + "}";
         default:
            break;
      }
      if (VciBaseUtil.getBoolean(secVO.getSerialDependFlag())) {
         serialUnitList.add(secValue);
      }
      secValueList.add(secValue);
   }

    /**
     * 保存流水的信息
     * @param batchCBO 数据存储容器
     * @param ruleVO 规则的显示对象
     * @param lastMaxSerialValueMap 最大的流水值映射
     * @param maxSerialValueMap 依据存储的最大流水的内容
     */
    private void saveSerialValue(BatchCBO batchCBO,CodeRuleVO ruleVO,
                                 Map<String/**码段的主键**/,Map<String, Double>> lastMaxSerialValueMap,
                                 Map<String/**码段的主键**/,Map<String, CodeSerialValueDO>> maxSerialValueMap){
        List<CodeSerialValueDO> editSerialValueDOList = new ArrayList<>();
        List<CodeSerialValueDO> addSerialValueDOList = new ArrayList<>();
        //存储最大流水号
        lastMaxSerialValueMap.forEach((secOid,maxSerialMap)->{
            maxSerialMap.forEach((unit,maxSerial)->{
                CodeSerialValueDO serialValueDO = null;
                if(maxSerialValueMap.containsKey(secOid) && maxSerialValueMap.get(secOid).containsKey(unit)){
                    //说明有
                    serialValueDO = maxSerialValueMap.get(secOid).get(unit);
                    serialValueDO.setMaxSerial(maxSerial.toString());
                    editSerialValueDOList.add(serialValueDO);
                }else{
                    serialValueDO = new CodeSerialValueDO();
                    serialValueDO.setCodeRuleOid(ruleVO.getOid());
                    serialValueDO.setSerialUnit(unit);
                    serialValueDO.setCodeSecOid(secOid);
                    serialValueDO.setMaxSerial(maxSerial.toString());
                    addSerialValueDOList.add(serialValueDO);
                }
            });
        });
        if(!CollectionUtils.isEmpty(editSerialValueDOList)){
            batchCBO.copyFromOther(serialValueMapper.batchUpdate(editSerialValueDOList));
        }
        if(!CollectionUtils.isEmpty(addSerialValueDOList)){
            batchCBO.copyFromOther(serialValueMapper.batchInsert(addSerialValueDOList));
        }
    }
   /**
    * 补位
    * @param totalLength 总长度
    * @param fillTypeEnum 补位方式
    * @param text 当前的内容
    * @param fillChar 补位的字符
    * @return 不填充位置和长度已经达到/超过的时候不会填充
    */
   private String fillString(int totalLength,OsCodeFillTypeEnum fillTypeEnum,String text,String fillChar){
      if(text.length() >= totalLength || OsCodeFillTypeEnum.NONE.equals(fillTypeEnum)){
         //不用补位了
         return  text;
      }
      int balance = totalLength - text.length();
      StringBuilder sb = new StringBuilder();
      for (int i = 0; i < balance; i++) {
         sb.append(fillChar);
      }
      if(OsCodeFillTypeEnum.LEFT.equals(fillTypeEnum)) {
         text = sb.toString() + text;
      }else {
         text = text + sb.toString();
      }
      return  text;
   }

   /**
    * 封装存储码值的对象
    * @param classifyFullInfoBO 分类全部的信息
    * @param ruleVO 规则的内容
    * @param cbo 业务数据
    * @param templateVO 模板的信息
    * @param allCodeDOList 所有的码值的对象列表
    */
   private void wrapperAllCode(CodeClassifyFullInfoBO classifyFullInfoBO, CodeRuleVO ruleVO,
                                BaseModel cbo, CodeClassifyTemplateVO templateVO,
                                List<CodeAllCode> allCodeDOList, String serialUnitString, String serialValueString){
      CodeAllCode allCodeDO = new CodeAllCode();
      allCodeDO.setCodeClassifyOid(classifyFullInfoBO.getCurrentClassifyVO().getOid());
      allCodeDO.setCodeRuleOid(ruleVO.getOid());
      allCodeDO.setId(cbo.getId());
      allCodeDO.setCodeClassifyTemplateOid(templateVO.getOid());
      allCodeDO.setCreateCodeBtm(cbo.getBtmname());
      allCodeDO.setCreateCodeOid(cbo.getOid());
      allCodeDO.setSerialUnit(serialUnitString);
      allCodeDO.setUnFillSerial(serialValueString);
      allCodeDO.setLcStatus(cbo.getLcStatus());
      allCodeDOList.add(allCodeDO);
   }




   /**
    * 保存流水的信息
    * @param ruleVO 规则的显示对象
    * @param lastMaxSerialValueMap 最大的流水值映射
    * @param maxSerialValueMap 依据存储的最大流水的内容
    */
   private void saveSerialValue(CodeRuleVO ruleVO,
                         Map<String/**码段的主键**/,Map<String, Double>> lastMaxSerialValueMap,
                         Map<String/**码段的主键**/,Map<String, CodeSerialValue>> maxSerialValueMap){
      List<CodeSerialValue> editSerialValueDOList = new ArrayList<>();
      List<CodeSerialValue> addSerialValueDOList = new ArrayList<>();
      //存储最大流水号
      lastMaxSerialValueMap.forEach((secOid,maxSerialMap)->{
         maxSerialMap.forEach((unit,maxSerial)->{
            CodeSerialValue serialValueDO = null;
            if(maxSerialValueMap.containsKey(secOid) && maxSerialValueMap.get(secOid).containsKey(unit)){
               //说明有
               serialValueDO = maxSerialValueMap.get(secOid).get(unit);
               serialValueDO.setMaxSerial(maxSerial.toString());
               editSerialValueDOList.add(serialValueDO);
            }else{
               serialValueDO = new CodeSerialValue();
               serialValueDO.setCodeRuleOid(ruleVO.getOid());
               serialValueDO.setSerialUnit(unit);
               serialValueDO.setCodeSecOid(secOid);
               serialValueDO.setMaxSerial(maxSerial.toString());
               addSerialValueDOList.add(serialValueDO);
            }
         });
      });
      if(!CollectionUtils.isEmpty(editSerialValueDOList)){
//         batchCBO.copyFromOther(serialValueMapper.batchUpdate(editSerialValueDOList));
         for (CodeSerialValue codeSerialValue : editSerialValueDOList) {
            serialValueMapper.updateById(codeSerialValue);
         }
      }
      if(!CollectionUtils.isEmpty(addSerialValueDOList)){
         for (CodeSerialValue codeSerialValue : addSerialValueDOList) {
            serialValueMapper.insert(codeSerialValue);
         }
//         batchCBO.copyFromOther(serialValueMapper.batchInsert(addSerialValueDOList));
      }
   }

   /**
    * 去掉不是数字的字符
    * @param s 字符
    * @return 替换后的值
    */
   private String killUnNumberChar(String s){
      Integer lastUnNumberIndex = 0;
      for (int i = 0; i < s.length(); i++) {
         char c = s.charAt(i);
         if(!(new String(new char[]{c})).matches(RegExpConstant.NUMBER)){
            lastUnNumberIndex = i;
         }
      }
      String value = s;
      if(lastUnNumberIndex >0){
         value = value.substring(lastUnNumberIndex);
      }
      return value;
   }

   /**
    * 去除补位字符
    * @param s 字符
    * @param fillString 补位字符
    * @param left 是否左补位
    * @return 替换后的值
    */
   private String killFillChar(String s, String fillString,boolean left){
      Integer index = 0;
      String value = s;
      if(left){
         for (int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);
            if((new String(new char[]{c})).equalsIgnoreCase(fillString)){
               index = i;
            }
         }
         if(index >0){
            value = value.substring(index);
         }
      }else{
         //从右往左找
         for (int i = s.length()-1; i >=0; i++) {
            char c = s.charAt(i);
            if((new String(new char[]{c})).equalsIgnoreCase(fillString)){
               index = i;
            }
         }
         if(index >0){
            value = value.substring(0,index);
         }
      }
      return value;

   }

   /**
    * 回收码值
    *
    * @param btmId                 业务数据的业务类型
    * @param businessOidCollection 业务数据的主键
    * @return 是否更新成功
    */
   @Override
   public Boolean recycleCode(String btmId, Collection<String> businessOidCollection) {
//      boolean oldPersistence =  WebUtil.isPersistence();
//      WebUtil.setPersistence(false);
//      BatchCBO batchCBO = new BatchCBO();
      AtomicReference<Boolean> updateFlag = new AtomicReference<>(false);
      VciBaseUtil.switchCollectionForOracleIn(businessOidCollection).stream().forEach(oids-> {
//         Map<String, String> conditionMap = new HashMap<>();
//         //编码要记录为回收的状态
//         conditionMap.put("createcodeoid", QueryOptionConstant.IN + "(" + VciBaseUtil.toInSql(oids.toArray(new String[0])) + ")");
//         conditionMap.put("createcodebtm", btmId);

         QueryWrapper<CodeAllCode> wrapper = new QueryWrapper<>();
         wrapper.in("createcodeoid",QueryOptionConstant.IN + "(" + VciBaseUtil.toInSql(oids.toArray(new String[0])) + ")");
         wrapper.eq("createcodebtm", btmId);


         List<CodeAllCode> allCodeDOS = codeAllCodeService.selectByWrapper(wrapper);
//         allCodeMapper.selectByCondition(conditionMap, new PageHelper(-1));
         if (!CollectionUtils.isEmpty(allCodeDOS)) {
            allCodeDOS.stream().forEach(codeDO->{
               codeDO.setLcStatus(CodeAllCodeLC.TASK_BACK.getValue());
            });
            updateFlag.set(codeAllCodeService.updateBatchById(allCodeDOS));
//            batchCBO.copyFromOther(allCodeMapper.batchUpdate(allCodeDOS));
         }
      });
//      WebUtil.setPersistence(oldPersistence);
      return updateFlag.get();
   }

   /**
    * 使用CBO处理组合规则的内容
    * @param cbo 数据的内容
    * @param rule 规则的内容
    * @return 转换后的
    */
   private String getValueByFormulaForCBO(BaseModel cbo,String rule)  {
      Map<String, Object> dataMap = null;
      try{
         dataMap = VciBaseUtil.convertBean2Map(cbo);
      }catch(Exception e){
         throw new VciBaseException("mapToBeanError:"+e);
      }
      Map<String, String> map = new HashMap<String, String>();
      for (String i : dataMap.keySet()) {
         map.put(i, String.valueOf(dataMap.get(i)));
      }
//      WebUtil.copyValueToMapFromCbos(cbo,dataMap);
      return formulaService.getValueByFormula(map,rule);
   }
}