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

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,4302 @@
package com.vci.ubcs.code.service.impl;

import com.alibaba.fastjson.JSONObject;
import com.alibaba.nacos.common.utils.StringUtils;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.vci.ubcs.code.bo.AttributeValue;
import com.vci.ubcs.code.bo.CodeClassifyFullInfoBO;
import com.vci.ubcs.code.bo.CodeTemplateAttrSqlBO;
import com.vci.ubcs.code.dto.CodeExportAttrDTO;
import com.vci.ubcs.code.dto.CodeOrderDTO;
import com.vci.ubcs.code.entity.CodeAllCode;
import com.vci.ubcs.code.enumpack.CodeDefaultLC;
import com.vci.ubcs.code.enumpack.CodeLevelTypeEnum;
import com.vci.ubcs.code.lifecycle.CodeAllCodeLC;
import com.vci.ubcs.code.mapper.CommonsMapper;
import com.vci.ubcs.code.service.*;
import com.vci.ubcs.code.util.ClientBusinessObject;
import com.vci.ubcs.code.vo.CodeKeyAttrRepeatVO;
import com.vci.ubcs.code.vo.pagemodel.*;
import com.vci.ubcs.code.vo.webserviceModel.attrmap.DataObjectVO;
import com.vci.ubcs.code.vo.webserviceModel.attrmap.RowDatas;
import com.vci.ubcs.code.vo.webserviceModel.result.xml.XMLResultDataObjectDetailDO;
import com.vci.ubcs.file.util.VciZipUtil;
import com.vci.ubcs.omd.feign.IBtmTypeClient;
import com.vci.ubcs.omd.feign.IWebSecretClient;
import com.vci.ubcs.omd.vo.BtmTypeVO;
import com.vci.ubcs.starter.bo.WriteExcelData;
import com.vci.ubcs.starter.exception.VciBaseException;
import com.vci.ubcs.starter.poi.bo.ReadExcelOption;
import com.vci.ubcs.starter.poi.bo.SheetDataSet;
import com.vci.ubcs.starter.poi.bo.SheetRowData;
import com.vci.ubcs.starter.poi.bo.WriteExcelOption;
import com.vci.ubcs.starter.poi.util.ExcelUtil;
import com.vci.ubcs.starter.revision.model.BaseModel;
import com.vci.ubcs.starter.util.DefaultAttrAssimtUtil;
import com.vci.ubcs.starter.util.LocalFileUtil;
import com.vci.ubcs.starter.web.constant.QueryOptionConstant;
import com.vci.ubcs.starter.web.enumpck.BooleanEnum;
import com.vci.ubcs.starter.web.enumpck.UserSecretEnum;
import com.vci.ubcs.starter.web.enumpck.VciFieldTypeEnum;
import com.vci.ubcs.starter.web.pagemodel.*;
import com.vci.ubcs.starter.web.toolmodel.DateConverter;
import com.vci.ubcs.starter.web.util.*;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections4.map.HashedMap;
import org.apache.poi.hssf.usermodel.HSSFRichTextString;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.hssf.util.HSSFColor;
import org.apache.poi.ss.usermodel.Font;
import org.apache.poi.ss.usermodel.RichTextString;
import org.apache.poi.ss.usermodel.Workbook;
import org.springblade.core.redis.cache.BladeRedis;
import org.springblade.core.tool.api.R;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils;
import javax.annotation.Resource;
import java.io.File;
import java.io.IOException;
import java.text.MessageFormat;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.CopyOnWriteArraySet;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.stream.Collectors;

import static com.alibaba.druid.util.FnvHash.Constants.LIMIT;
import static com.vci.ubcs.code.constant.MdmEngineConstant.*;
import static com.vci.ubcs.starter.poi.util.ExcelUtil.*;

@RequiredArgsConstructor
@Service
@Slf4j
public class MdmIOServiceImpl implements MdmIOService {


   /**
    * å­—段
    */
   public static final String ROW_INDEX = "LAY_TABLE_INDEX";

   /**
    * é”™è¯¯ä¿¡æ¯çš„字段
    */
   public static final String ERROR_MSG = "errorMsg";

   @Value("${batchadd.exportattr.type:基本信息}")
   public String BATCHADD_EXCEPORT_ATTR_TYPE;

   @Value("${batchadd.redis.time:6000000}")
   public int BATCHADD_REDIS_TIME;
   /**
    * ä¸»é¢˜åº“分类的服务
    */
   @Resource
   private ICodeClassifyService classifyService;


   /**
    * é€šç”¨æŸ¥è¯¢
    */
   @Resource
   private CommonsMapper commonsMapper;
   /****
    * ç å€¼æœåŠ¡
    */
   @Resource
   ICodeAllCodeService codeAllCodeService;

   /**
    * æ¨¡æ¿çš„服务
    */
   @Resource
   private CodeClstemplateServiceImpl templateService;

   /**
    * ä¸»æ•°æ®å¼•æ“Žçš„服务
    */
   @Resource
   private MdmEngineService engineService;
   /***
    * resdis缓存服务
    */
   private final BladeRedis bladeRedis;
   /**
    * ç”Ÿæˆç¼–码的服务
    */
   @Resource
   private MdmProductCodeService productCodeService;
   /**
    * å…³é”®å±žæ€§çš„配置
    */
   @Autowired
   private ICodeKeyAttrRepeatService keyRuleService;

   /**
    * å…¬å¼çš„服务
    */
   @Autowired
   private FormulaServiceImpl formulaService;
   /**
    * è§„则的服务
    */
   @Autowired
   private ICodeRuleService ruleService;
   /**
    * ä¸šåŠ¡ç±»åž‹çš„服务
    */
   @Autowired
   private IBtmTypeClient btmTypeClient;

   /***
    * å¯†çº§æœåŠ¡
    */
   @Resource
   private IWebSecretClient secretService;

   /**
    * å¯¼å‡ºçš„十万条
    */
   public static final int EXPORT_LIMIT = 100000;

   /**
    * æ‰¹é‡ç”³è¯·ï¼šé€‰å–选中分类下的所有模板关键属性，相似属性，必填属性，写入execl中
    *
    * @param codeClassifyOid åˆ†ç±»çš„主键
    * @return excel的文件地址
    */
   @Override
   public  String downloadTopImportExcel(String codeClassifyOid){
      List<CodeClassifyTemplateVO> templateVOList=new ArrayList<>();
      VciBaseUtil.alertNotNull("导出模板","导出的配置",codeClassifyOid,"主题库分类的主键");
      CodeClassifyVO codeClassifyVO = classifyService.getObjectByOid(codeClassifyOid);
      templateVOList= templateService.childTemplates(codeClassifyOid);
      List<CodeClassifyVO>  codeClassifyVOS=classifyService.getIdPathToNamePathByParentId(codeClassifyOid,true);
      WriteExcelOption eo = new WriteExcelOption();
      LinkedHashMap<String,CodeClassifyTemplateAttrVO> allFieldToOutNameMap=new LinkedHashMap<>();
      templateVOList.stream().forEach(templateVO -> {
         //组合格式的不导入，
         // æžšä¸¾çš„提供序列的选择
         //时间全部统一为yyyy-MM-dd HH:mm:ss
         //参照的自行输入名称
         //分类注入的不用，都是导入后自动处理的
         //编码，状态等字段不导入
         if(!CollectionUtils.isEmpty(templateVO.getAttributes())) {
            List<CodeClassifyTemplateAttrVO> templateAttrVOS = templateVO.getAttributes().stream().filter(s ->
               !DEFAULT_ATTR_LIST.contains(s.getId())
                  && StringUtils.isBlank(s.getComponentRule())
                  && StringUtils.isBlank(s.getClassifyInvokeAttr())
                  && (VciBaseUtil.getBoolean(s.getFormDisplayFlag()))
            ).collect(Collectors.toList());
            if(CollectionUtils.isEmpty(templateAttrVOS)){
               throw new VciBaseException("模板没有配置任何【表单显示】为【是】的属性");
            }
            templateAttrVOS.stream().forEach(codetemplateAttr -> {
               String field = codetemplateAttr.getId();
               String name = codetemplateAttr.getName();
               CodeClassifyTemplateAttrVO codeBaseAttributeDTO = new CodeClassifyTemplateAttrVO();
               boolean res = (StringUtils.isNotBlank(codetemplateAttr.getAttributeGroup()) && codetemplateAttr.getAttributeGroup().equals(BATCHADD_EXCEPORT_ATTR_TYPE))//基本属性字段显示
                  || (StringUtils.isNotBlank(codetemplateAttr.getKeyAttrFlag()) && Boolean.parseBoolean(codetemplateAttr.getKeyAttrFlag()))//关键属性的存入
                  || (StringUtils.isNotBlank(codetemplateAttr.getSameRepeatAttrFlag()) && Boolean.parseBoolean(codetemplateAttr.getSameRepeatAttrFlag())) //相似属性的存入
                  || (StringUtils.isNotBlank(codetemplateAttr.getRequireFlag()) && Boolean.parseBoolean(codetemplateAttr.getRequireFlag()));
               if (allFieldToOutNameMap.containsKey(name)) {//如果存在的话则需要根据具体的去赋值
                  codeBaseAttributeDTO = allFieldToOutNameMap.get(name);
                  if (StringUtils.isNotBlank(codetemplateAttr.getKeyAttrFlag()) && Boolean.parseBoolean(codetemplateAttr.getKeyAttrFlag())) {
                     codeBaseAttributeDTO.setKeyAttrFlag(codetemplateAttr.getKeyAttrFlag());//属性关键属性
                  }
                  if (StringUtils.isNotBlank(codetemplateAttr.getRequireFlag()) && Boolean.parseBoolean(codetemplateAttr.getRequireFlag())) {
                     codeBaseAttributeDTO.setRequireFlag(codetemplateAttr.getRequireFlag());//属性必填项
                  }
                  if (StringUtils.isNotBlank(codetemplateAttr.getSameRepeatAttrFlag()) && Boolean.parseBoolean(codetemplateAttr.getSameRepeatAttrFlag())) {
                     codeBaseAttributeDTO.setSameRepeatAttrFlag(codetemplateAttr.getSameRepeatAttrFlag());//属性相似属性
                  }
               } else if (res) {
                  allFieldToOutNameMap.put(name, codetemplateAttr);
               }
            });
         }
      });
      //整理好所有模板需要写入execl的属性信息
      Workbook workbook = new HSSFWorkbook();
      LinkedList<WriteExcelData> excelDataList = new LinkedList<>();
      if(!CollectionUtils.isEmpty(allFieldToOutNameMap)){
         excelDataList.add(new WriteExcelData(0,0,"分类路径"));
         final int[] index = {0};
         allFieldToOutNameMap.values().stream().forEach(attrVO -> {
            Object text = attrVO.getName();
            text = exportKeyAndRequired(workbook,attrVO,text);
            int colIndex = 1 + index[0]++;
            WriteExcelData excelData = new WriteExcelData(0, colIndex, text);
            if(StringUtils.isNotBlank(attrVO.getCodeDateFormat())
               || VciFieldTypeEnum.VTDateTime.name().equalsIgnoreCase(attrVO.getAttributeDataType())
               || VciFieldTypeEnum.VTDate.name().equalsIgnoreCase(attrVO.getAttributeDataType())
               ||VciFieldTypeEnum.VTTime.name().equalsIgnoreCase(attrVO.getAttributeDataType())){
               excelData.setDateFormat(VciDateUtil.DateTimeFormat);
            }
            if(text instanceof RichTextString){
               excelData.setFontColor(String.valueOf(HSSFColor.HSSFColorPredefined.RED.getIndex()));
            }
            excelDataList.add(excelData);
            if(StringUtils.isNotBlank(attrVO.getEnumString()) || StringUtils.isNotBlank(attrVO.getEnumId())){
               //添加数据有效性
               List<String> enumValueList = new ArrayList<>();
               enumValueList.add("");
               List<KeyValue> valueList = engineService.listComboboxItems(attrVO);
               if(!CollectionUtils.isEmpty(valueList)){
                  valueList.stream().forEach(kv->{
                     enumValueList.add(kv.getValue());
                  });
               }
               //默认加1万条
               WriteExcelData ed = new WriteExcelData(1,colIndex,"");
               ed.setRowTo(100);
               ed.setColTo(colIndex);
               ed.setValidation(true);
               ed.setValidationDataList(enumValueList);
               ed.setValidationErrorMsg("请在序列中选择正确的值");
               excelDataList.add(ed);
            }
            if(VciFieldTypeEnum.VTBoolean.name().equalsIgnoreCase(attrVO.getAttributeDataType())){
               List<String> booleanList = new ArrayList<>();
               booleanList.add("是");
               booleanList.add("否");
               //默认加1万条
               WriteExcelData ed = new WriteExcelData(1,colIndex,"");
               ed.setRowTo(100);
               ed.setColTo(colIndex);
               ed.setValidation(true);
               ed.setValidationDataList(booleanList);
               ed.setValidationErrorMsg("请在序列中选择正确的值");
               excelDataList.add(ed);
            }
         });
         eo.addSheetDataList(codeClassifyVO.getName()+"导入模板",excelDataList);
      }
      LinkedList<WriteExcelData> classPathList = new LinkedList<>();
      classPathList.add(new WriteExcelData(0,0,"分类层级"));

      WriteExcelData idPathWriteExcelTitle=new WriteExcelData(0,1,"分类ID路径");
      idPathWriteExcelTitle.setWidth(20);
      idPathWriteExcelTitle.setCenter(false);
      classPathList.add(idPathWriteExcelTitle);
      WriteExcelData namePathWriteExcelTitle=new WriteExcelData(0,2,"分类名称路径");
      namePathWriteExcelTitle.setWidth(20);
      namePathWriteExcelTitle.setCenter(false);
      classPathList.add(namePathWriteExcelTitle);


      final int[] rowIndex = {1};
      codeClassifyVOS.stream().forEach(codeClassifyVO1 -> {
         classPathList.add(new WriteExcelData(rowIndex[0],0,codeClassifyVO1.getDataLevel()));

         String idPath=codeClassifyVO1.getIdPath().startsWith("#")?codeClassifyVO1.getIdPath().substring(1):codeClassifyVO1.getIdPath();
         WriteExcelData idPathWriteExcelData=new WriteExcelData(rowIndex[0],1,idPath);
         idPathWriteExcelData.setWidth(30);
         idPathWriteExcelData.setCenter(false);
         classPathList.add(idPathWriteExcelData);

         String namePath=codeClassifyVO1.getNamePath().startsWith("#")?codeClassifyVO1.getNamePath().substring(1):codeClassifyVO1.getNamePath();
         WriteExcelData  namePathWriteExcelData=  new WriteExcelData(rowIndex[0],2,namePath);
         namePathWriteExcelData.setWidth(40);
         namePathWriteExcelData.setCenter(false);
         classPathList.add(namePathWriteExcelData);
         rowIndex[0]++;
      });

      WriteExcelData  excelData=new WriteExcelData();
      excelData.setMerged(true);
      excelData.setRow(1);
      excelData.setRowTo(2);
      excelData.setCol(4);
      excelData.setColTo(9);
      excelData.setCenter(false);
      excelData.setReadOnly(true);
      excelData.setObj("导入数据时，分类路径必须填写叶子节点路径\n(选择叶子节点导入则不需要填写分类路径)");
      excelData.setFontColor(String.valueOf(HSSFColor.HSSFColorPredefined.RED.getIndex()));
      classPathList.add(excelData);

      eo.addSheetDataList(codeClassifyVO.getName()+"分类对照表",classPathList);

      String excelName = LocalFileUtil.getDefaultTempFolder() + File.separator + codeClassifyVO.getName() + "_导入模板.xls";
      // eo.addSheetDataList(templateVOList.size()+"模板信息【请勿删除或移动】",tempEDList);
      ExcelUtil.writeDataToFile(excelName,eo);
      return excelName;
   }

   /**
    * ç”Ÿæˆå¯¼å…¥çš„文件
    *
    * @param codeClassifyOid åˆ†ç±»çš„主键
    * @param isHistory æ˜¯å¦åŽ†å²æ•°æ®å¯¼å…¥
    * @return excel的文件地址
    */
   @Override
   public String createImportExcel(String codeClassifyOid, boolean isHistory) {
      List<CodeClassifyTemplateVO> templateVOList=new ArrayList<>();

      VciBaseUtil.alertNotNull("导出模板","导出的配置",codeClassifyOid,"主题库分类的主键");

      CodeClassifyVO codeClassifyVO = classifyService.getObjectByOid(codeClassifyOid);

      if(isHistory){
         templateVOList= templateService.childTemplates(codeClassifyOid);
      }else{
         //找模板
         CodeClassifyTemplateVO templateVO = engineService.getUsedTemplateByClassifyOid(codeClassifyOid);
         templateVOList.add(templateVO);
      }

      WriteExcelOption eo = new WriteExcelOption();
      eo.setAppend(true);
      //增加模板的信息导入
      LinkedList<WriteExcelData> tempEDList = new LinkedList<>();
      tempEDList.add(new WriteExcelData(0,0,"模板主键"));
      tempEDList.add(new WriteExcelData(0,1,"模板代号"));
      tempEDList.add(new WriteExcelData(0,2,"模板名称"));
      for(int j=0;j<templateVOList.size();j++){
         CodeClassifyTemplateVO  templateVO=templateVOList.get(j);
         CodeClassifyTemplateVO codeClassifyTemplateVO = new CodeClassifyTemplateVO();
         BeanUtils.copyProperties(templateVO,codeClassifyTemplateVO);
         //组合格式的不导入，
         // æžšä¸¾çš„提供序列的选择
         //时间全部统一为yyyy-MM-dd HH:mm:ss
         //参照的自行输入名称
         //分类注入的不用，都是导入后自动处理的
         //编码，状态等字段不导入
         List<CodeClassifyTemplateAttrVO> codeClassifyTemplateAttrVOList=codeClassifyTemplateVO.getAttributes();
         if(!CollectionUtils.isEmpty(codeClassifyTemplateAttrVOList)) {
            if (CollectionUtils.isEmpty(codeClassifyTemplateAttrVOList)) {
               throw new VciBaseException("模板没有配置属性");
            }
         }
         List<CodeClassifyTemplateAttrVO> templateAttrVOS = codeClassifyTemplateAttrVOList.stream().filter(s ->
            !DEFAULT_ATTR_LIST.contains(s.getId())
               && StringUtils.isBlank(s.getComponentRule())
               && StringUtils.isBlank(s.getClassifyInvokeAttr())
               && (isHistory || VciBaseUtil.getBoolean(s.getFormDisplayFlag()))
         ).collect(Collectors.toList());

            if (CollectionUtils.isEmpty(templateAttrVOS)) {
               throw new VciBaseException("模板没有配置任何【表单显示】为【是】的属性");
            }

         List<CodeClassifyTemplateAttrVO> idAttrVOList = codeClassifyTemplateVO.getAttributes().stream().filter(s -> s.getId().equalsIgnoreCase(CODE_FIELD)).collect(Collectors.toList());
         LinkedList<WriteExcelData> excelDataList = new LinkedList<>();
         Workbook workbook = new HSSFWorkbook();
         if(isHistory){
            excelDataList.add(new WriteExcelData(0,0,"分类路径"));
            excelDataList.add(new WriteExcelData(0,1,"码段宽度"));
            excelDataList.add(new WriteExcelData(0,2,!CollectionUtils.isEmpty(idAttrVOList)?idAttrVOList.get(0).getName():"企业编码"));
         }
         for (int i = 0; i < templateAttrVOS.size(); i++) {
            CodeClassifyTemplateAttrVO attrVO = templateAttrVOS.get(i);

            Object text = attrVO.getName();
            text = exportKeyAndRequired(workbook,attrVO,text);
            int colIndex = (isHistory?3:0) + i;
            WriteExcelData excelData = new WriteExcelData(0, colIndex, text);
            if(StringUtils.isNotBlank(attrVO.getCodeDateFormat())
               || VciFieldTypeEnum.VTDateTime.name().equalsIgnoreCase(attrVO.getAttributeDataType())
               || VciFieldTypeEnum.VTDate.name().equalsIgnoreCase(attrVO.getAttributeDataType())
               ||VciFieldTypeEnum.VTTime.name().equalsIgnoreCase(attrVO.getAttributeDataType())){
               excelData.setDateFormat(VciDateUtil.DateTimeFormat);
            }
            if(text instanceof RichTextString){
               excelData.setFontColor(String.valueOf(HSSFColor.HSSFColorPredefined.RED.getIndex()));
            }
            excelDataList.add(excelData);
            if(StringUtils.isNotBlank(attrVO.getEnumString()) || StringUtils.isNotBlank(attrVO.getEnumId())){
               //添加数据有效性
               List<String> enumValueList = new ArrayList<>();
               enumValueList.add("");
               List<KeyValue> valueList = engineService.listComboboxItems(attrVO);
               if(!CollectionUtils.isEmpty(valueList)){
                  valueList.stream().forEach(kv->{
                     enumValueList.add(kv.getValue());
                  });
               }
               //默认加1万条
               WriteExcelData ed = new WriteExcelData(1,colIndex,"");
               ed.setRowTo(100);
               ed.setColTo(colIndex);
               ed.setValidation(true);
               ed.setValidationDataList(enumValueList);
               ed.setValidationErrorMsg("请在序列中选择正确的值");
               excelDataList.add(ed);
            }
            if(VciFieldTypeEnum.VTBoolean.name().equalsIgnoreCase(attrVO.getAttributeDataType())){
               List<String> booleanList = new ArrayList<>();

               booleanList.add("是");
               booleanList.add("否");
               //默认加1万条
               WriteExcelData ed = new WriteExcelData(1,colIndex,"");
               ed.setRowTo(100);
               ed.setColTo(colIndex);
               ed.setValidation(true);
               ed.setValidationDataList(booleanList);
               ed.setValidationErrorMsg("请在序列中选择正确的值");
               excelDataList.add(ed);
            }
         }
         eo.addSheetDataList(j+templateVO.getName(),excelDataList);
         tempEDList.add(new WriteExcelData(j+1,0,templateVO.getOid()));
         tempEDList.add(new WriteExcelData(j+1,1,templateVO.getId()));
         tempEDList.add(new WriteExcelData(j+1,2,templateVO.getName()));
      }
      String excelName = LocalFileUtil.getDefaultTempFolder() + File.separator + codeClassifyVO.getName() + (isHistory?"_历史数据导入模板.xls": "_导入模板.xls");
      eo.addSheetDataList(templateVOList.size()+"模板信息【请勿删除或移动】",tempEDList);
      ExcelUtil.writeDataToFile(excelName,eo);
      return excelName;
   }

   /**
    * å¯¼å‡ºçš„时候封装必输和关键属性
    * @param attrVO å±žæ€§çš„显示对象
    * @param text å•å…ƒæ ¼çš„值
    */
   private Object exportKeyAndRequired(Workbook workbook,CodeClassifyTemplateAttrVO attrVO,Object text){
      //必输加*，关键属性为蓝色
      if (VciBaseUtil.getBoolean(attrVO.getRequireFlag()) || VciBaseUtil.getBoolean(attrVO.getKeyAttrFlag())) {
         String value = text.toString();
         if(VciBaseUtil.getBoolean(attrVO.getRequireFlag())) {
            value += REQUIRED_CHAR;
         }
         if(VciBaseUtil.getBoolean(attrVO.getKeyAttrFlag())){
            value += KEY_ATTR_CHAR;
         }
         RichTextString ts = new HSSFRichTextString(value);
         if(VciBaseUtil.getBoolean(attrVO.getRequireFlag())){
            Font font =  workbook.createFont();
            font.setColor(HSSFColor.HSSFColorPredefined.RED.getIndex());
            ts.applyFont(font);
         }

         if(VciBaseUtil.getBoolean(attrVO.getKeyAttrFlag())){
            Font font =  workbook.createFont();
            font.setColor(HSSFColor.HSSFColorPredefined.BLUE.getIndex());
            ts.applyFont(font);
         }
         return ts;
      }
      return text;
   }


   /**
    * æ‰¹é‡ç”³è¯·ç¼–码数据
    *
    * @param orderDTO ç¼–码申请信息，必须包含分类主键和码段的信息
    * @param file     excel文件的信息
    * @return  æœ‰é”™è¯¯ä¿¡æ¯çš„excel的文件
    */
   @Override
   public CodeImProtRusultVO batchImportCode(CodeOrderDTO orderDTO, File file) {
      VciBaseUtil.alertNotNull(orderDTO,"编码申请相关的数据",orderDTO.getCodeClassifyOid(),"主题库分类主键");
      ReadExcelOption reo = new ReadExcelOption();
      reo.setReadAllSheet(true);
      List<SheetDataSet> sheetDataSetList = ExcelUtil.readDataObjectFromExcel(file,null,reo);
      if(CollectionUtils.isEmpty(sheetDataSetList) || CollectionUtils.isEmpty(sheetDataSetList.get(0).getRowData())
         ||sheetDataSetList.get(0).getRowData().size()<1){
         throw new VciBaseException("没有读取到任何的数据");
      }
      if(sheetDataSetList.size()>LIMIT+1){
         throw new VciBaseException("为了保证系统的稳定性，请一次不要导入超过1万条的数据");
      }
      //先找到每一行的标题，然后根据标题来获取对应的属性
      SheetDataSet dataSet = sheetDataSetList.get(0);
      //找第一行，为了找标题
      CodeClassifyTemplateVO templateVO = engineService.getUsedTemplateByClassifyOid(orderDTO.getCodeClassifyOid());

      //校验模板是不是最新的
      checkTemplateSync(sheetDataSetList,templateVO,0);
      //先不用管属性是否都存在，先转换一下数据
      Map<String,String> errorMap = new HashMap<>();
      String redisUUid=batchImportCodes(orderDTO,templateVO,dataSet,errorMap,true);
      CodeImProtRusultVO codeImProtRusultVO = new CodeImProtRusultVO();
      List<String> needRowIndexList = new ArrayList<>();
      String filePath = returnErrorToExcel(dataSet.getRowData(), errorMap, needRowIndexList, dataSet.getColName());
      if(StringUtils.isNotBlank(filePath)) {
         codeImProtRusultVO.setFilePath(filePath);
      }
      if(StringUtils.isNotBlank(redisUUid)){
         codeImProtRusultVO.setRedisUuid(redisUUid);
      }
//      return null;
      return codeImProtRusultVO;
   }


   /***
    * ä»Žé¡¶å±‚批量申请导入方法
    * @param codeClassifyOid åˆ†ç±»çš„主键
    * @param classifyAttr åˆ†ç±»è·¯å¾„使用的属性
    * @param file excel文件的信息
    * @return
    */
   @Override
   public CodeImProtRusultVO batchTopImportCode(String codeClassifyOid, String classifyAttr, File file) {
      VciBaseUtil.alertNotNull(codeClassifyOid,"分类的主键");
      ReadExcelOption reo = new ReadExcelOption();
      reo.setReadAllSheet(true);
      List<SheetDataSet> sheetDataSetList = ExcelUtil.readDataObjectFromExcel(file,null,reo);
      if(CollectionUtils.isEmpty(sheetDataSetList) || CollectionUtils.isEmpty(sheetDataSetList.get(0).getRowData())
         ||sheetDataSetList.get(0).getRowData().size()<1){
         throw new VciBaseException("没有读取到任何的数据");
      }
      if(sheetDataSetList.size()>LIMIT+1){
         throw new VciBaseException("为了保证系统的稳定性，请一次不要导入超过1万条的数据");
      }
      //先找到每一行的标题，然后根据标题来获取对应的属性
      SheetDataSet dataSet = sheetDataSetList.get(0);
      CodeClassifyFullInfoBO classifyFullInfo = classifyService.getClassifyFullInfo(codeClassifyOid);
      //获取当前模板
      CodeClassifyTemplateVO selectCodeClassifyTemplateVO =engineService.getUsedTemplateByClassifyOid(codeClassifyOid);
      Map<String,List<ColumnVO>> templateColumnVOMap=new HashMap<>();
      createTemplate(selectCodeClassifyTemplateVO,templateColumnVOMap);

      List<CodeClassifyVO> childClassifyVOs = classifyService.listChildrenClassify(codeClassifyOid, true, classifyAttr, true);
      Map<String/**路径**/, CodeClassifyVO> pathMap = Optional.ofNullable(childClassifyVOs).orElseGet(() -> new ArrayList<>()).stream().collect(Collectors.toMap(s -> s.getPath().startsWith("#") ? s.getPath().substring(1) : s.getPath(), t -> t));
      pathMap.put("#current#", classifyFullInfo.getCurrentClassifyVO());
      List<String> titleRowData = dataSet.getColName();
      Map<String, String> errorMap = new ConcurrentHashMap<>();
      //首先将数据以模板的形式分开
      LinkedHashMap<String,List<CodeImprotDataVO>> codeclassifyDataMap=new LinkedHashMap<>();
      List<CodeImprotDataVO> codeClassifyDatas=new ArrayList<>();
      createExeclClassData(dataSet,pathMap,errorMap,codeClassifyDatas);

      //根据模板将数据整合在一起，去校验
      Map<String/**模板oid**/, List<CodeImprotDataVO>/**数据对象**/> templateDatasMap =codeClassifyDatas.stream().collect(Collectors.toMap(CodeImprotDataVO::getTemplateOid,s->{
         List<CodeImprotDataVO> l=new ArrayList<>();
         l.add(s);
         return l;
      },(List<CodeImprotDataVO> s1,List<CodeImprotDataVO> s2)->{
         s1.addAll(s2);
         return s1;
      }));
      String uuid=VciBaseUtil.getPk();
      List<CodeImportTemplateVO> codeImportTemplateVOS=new ArrayList<>();
      Map<String,CodeImportTemplateVO> codeRuleMap=new HashMap<>();

      //相似数据
      // Map<String,String>wpResembleMap=new HashMap<>();
      // List<CodeImprotDataVO> wpCodeImprotDataVOList=new ArrayList<>();
      //按照模板去整理数据
      templateDatasMap.keySet().stream().forEach(templateVOOid->{
         List<CodeImprotDataVO> codeImprotDataVOS= templateDatasMap.get(templateVOOid);
         CodeClassifyTemplateVO templateVO= templateService.getObjectHasAttrByOid(templateVOOid);

         //除去默认的属性.还有只有表单显示的字段才导入
         List<CodeClassifyTemplateAttrVO> attrVOS = templateVO.getAttributes().stream().filter(s ->
            !DEFAULT_ATTR_LIST.contains(s.getId()) && VciBaseUtil.getBoolean(s.getFormDisplayFlag())
         ).collect(Collectors.toList());

         Map<String/**模板属性字段oid**/, String /**模板属性外部名称**/> fieldNameMap =attrVOS.stream().collect(Collectors.toMap(CodeClassifyTemplateAttrVO::getId,s->s.getName()));

         List<ClientBusinessObject> allCboList=new ArrayList<>();
         codeImprotDataVOS.stream().forEach(codeImprotDataVO -> {
            List<ColumnVO>columnVOList =new ArrayList();
            String templateOid=selectCodeClassifyTemplateVO.getOid();
            if(templateColumnVOMap.containsKey(templateOid)){
               columnVOList= columnVOList=templateColumnVOMap.get(templateOid);
            }else{
               createTemplate(templateVO,templateColumnVOMap);
               columnVOList= columnVOList=templateColumnVOMap.get(templateOid);
            }
            String codeRuleOid=codeImprotDataVO.getCodeRuleOid();
            if(!codeRuleMap.containsKey(codeRuleOid)){
               CodeImportTemplateVO codeImportTemplateVO=new CodeImportTemplateVO();
               codeImportTemplateVO.setRoot(false);
               codeImportTemplateVO.setCodeClassifyOid(codeImprotDataVO.getCodeClassifyOid());
               codeImportTemplateVO.setCodeRuleOid(codeImprotDataVO.getCodeRuleOid());
               codeImportTemplateVO.setCodeTemplateOid (codeImprotDataVO.getTemplateOid());
               codeImportTemplateVO.setCodeClassifyVO( codeImprotDataVO.getCodeClassifyVO());
               codeImportTemplateVO.setCodeClassifyTemplateVO( codeImprotDataVO.getCodeClassifyTemplateVO());
               codeImportTemplateVO.setCodeRuleVO(codeImprotDataVO.getCodeRuleVO());
               List<String> colNames=codeImprotDataVO.getColNames();
               codeImportTemplateVO.setCloNamesList(columnVOList);
               codeImportTemplateVOS.add(codeImportTemplateVO);
               codeRuleMap.put(codeRuleOid,codeImportTemplateVO);
            }
            List<ClientBusinessObject> cboList=new ArrayList<>();
            excelToCbo(classifyFullInfo,codeImprotDataVO,cboList,true);
            allCboList.addAll(cboList);
            //往选择的节点里面加数据
            // CodeImprotDataVO wpcodeImprotDataVO=new CodeImprotDataVO();
            //   BeanUtilForVCI.copyPropertiesIgnoreCase(codeImprotDataVO,wpcodeImprotDataVO);
               /* wpcodeImprotDataVO.setCodeClassifyOid(codeClassifyOid);
                wpcodeImprotDataVO.setCodeClassifyVO(classifyFullInfo.getCurrentClassifyVO());
                wpcodeImprotDataVO.setCodeClassifyTemplateVO(selectCodeClassifyTemplateVO);
                wpcodeImprotDataVO.setCodeRuleOid(classifyFullInfo.getCurrentClassifyVO().getCoderuleoid());*/
            // wpCodeImprotDataVOList.add(wpcodeImprotDataVO);//往物品对象里添加

         });


         //都转换完了。需要批量检查
         //如果出错了，我们依然执行有效的数据，无效的数据写回到excel中
         //2.判断必输项。。需要全部的属性，如果是必输，但是表单里面不显示的，只能是分类注入或者组合规则
         batchCheckRequiredAttrOnOrder(templateVO,allCboList,errorMap);
         //3.判断关键属性
         CodeImportResultVO keyResultVO = batchCheckKeyAttrOnOrder(classifyFullInfo, templateVO, allCboList);
         Set<String> selfRepeatRowIndexList = keyResultVO.getSelfRepeatRowIndexList();
         Set<String> keyAttrRepeatRowIndexList = keyResultVO.getKeyAttrRepeatRowIndexList();
         if(!CollectionUtils.isEmpty(selfRepeatRowIndexList)){
            selfRepeatRowIndexList.stream().forEach(rowIndex->{
               errorMap.put(rowIndex,errorMap.getOrDefault(rowIndex,"") + ";在当前处理的数据文件中关键属性重复" );
            });
         }
         if(!CollectionUtils.isEmpty(keyAttrRepeatRowIndexList)){
            keyAttrRepeatRowIndexList.stream().forEach(rowIndex->{
               errorMap.put(rowIndex,errorMap.getOrDefault(rowIndex,"") + ";关键属性与系统中的重复" );
            });
         }
         //分类注入
         // batchSwitchClassifyAttrOnOrder(attrVOS,allCboList,classifyFullInfo,false);
         //boolean
         reSwitchBooleanAttrOnOrder(attrVOS,allCboList);
         //4.校验规则
         batchCheckVerifyOnOrder(attrVOS, allCboList,errorMap);
         //是否需要校验枚举/参照
         //5.校验枚举是否正确
         batchSwitchEnumAttrOnOrder(attrVOS, allCboList, errorMap);
         //7.处理参照的情况
         batchSwitchReferAttrOnOrder(attrVOS,allCboList,errorMap);

         //6.时间格式的验证
         //6.时间的，必须统一为yyyy-MM-dd HH:mm:ss
         batchSwitchDateAttrOnOrder(attrVOS,allCboList,errorMap);
         //设置默认值
         batchSwitchAttrDefault(attrVOS, allCboList);
         //最后弄组合规则
         batchSwitchComponentAttrOnOrder(attrVOS,allCboList);


         Map<String, ClientBusinessObject> rowIndexCboMap = allCboList.stream().filter(cbo -> cbo != null).collect(Collectors.toList()).stream().collect(Collectors.toMap(s -> s.getAttributeValue((IMPORT_ROW_INDEX)), t -> t));


         List<ClientBusinessObject> needSaveCboList = allCboList.stream().filter(cbo -> {
            String rowIndex = cbo.getAttributeValue(IMPORT_ROW_INDEX);
            return !errorMap.containsKey(rowIndex);
         }).collect(Collectors.toList());
         //相似校验
         Map<String,String>resembleMap=new HashMap<>();
         List<DataResembleVO> dataResembleVOS=new ArrayList<>();
         String btmtypeid= classifyFullInfo.getTopClassifyVO().getBtmTypeId();
         bathcResembleQuery(codeClassifyOid,templateVO,needSaveCboList,resembleMap,btmtypeid,dataResembleVOS);
         if(resembleMap.size()>0) {
            if(!CollectionUtils.isEmpty(dataResembleVOS)) {
               bladeRedis.set(uuid + "-resemble-data", dataResembleVOS);
               bladeRedis.expire(uuid + "-resemble-data",BATCHADD_REDIS_TIME);//redis过期时间
               // createRedisDatas(uuid + "-resemble", codeImprotDataVOS, resembleMap, false);
               //  wpResembleMap.putAll(resembleMap);
            }
         }
         //排除错误的，剩下正确的
         Map<String,String> newErrorMap=new HashMap<>();
         newErrorMap.putAll(resembleMap);
         newErrorMap.putAll(errorMap);
         needSaveCboList = allCboList.stream().filter(cbo -> {
            String rowIndex = cbo.getAttributeValue(IMPORT_ROW_INDEX);
            return !newErrorMap.containsKey(rowIndex);
         }).collect(Collectors.toList());
         if(newErrorMap.size()>0) {
            createRedisDatas(uuid + "-resemble",codeImprotDataVOS, newErrorMap,false);
         }
         createRedisDatas(uuid + "-ok",codeImprotDataVOS, newErrorMap,true);

      });
      //往物品节点上加模板



      List<String> needRowIndexList=new ArrayList<>();
      CodeImProtRusultVO codeImProtRusultVO = new CodeImProtRusultVO();
      if(errorMap.size()>0) {
         String filePath = returnErrorToExcel(dataSet.getRowData(), errorMap, needRowIndexList, dataSet.getColName());
         if (StringUtils.isNotBlank(filePath)) {
            codeImProtRusultVO.setFilePath(filePath);
         }
      }
      if(StringUtils.isNotBlank(uuid)){
         //将所有的分类存入缓存之中
         codeImProtRusultVO.setRedisUuid(uuid);
         /**  List<ColumnVO>columnVOList=new ArrayList<>();
          CodeImportTemplateVO wpCodeImportTemplateVO=new CodeImportTemplateVO();
          wpCodeImportTemplateVO.setRoot(true);
          wpCodeImportTemplateVO.setCodeClassifyTemplateVO(selectCodeClassifyTemplateVO);
          wpCodeImportTemplateVO.setCodeClassifyVO(classifyFullInfo.getCurrentClassifyVO());
          String templateOid=selectCodeClassifyTemplateVO.getOid();
          if(templateColumnVOMap.containsKey(templateOid)){
          columnVOList= columnVOList=templateColumnVOMap.get(templateOid);
          }else{
          createTemplate(selectCodeClassifyTemplateVO,templateColumnVOMap);
          columnVOList= columnVOList=templateColumnVOMap.get(templateOid);
          }
          wpCodeImportTemplateVO.setCloNamesList(columnVOList);
          codeImportTemplateVOS.add(wpCodeImportTemplateVO);

          if(wpResembleMap.size()>0){
          //  redisService.setCacheList(uuid + "-resemble-data", wpDataResembleVOList);
          createRedisDatas(uuid + "-resemble",selectCodeClassifyTemplateVO, wpCodeImprotDataVOList, wpResembleMap, false,codeClassifyOid);
          }
          //排除错误的，剩下正确的
          Map<String,String> newErrorMap=new HashMap<>();
          newErrorMap.putAll(wpResembleMap);
          newErrorMap.putAll(errorMap);
          List<CodeImprotDataVO>  needSaveCboList = wpCodeImprotDataVOList.stream().filter(cbo -> {
          String rowIndex = cbo.getRowIndex();
          return !newErrorMap.containsKey(rowIndex);
          }).collect(Collectors.toList());
          createRedisDatas(uuid + "-ok",selectCodeClassifyTemplateVO,wpCodeImprotDataVOList, newErrorMap,true,codeClassifyOid);****/
         if(codeImportTemplateVOS.size()>0){
            bladeRedis.set(uuid + "-class",codeImportTemplateVOS);
            bladeRedis.expire(uuid + "-class",BATCHADD_REDIS_TIME);
         }
      }
      return codeImProtRusultVO;
   }

   /**
    * å¯¼å…¥åŽ†å²æ•°æ®
    *
    * @param codeClassifyOid åˆ†ç±»çš„主键
    * @param classifyAttr åˆ†ç±»è·¯å¾„使用的属性
    * @param file            excel文件的信息
    * @return æœ‰é”™è¯¯ä¿¡æ¯çš„excel
    */
   @Override
   public CodeImProtRusultVO batchImportHistoryData(String codeClassifyOid, String classifyAttr,File file) throws  Throwable{
      VciBaseUtil.alertNotNull(codeClassifyOid,"分类的主键");
      ReadExcelOption reo = new ReadExcelOption();
      reo.setReadAllSheet(true);
      List<SheetDataSet> sheetDataSetList = ExcelUtil.readDataObjectFromExcel(file,null,reo);
      if (sheetDataSetList.size() > LIMIT + 1) {
         throw new VciBaseException("为了保证系统的稳定性，请一次不要导入超过1万条的数据");
      }
      Map<String,List<WriteExcelData>> shetNameMap=new HashMap<>();
      //相似项目查重
      String uuid=VciBaseUtil.getPk();
      boolean isCreateUUid=false;
      boolean isExport=false;
      for(int i=0;i<sheetDataSetList.size()-1;i++) {
         if (CollectionUtils.isEmpty(sheetDataSetList) || CollectionUtils.isEmpty(sheetDataSetList.get(i).getRowData())
            || sheetDataSetList.get(i).getRowData().size() < 1) {
            continue;
         }
         //历史导入的时候不处理编码
         //----逻辑内容----
         //1. åˆ†ç±»çš„路径可以在页面上选择是分类编号还是分类的名称
         //2. åˆ†ç±»çš„路径，必须是当前导入选择的分类的节点，以及其下级节点
         //3. é€šè¿‡æ•°æ®è¦å¯¼å…¥çš„分类去查找对应的编码规则
         //4. æ•°æ®å­˜å‚¨å’Œæ‰¹é‡ç”³è¯·ä¸€æ ·ï¼Œ
         //5. éœ€è¦å•ç‹¬å¤„理企业编码的内容，
         //     5.1 ä¼ä¸šç¼–码在当前excel里不能重复
         //     5.2 ä¼ä¸šç¼–码在系统中不能重复（可以是已经回收的）
         //     5.3 ä¼ä¸šç¼–码的长度，和编码规则的长度要对应上
         //     5.4 èŽ·å–流水码段的值，去除填充的字符，看流水号是多少，然后将流水号和现在的最大流水号判断，小于就直接录入，大于则修改最大流水号
         //     5.5 å­˜å‚¨ä¼ä¸šç¼–码到allcode中

         //查询分类和模板
         CodeClassifyFullInfoBO classifyFullInfo = classifyService.getClassifyFullInfo(codeClassifyOid);

         //先找到每一行的标题，然后根据标题来获取对应的属性
         SheetDataSet dataSet = sheetDataSetList.get(i);
         List<SheetRowData> rowDataList = dataSet.getRowData();

         //找第一行，为了找标题
         CodeClassifyTemplateVO templateVO = new CodeClassifyTemplateVO();
         /**  if (!templateService.checkChildHasSameTemplate(classifyFullInfo.getCurrentClassifyVO().getOid())) {
          throw new VciBaseException("当前的分类以及下级分类的模板不相同");
          }***/
         //都转换完了。需要批量检查
         //找所有的分类路径,需要校验路径是否正确，是否都在当前的分类的下级
         List<CodeClassifyVO> childClassifyVOs = classifyService.listChildrenClassify(codeClassifyOid, true, classifyAttr, true);
         Map<String/**路径**/, CodeClassifyVO> pathMap = Optional.ofNullable(childClassifyVOs).orElseGet(() -> new ArrayList<>()).stream().collect(Collectors.toMap(s -> s.getPath().startsWith("#") ? s.getPath().substring(1) : s.getPath(), t -> t));
         List<String> titleRowData = dataSet.getColName();
         Map<String, String> errorMap = new ConcurrentHashMap<>();
         pathMap.put("#current#",classifyFullInfo.getCurrentClassifyVO());

         try {
            List<CodeClassifyTemplateVO> templateVOList= checkSamesTemplate(titleRowData,sheetDataSetList,i,pathMap,errorMap);
            templateVO= templateVOList.get(0);
         }catch (Throwable e){
            throw  new VciBaseException(e.getMessage());
         }

         List<SheetRowData> needowDataList = rowDataList.stream().filter(cbo -> {
            String rowIndex = cbo.getRowIndex();
            return !errorMap.containsKey(rowIndex);
         }).collect(Collectors.toList());

         //checkTemplateSync(sheetDataSetList, templateVO,i);
         //这里不除去默认的属性
         List<CodeClassifyTemplateAttrVO> attrVOS = templateVO.getAttributes();
         Map<Integer/**列号**/, String/**字段的名称**/> fieldIndexMap = new HashMap<>();

         Map<String/**中文名称**/, String/**英文名称**/> attrNameIdMap = attrVOS.stream().collect(Collectors.toMap(s -> s.getName(), t -> t.getId()));
         String idFieldName = attrVOS.stream().filter(s -> VciQueryWrapperForDO.ID_FIELD.equalsIgnoreCase(s.getId())).findFirst().orElseGet(() -> new CodeClassifyTemplateAttrVO()).getName();
         getFieldIndexMap(titleRowData, attrNameIdMap, fieldIndexMap);
         //先不用管属性是否都存在，先转换一下数据
         List<ClientBusinessObject> cboList = new ArrayList<>();
         String fullPath = getFullPath(classifyFullInfo);
         //我们需要获取到所有的下级分类的oid的路径，因为后面需要
         Map<String/**主键**/, String/**路径**/> childOidPathMap = getChildClassifyPathMap(classifyFullInfo, fullPath);
         excelToCbo(classifyFullInfo, fieldIndexMap, needowDataList, templateVO, cboList, fullPath, false);


         Map<String/**主键**/, CodeClassifyVO> classifyVOMap = Optional.ofNullable(childClassifyVOs).orElseGet(() -> new ArrayList<>()).stream().collect(Collectors.toMap(s -> s.getOid(), t -> t));
         classifyVOMap.put(classifyFullInfo.getCurrentClassifyVO().getOid(), classifyFullInfo.getCurrentClassifyVO());
         pathMap.put("#current#", classifyFullInfo.getCurrentClassifyVO());

         //判断编号在excel里本身就重复的
         Map<String, Long> idCountMap = cboList.stream().collect(Collectors.groupingBy(ClientBusinessObject::getId, Collectors.counting()));
         List<String> repeatIdList = new ArrayList<>();
         idCountMap.forEach((id, count) -> {
            if (count > 1) {
               repeatIdList.add(id);
            }
         });
         if (!CollectionUtils.isEmpty(repeatIdList)) {
            cboList.stream().filter(s -> repeatIdList.contains(s.getId())).map(s -> s.getAttributeValue(IMPORT_ROW_INDEX)).forEach(rowIndex -> {
               errorMap.put(rowIndex, "编号在当前excel中重复;");
            });
         }
         //我们需要判断这些分类的模板是不是一样的，只需要校验，不用获取
         //检查分类的路径
         checkClassifyPathInHistory(cboList, errorMap, pathMap, childOidPathMap);

         //检查规则
         Map<String/**分类主键**/, String/**规则主键**/> ruleOidMap = new ConcurrentHashMap<String, String>();
         List<String> unExistRuleClassifyOidList = new CopyOnWriteArrayList<>();
         checkRuleOidInHistory(classifyVOMap, ruleOidMap, unExistRuleClassifyOidList);
         //如果出错了，我们依然执行有效的数据，无效的数据写回到excel中

         //我们根据出错的分类的主键，去找行号
         if (!CollectionUtils.isEmpty(unExistRuleClassifyOidList)) {
            cboList.stream().forEach(cbo -> {
               if (unExistRuleClassifyOidList.contains(cbo.getAttributeValue(CODE_CLASSIFY_OID_FIELD))) {
                  String row_index = cbo.getAttributeValue(IMPORT_ROW_INDEX);
                  errorMap.put(row_index, errorMap.getOrDefault(row_index, "") + ";根据分类路径对应的分类，没有设置编码规则");
               }
            });
         }

         //判断必输项
         batchCheckRequiredAttrOnOrder(templateVO, cboList, errorMap);

         //有限校验编码是否存在
         batchCheckIdExistOnOrder(templateVO, cboList, errorMap);

         //boolean
         reSwitchBooleanAttrOnOrder(attrVOS, cboList);

         // æžšä¸¾çš„内容需要根据名称转换为枚举的值
         batchSwitchEnumAttrOnOrder(attrVOS, cboList, errorMap);

         batchSwitchReferAttrOnOrder(attrVOS, cboList, errorMap);
         //6.处理分类注入
         batchSwitchClassifyAttrOnOrder(attrVOS, cboList, classifyFullInfo,true);

         //设置默认值
         batchSwitchAttrDefault(attrVOS, cboList);
         //7.处理组合规则
         batchSwitchComponentAttrOnOrder(attrVOS, cboList);
         //3.判断关键属性
         CodeImportResultVO keyResultVO = batchCheckKeyAttrOnOrder(classifyFullInfo, templateVO, cboList);
         Set<String> selfRepeatRowIndexList = keyResultVO.getSelfRepeatRowIndexList();
         Set<String> keyAttrRepeatRowIndexList = keyResultVO.getKeyAttrRepeatRowIndexList();
         if (!CollectionUtils.isEmpty(selfRepeatRowIndexList)) {
            selfRepeatRowIndexList.stream().forEach(rowIndex -> {
               errorMap.put(rowIndex, errorMap.getOrDefault(rowIndex, "") + ";在当前excel文件中关键属性重复");
            });
         }
         if (!CollectionUtils.isEmpty(keyAttrRepeatRowIndexList)) {
            keyAttrRepeatRowIndexList.stream().forEach(rowIndex -> {
               errorMap.put(rowIndex, errorMap.getOrDefault(rowIndex, "") + ";关键属性与系统中的重复");
            });
         }
         //4.校验规则
         batchCheckVerifyOnOrder(attrVOS, cboList, errorMap);

         //6.时间的，必须统一为yyyy-MM-dd HH:mm:ss
         batchSwitchDateAttrOnOrder(attrVOS, cboList, errorMap);
         if (CollectionUtils.isEmpty(ruleOidMap.values())) {
            throw new VciBaseException("导入的数据所选择的分类都没有设置编码规则");
         }
         Map<String, CodeRuleVO> ruleVOMap = ruleService.listCodeRuleByIds(ruleOidMap.values(), true).stream().collect(Collectors.toMap(s -> s.getOid(), t -> t));
         //校验编码规则和码段是否正确
         Map<String, List<String>> ruleRowIndexMap = new ConcurrentHashMap<>();
         checkSecLengthInHistory(cboList, classifyVOMap, ruleVOMap, ruleOidMap, errorMap, ruleRowIndexMap);
         ruleRowIndexMap.keySet().parallelStream().forEach(ruleOid -> {
            List<String> rowIndexList = ruleRowIndexMap.get(ruleOid);
            List<ClientBusinessObject> thisCbos = cboList.stream().filter(cbo -> rowIndexList.contains(cbo.getAttributeValue(IMPORT_ROW_INDEX)) && !errorMap.containsKey(cbo.getAttributeValue(IMPORT_ROW_INDEX))).collect(Collectors.toList());
//我们需要先查询一下，内容是否已经存在
            if(!CollectionUtils.isEmpty(thisCbos)){
               List<String> existIds = new ArrayList<>();
               VciBaseUtil.switchCollectionForOracleIn(thisCbos).stream().forEach(cbos -> {
                  List<CodeAllCode> codeAllCodeList= codeAllCodeService.selectByWrapper(Wrappers.<CodeAllCode>query().lambda().eq(CodeAllCode::getCodeRuleOid, ruleOid)
                     .notIn(CodeAllCode::getId,cbos.stream().map(s -> s.getId()).collect(Collectors.toSet()).toArray(new String[0]))
                     .notIn(CodeAllCode::getLcStatus,CodeAllCodeLC.TASK_BACK.getValue() + "','" + CodeAllCodeLC.OBSOLETED.getValue())
                  );
                  existIds.addAll(Optional.ofNullable(codeAllCodeList).orElseGet(() -> new ArrayList<>()).stream().map(s -> {
                     String id = s.getId();
                     if (StringUtils.isBlank(id)) {
                        id = s.getId();
                     }
                     return id;
                  }).collect(Collectors.toList()));
               });
               List<String> existIdCbos = thisCbos.stream().filter(s -> {
                  String id = s.getId();
                  if (StringUtils.isBlank(id)) {
                     id = s.getAttributeValue("id");
                  }
                  return existIds.contains(id);
               }).map(s -> s.getAttributeValue(IMPORT_ROW_INDEX)).collect(Collectors.toList());
               if (!CollectionUtils.isEmpty(existIdCbos)) {
                  thisCbos = thisCbos.stream().filter(s -> {
                     String id = s.getId();
                     if (StringUtils.isBlank(id)) {
                        id = s.getAttributeValue("id");
                     }
                     return !existIdCbos.contains(id);
                  }).collect(Collectors.toList());
                  existIdCbos.stream().forEach(rowIndex -> {
                     errorMap.put(rowIndex, errorMap.getOrDefault(rowIndex, "") + ";【" + idFieldName + "】在系统中已经被占用");
                  });
               }
            }
         });

         Map<String, ClientBusinessObject> rowIndexCboMap = cboList.stream().filter(cbo -> cbo != null).collect(Collectors.toList()).stream().collect(Collectors.toMap(s -> s.getAttributeValue((IMPORT_ROW_INDEX)), t -> t));
         if (errorMap.size() > 0) {
            isExport=true;
            createRedisDatas(uuid + "-error", templateVO, rowIndexCboMap, dataSet, fieldIndexMap, errorMap, false);
         }
         createWriteExcelData(rowDataList, errorMap, new ArrayList<>(), titleRowData, shetNameMap, templateVO);
         List<ClientBusinessObject> needSaveCboList = cboList.stream().filter(cbo -> {
            String rowIndex = cbo.getAttributeValue(IMPORT_ROW_INDEX);
            return !errorMap.containsKey(rowIndex);
         }).collect(Collectors.toList());
         //相似校验
         Map<String, String> resembleMap = new HashMap<>();
         List<DataResembleVO> dataResembleVOS = new ArrayList<>();
         String btmtypeid = classifyFullInfo.getTopClassifyVO().getBtmTypeId();
         bathcResembleQuery(templateVO.getCodeclassifyoid(), templateVO, needSaveCboList, resembleMap, btmtypeid, dataResembleVOS);
         if (resembleMap.size() > 0) {
            if (!CollectionUtils.isEmpty(dataResembleVOS)) {
               bladeRedis.set(uuid + "-resemble-data", dataResembleVOS);
               createRedisDatas(uuid + "-resemble", templateVO, rowIndexCboMap, dataSet, fieldIndexMap, resembleMap, false);
            }
         }
         //生成class缓存
         Map<String, String> rowIndexClsOidMap = cboList.stream().filter(cbo -> cbo != null).collect(Collectors.toList()).stream().collect(Collectors.toMap(s -> s.getAttributeValue((IMPORT_ROW_INDEX)), t -> t.getAttributeValue(CODE_CLASSIFY_OID_FIELD)));
         createRedisByCodeClassify(uuid + "-class",templateVO,dataSet,fieldIndexMap,true);
         //获取编码，查询在系统中是否被其他的引用了
         //排除错误的，剩下正确的
         Map<String, String> newErrorMap = new HashMap<>();
         newErrorMap.putAll(resembleMap);
         newErrorMap.putAll(errorMap);
         //要把以上的错误的都抛出后，再继续处理时间和组合规则
         needSaveCboList = cboList.stream().filter(cbo -> {
            String rowIndex = cbo.getAttributeValue(IMPORT_ROW_INDEX);
            return !newErrorMap.containsKey(rowIndex);
         }).collect(Collectors.toList());
         if((errorMap.size()>0&&needSaveCboList.size()>0)||resembleMap.size()>0){
            isCreateUUid=true;
         }

         List<String> needRowIndexList = needSaveCboList.stream().filter(s -> errorMap.containsKey(s.getAttributeValue(IMPORT_ROW_INDEX))).map(s -> s.getAttributeValue(IMPORT_ROW_INDEX)).collect(Collectors.toList());
         if (isExport||newErrorMap.size() > 0) {
            createRedisDatas(uuid + "-ok", templateVO, rowIndexCboMap, dataSet, fieldIndexMap, newErrorMap, true);
         } else {
            List<BaseModel> dataCBOIdList=new ArrayList<>();
            //SessionInfo sessionInfo = VciBaseUtil.getCurrentUserSessionInfo();
            List<ClientBusinessObject> finalNeedSaveCboList = needSaveCboList;
            CodeClassifyTemplateVO finalTemplateVO = templateVO;
            ruleRowIndexMap.keySet().parallelStream().forEach(ruleOid -> {
               //VciBaseUtil.setCurrentUserSessionInfo(sessionInfo);
               List<String> rowIndexList = ruleRowIndexMap.get(ruleOid);
               List<ClientBusinessObject> thisCbos = finalNeedSaveCboList.stream().filter(cbo -> rowIndexList.contains(cbo.getAttributeValue(IMPORT_ROW_INDEX)) && !errorMap.containsKey(cbo.getAttributeValue(IMPORT_ROW_INDEX))).collect(Collectors.toList());
               List<BaseModel> dataCBOList=new ArrayList<>();
               thisCbos.stream().forEach(clientBusinessObject -> {
                  BaseModel baseModel=new BaseModel();
                  BeanUtil.convert(clientBusinessObject,baseModel);
                  //baseModel.setData(VciBaseUtil.objectToMapString(clientBusinessObject));
                  dataCBOList.add(baseModel);
                  dataCBOIdList.add(baseModel);
               });

               if (!CollectionUtils.isEmpty(thisCbos)) {
                  try {
                     productCodeService.productCodeAndSaveData(classifyFullInfo, finalTemplateVO, ruleVOMap.get(ruleOid), null, dataCBOList);
                  } catch (Throwable e) {
                     log.error("批量产生编码的时候出错了", e);
                     thisCbos.stream().forEach(cbo -> {
                        String rowIndex = cbo.getAttributeValue(IMPORT_ROW_INDEX);
                        errorMap.put(rowIndex, errorMap.getOrDefault(rowIndex, "") + ";系统错误，存储数据的时候出错了");
                     });

                  }
               }
            });
            if (errorMap.size() > 0) {
               isExport = true;
            }
            createWriteExcelData(rowDataList, errorMap, new ArrayList<>(), titleRowData, shetNameMap, finalTemplateVO);
            engineService.batchSaveSelectChar(templateVO, dataCBOIdList);
         }
      }
      String excelFileName="";
      if(isExport&&!CollectionUtils.isEmpty(shetNameMap)) {
         excelFileName = LocalFileUtil.getDefaultTempFolder() + File.separator + "错误信息.xls";
         WriteExcelOption eo = new WriteExcelOption();
         shetNameMap.forEach((shetName, errorDataList) -> {
            eo.addSheetDataList(shetName, errorDataList);
         });
         try {
            new File(excelFileName).createNewFile();
         } catch (IOException e) {
            throw new VciBaseException(LangBaseUtil.getErrorMsg(e));
         }
         ExcelUtil.writeDataToFile(excelFileName, eo);
      }
      CodeImProtRusultVO codeImProtRusultVO=new CodeImProtRusultVO();
      if(StringUtils.isNotBlank(excelFileName)) {
         codeImProtRusultVO.setFilePath(excelFileName);
         codeImProtRusultVO.setFileOid("");
      }
      if(isCreateUUid){
         codeImProtRusultVO.setRedisUuid(uuid);
      }

      return codeImProtRusultVO;
   }
   /*private void converBaseModels(List<ClientBusinessObject> clientBusinessObjects,List<BaseModel>dataCBOList){
      clientBusinessObjects.stream().forEach(clientBusinessObject -> {
         BaseModel baseModel=new BaseModel();
         BeanUtil.convert(clientBusinessObject,baseModel);
         Map<String,String> dataMap=new HashMap<>();
         clientBusinessObject.getHisAttrValList()
         baseModel.setData(VciBaseUtil.objectToMapString(baseModel));

         AttributeValue[] newAttributeValue=    clientBusinessObject.getNewAttrValList();
         dataCBOList.add(baseModel);
      });

   }*/
   /***
    * ä»Žexecl里构建对象
    * @param rowDataList
    * @param errorMap
    * @param needRowIndexList
    * @param titleRowData
    * @param shetNameMap
    * @param templateVO
    */
   private void createWriteExcelData(Collection<SheetRowData> rowDataList, Map<String,String> errorMap,
                             List<String> needRowIndexList, List<String> titleRowData, Map<String,List<WriteExcelData>> shetNameMap, CodeClassifyTemplateVO templateVO){
      List<WriteExcelData> errorDataList=new ArrayList<>();
      Map<String, SheetRowData> rowIndexDataMap = rowDataList.stream().filter(s -> !needRowIndexList.contains(s.getRowIndex())).collect(Collectors.toMap(s -> s.getRowIndex(), t -> t));
      errorDataList.add(new WriteExcelData(0,0,"错误信息"));
      for (int i = 0; i < titleRowData.size(); i++) {
         //错误信息在最后
         errorDataList.add(new WriteExcelData(0,i+1,titleRowData.get(i)));
      }
      Integer[] newRowIndex = new Integer[]{1};
      errorMap.forEach((index,error)->{
         //错误信息全部组合到一起
         SheetRowData rowData = rowIndexDataMap.getOrDefault(index, null);
         if(rowData!=null){
            errorDataList.add(new WriteExcelData(newRowIndex[0],0,error));
            rowData.getData().forEach((colIndex,value)->{
               errorDataList.add(new WriteExcelData(newRowIndex[0],colIndex+1,value));
            });
            newRowIndex[0]++;
         }
      });

      shetNameMap.put(templateVO.getName(),errorDataList);
   }

   /***
    *
    * @param currentTemplateVO
    * @param templateColumnVOMap
    */

   private void createTemplate(CodeClassifyTemplateVO currentTemplateVO,Map<String,List<ColumnVO>>templateColumnVOMap){

      List<CodeClassifyTemplateAttrVO> templateAttrVOS = currentTemplateVO.getAttributes().stream().filter(s ->
         !DEFAULT_ATTR_LIST.contains(s.getId())
            && StringUtils.isBlank(s.getComponentRule())
            && StringUtils.isBlank(s.getClassifyInvokeAttr())
            && (VciBaseUtil.getBoolean(s.getFormDisplayFlag()))
      ).collect(Collectors.toList());
      if(CollectionUtils.isEmpty(templateAttrVOS)){
         throw new VciBaseException("模板没有配置任何【表单显示】为【是】的属性");
      }
      List<ColumnVO> columnVOList=new ArrayList<>();

      ColumnVO errorMsgColumnVO=new ColumnVO();
      errorMsgColumnVO.setTitle("错误信息");
      errorMsgColumnVO.setField("errorMsg");
      columnVOList.add(errorMsgColumnVO);



      ColumnVO pathColumnVO=new ColumnVO();
      pathColumnVO.setTitle("分类路径");
      pathColumnVO.setField("codeclsfid");
      columnVOList.add(pathColumnVO);
      templateAttrVOS.stream().forEach(codetemplateAttr ->{
         String field=codetemplateAttr.getId();
         String name=codetemplateAttr.getName();
         ColumnVO columnVO=new ColumnVO();
         columnVO.setTitle(name);
         columnVO.setField(field);
         columnVO.setWidth(codetemplateAttr.getAttrTableWidth()==0?columnVO.getWidth():codetemplateAttr.getAttrTableWidth());
         columnVOList.add(columnVO);
      });

      templateColumnVOMap.put(currentTemplateVO.getOid(),columnVOList);
      log.info("模板"+currentTemplateVO.getName()+"对应的属性"+columnVOList.size());
   }

   /**
    * é”™è¯¯ä¿¡æ¯è¿”回excel
    * @param rowDataList æ‰€æœ‰çš„导入数据
    * @param errorMap é”™è¯¯çš„信息
    * @param needRowIndexList éœ€è¦å†™å…¥çš„数据的行号
    * @param titleRowData æ ‡é¢˜è¡Œ
    *
    * @return é”™è¯¯çš„excel文件，没有错误会返回空
    */
   private String returnErrorToExcel(Collection<SheetRowData> rowDataList,
                             Map<String,String> errorMap,
                             List<String> needRowIndexList,List<String> titleRowData){
      if(CollectionUtils.isEmpty(errorMap)){
         return "";
      }
      Map<String, SheetRowData> rowIndexDataMap = rowDataList.stream().filter(s -> !needRowIndexList.contains(s.getRowIndex())).collect(Collectors.toMap(s -> s.getRowIndex(), t -> t));
      List<WriteExcelData> errorDataList = new ArrayList<>();
      errorDataList.add(new WriteExcelData(0,0,"错误信息"));
      for (int i = 0; i < titleRowData.size(); i++) {
         //错误信息在最后
         errorDataList.add(new WriteExcelData(0,i+1,titleRowData.get(i)));
      }
      Integer[] newRowIndex = new Integer[]{1};
      errorMap.forEach((index,error)->{
         //错误信息全部组合到一起
         SheetRowData rowData = rowIndexDataMap.getOrDefault(index, null);
         if(rowData!=null){
            errorDataList.add(new WriteExcelData(newRowIndex[0],0,error));
            rowData.getData().forEach((colIndex,value)->{
               errorDataList.add(new WriteExcelData(newRowIndex[0],colIndex+1,value));
            });
            newRowIndex[0]++;
         }
      });
      String excelFileName = LocalFileUtil.getDefaultTempFolder() + File.separator + "错误信息.xls";
      WriteExcelOption eo = new WriteExcelOption(errorDataList);
      try {
         new File(excelFileName).createNewFile();
      } catch (IOException e) {
         throw new VciBaseException(LangBaseUtil.getErrorMsg(e));
      }
      ExcelUtil.writeDataToFile(excelFileName,eo);
      return excelFileName;
   }

   /**
    * æ ¡éªŒæ¨¡æ¿æ˜¯å¦ä¸ºåŒæ­¥çš„
    * @param sheetDataSetList excel里的内容
    * @param templateVO æ¨¡æ¿çš„信息
    */
   private void checkTemplateSync(List<SheetDataSet> sheetDataSetList,CodeClassifyTemplateVO templateVO,int i){
      String templateOidInExcel = "";
      String templateName="";
      if(!CollectionUtils.isEmpty(sheetDataSetList)
         && sheetDataSetList.size()>1 && !CollectionUtils.isEmpty(sheetDataSetList.get(sheetDataSetList.size()-1).getColName())){
         List<SheetRowData>  rowData=  sheetDataSetList.get(sheetDataSetList.size()-1).getRowData();
         templateName=rowData.get(i).getData().get(2);
         templateOidInExcel=rowData.get(i).getData().get(0);
         //templateOidInExcel = sheetDataSetList.get(sheetDataSetList.size()-1).getColName().get(sheetDataSetList.size()-i);
      }
       /* if(!CollectionUtils.isEmpty(sheetDataSetList)
                && sheetDataSetList.size()>1 && !CollectionUtils.isEmpty(sheetDataSetList.get(sheetDataSetList.size()-1).getColName())){
            List<SheetRowData>  rowData=  sheetDataSetList.get(sheetDataSetList.size()-1).getRowData();
            templateOidInExcel=rowData.get(i).getData().get(0);
           //templateOidInExcel = sheetDataSetList.get(sheetDataSetList.size()-1).getColName().get(sheetDataSetList.size()-i);
        }*/
      if(StringUtils.isBlank(templateOidInExcel) || !templateOidInExcel.equalsIgnoreCase(templateVO.getOid())){
         throw new VciBaseException("模板【"+templateName+"】中的数据获取的模版信息与当前模板不匹配，请确保excel文件里有【模板信息-请勿移动或删除】的工作表，且确保每次导入都是先下载的导入模板后添加的数据");
      }

   }


   /***
    * æ‰¹é‡å¤„理申请数据
    * @param orderDTO
    * @param templateVO
    * @param dataSet
    * @return
    */
   private String batchImportCodes(CodeOrderDTO orderDTO,CodeClassifyTemplateVO templateVO,SheetDataSet dataSet,Map<String,String> errorMap,boolean isEnumType){
      List<String> codeList=new ArrayList<>();
      CodeClassifyFullInfoBO classifyFullInfo = classifyService.getClassifyFullInfo(orderDTO.getCodeClassifyOid());
      //规则的主键需要去获取
      CodeRuleVO ruleVO = engineService.getCodeRuleByClassifyFullInfo(classifyFullInfo);
      //1.判断规则中除了流水码段，是否有其他码段
      engineService.checkSecValueOnOrder(ruleVO,orderDTO);
      List<SheetRowData> rowDataList = dataSet.getRowData();

      //除去默认的属性.还有只有表单显示的字段才导入
      List<CodeClassifyTemplateAttrVO> attrVOS = templateVO.getAttributes().stream().filter(s ->
         !DEFAULT_ATTR_LIST.contains(s.getId()) && VciBaseUtil.getBoolean(s.getFormDisplayFlag())
      ).collect(Collectors.toList());
      Map<Integer/**列号**/,String/**字段的名称**/> fieldIndexMap = new HashMap<>();
      List<String> titleRowData = dataSet.getColName();
      Map<String/**中文名称**/, String/**英文名称**/> attrNameIdMap = attrVOS.stream().collect(Collectors.toMap(s -> s.getName(), t -> t.getId().toLowerCase(Locale.ROOT),(o1, o2)->o2));
      getFieldIndexMap(titleRowData,attrNameIdMap,fieldIndexMap);

      //需要判断是否所有的属性都在模板上了
      List<CodeClassifyTemplateAttrVO> unExistAttrVOs = attrVOS.stream().filter(s -> !fieldIndexMap.containsValue(s.getId().toLowerCase(Locale.ROOT))
         && StringUtils.isBlank(s.getComponentRule()) && StringUtils.isBlank(s.getClassifyInvokeAttr())//组合规则和分类注入确实没给用户导出去
      ).collect(Collectors.toList());
      if(!CollectionUtils.isEmpty(unExistAttrVOs)){
         throw new VciBaseException("【" + unExistAttrVOs.stream().map(CodeClassifyTemplateAttrVO::getName) + "】这些属性在列表中没有找到");
      }
      List<ClientBusinessObject> cboList = new ArrayList<>();
      String fullPath = getFullPath(classifyFullInfo);
      excelToCbo(classifyFullInfo,fieldIndexMap,rowDataList,templateVO,cboList,fullPath,true);

      //都转换完了。需要批量检查
      //如果出错了，我们依然执行有效的数据，无效的数据写回到excel中
      //2.判断必输项。。需要全部的属性，如果是必输，但是表单里面不显示的，只能是分类注入或者组合规则
      batchCheckRequiredAttrOnOrder(templateVO,cboList,errorMap);
      //3.判断关键属性
      CodeImportResultVO keyResultVO = batchCheckKeyAttrOnOrder(classifyFullInfo, templateVO, cboList);
      Set<String> selfRepeatRowIndexList = keyResultVO.getSelfRepeatRowIndexList();
      Set<String> keyAttrRepeatRowIndexList = keyResultVO.getKeyAttrRepeatRowIndexList();
      if(!CollectionUtils.isEmpty(selfRepeatRowIndexList)){
         selfRepeatRowIndexList.stream().forEach(rowIndex->{
            errorMap.put(rowIndex,errorMap.getOrDefault(rowIndex,"") + ";在当前处理的数据文件中关键属性重复" );
         });
      }
      if(!CollectionUtils.isEmpty(keyAttrRepeatRowIndexList)){
         keyAttrRepeatRowIndexList.stream().forEach(rowIndex->{
            errorMap.put(rowIndex,errorMap.getOrDefault(rowIndex,"") + ";关键属性与系统中的重复" );
         });
      }
      //分类注入
      batchSwitchClassifyAttrOnOrder(attrVOS,cboList,classifyFullInfo,false);
      //boolean
      reSwitchBooleanAttrOnOrder(attrVOS,cboList);
      //4.校验规则
      batchCheckVerifyOnOrder(attrVOS, cboList,errorMap);
      if(isEnumType) {//是否需要校验枚举/参照
         //5.校验枚举是否正确
         batchSwitchEnumAttrOnOrder(attrVOS, cboList, errorMap);
         //7.处理参照的情况
         batchSwitchReferAttrOnOrder(attrVOS,cboList,errorMap);
      }
      //6.时间格式的验证
      //6.时间的，必须统一为yyyy-MM-dd HH:mm:ss
      batchSwitchDateAttrOnOrder(attrVOS,cboList,errorMap);
      //最后弄组合规则
      batchSwitchComponentAttrOnOrder(attrVOS,cboList);
      String uuid=VciBaseUtil.getPk();
      Map<String, ClientBusinessObject> rowIndexCboMap = cboList.stream().filter(cbo -> cbo != null).collect(Collectors.toList()).stream().collect(Collectors.toMap(s -> s.getAttributeValue((IMPORT_ROW_INDEX)), t -> t));

      if(errorMap.size()>0) {
         createRedisDatas(uuid + "-error",templateVO, rowIndexCboMap, dataSet, fieldIndexMap, errorMap,false);
      }
      boolean isCreateUUid=false;
      List<ClientBusinessObject> needSaveCboList = cboList.stream().filter(cbo -> {
         String rowIndex = cbo.getAttributeValue(IMPORT_ROW_INDEX);
         return !errorMap.containsKey(rowIndex);
      }).collect(Collectors.toList());
      //相似校验
      Map<String,String>resembleMap=new HashMap<>();
      List<DataResembleVO> dataResembleVOS=new ArrayList<>();
      String btmtypeid= classifyFullInfo.getTopClassifyVO().getBtmTypeId();
      bathcResembleQuery(orderDTO.getCodeClassifyOid(),templateVO,needSaveCboList,resembleMap,btmtypeid,dataResembleVOS);
      if(resembleMap.size()>0) {
         isCreateUUid=true;
         if(!CollectionUtils.isEmpty(dataResembleVOS)) {
            bladeRedis.set(uuid + "-resemble-data", dataResembleVOS);
            createRedisDatas(uuid + "-resemble",templateVO, rowIndexCboMap, dataSet, fieldIndexMap, resembleMap, false);
         }
      }
      //排除错误的，剩下正确的
      Map<String,String> newErrorMap=new HashMap<>();
      newErrorMap.putAll(resembleMap);
      newErrorMap.putAll(errorMap);
      needSaveCboList = cboList.stream().filter(cbo -> {
         String rowIndex = cbo.getAttributeValue(IMPORT_ROW_INDEX);
         return !newErrorMap.containsKey(rowIndex);
      }).collect(Collectors.toList());
      if((errorMap.size()>0&&needSaveCboList.size()>0)||resembleMap.size()>0){
         isCreateUUid=true;
      }
      createRedisByCodeClassify(uuid + "-class",templateVO,dataSet,fieldIndexMap,false);
      if(newErrorMap.size()>0) {
         createRedisDatas(uuid + "-ok",templateVO, rowIndexCboMap, dataSet, fieldIndexMap, newErrorMap,true);
      }else {
         uuid="";

         //要把以上的错误的都抛出后，再继续处理时间和组合规则
         needSaveCboList = cboList.stream().filter(cbo -> {
            String rowIndex = cbo.getAttributeValue(IMPORT_ROW_INDEX);
            return !newErrorMap.containsKey(rowIndex);
         }).collect(Collectors.toList());

         if (!CollectionUtils.isEmpty(needSaveCboList)) {
            //9.我们处理业务数据
            //生成编码的内容
            List<String> dataCBOIdList=new ArrayList<>();
            List<BaseModel> dataCBOList=new ArrayList<>();
            cboList.stream().forEach(clientBusinessObject -> {
               BaseModel baseModel=new BaseModel();
               BeanUtil.convert(clientBusinessObject,baseModel);
               //baseModel.setData(VciBaseUtil.objectToMapString(clientBusinessObject));
               dataCBOList.add(baseModel);
               dataCBOIdList.add(baseModel.getOid());
            });
            try {
               codeList = productCodeService.productCodeAndSaveData(classifyFullInfo,templateVO,ruleVO, orderDTO.getSecDTOList(),dataCBOList);
               //如果是编码生成失败，则直接就失败了，其他的判断出来有错误的我们都统一返回到excel里面
               engineService.batchSaveSelectChar(templateVO, dataCBOList);
            } catch (Exception e) {
               e.printStackTrace();
               log.error("批了申请时失败");
            }
         }
      }
      if(!isCreateUUid){
         return uuid="";
      }
      return uuid;
   }

   @Override
   public List<CodeImportTemplateVO> gridclassifys(String redisOid) {
      List<CodeImportTemplateVO> codeImportTemplateVOs=new ArrayList<>();
      VciBaseUtil.alertNotNull(redisOid,"分类",redisOid,"分类缓存主键");
      List<CodeImportTemplateVO> redisServiceCacheObjects=bladeRedis.get(redisOid);
      if(redisServiceCacheObjects!=null){
         codeImportTemplateVOs=  redisServiceCacheObjects;
      }
      return codeImportTemplateVOs;
   }

   /***
    * ä»Žç¼“存里获取到需要导入的相关数据
    * @param codeClssifyOid
    * @param redisOid
    * @return
    */
   @Override
   public DataGrid<Map<String, String>> gridDatas(String codeClssifyOid, String redisOid) {
      VciBaseUtil.alertNotNull(redisOid,"导入相似数据",redisOid,"数据缓存主键");
      List<CodeImprotDataVO> codeImprotDataVOs = bladeRedis.get(redisOid+"-"+codeClssifyOid);
//      redisService.getCacheList(redisOid+"-"+codeClssifyOid);
      CodeImprotDataVO codeImprotDataVO=new CodeImprotDataVO();
      if(!CollectionUtils.isEmpty(codeImprotDataVOs)){
         if(StringUtils.isNotBlank(codeClssifyOid)){
            Map<String/**分类名称**/, CodeImprotDataVO/**英文名称**/> codeClassifyDatasMap = codeImprotDataVOs.stream().collect(Collectors.toMap(s -> s.getCodeClassifyOid(), t -> t,(o1, o2)->o2));
            if(codeClassifyDatasMap.containsKey(codeClssifyOid)){
               codeImprotDataVO= codeClassifyDatasMap.get(codeClssifyOid);
            }else{
               codeImprotDataVO=  codeImprotDataVOs.get(0);
            }
         }
      }
      DataGrid<Map<String, String>> dataGrid = new DataGrid<>();
      List<Map<String, String>> dataList = new ArrayList<>();
      if(codeImprotDataVO!=null){
         dataList= codeImprotDataVO.getDatas();
      }
      dataGrid.setData(dataList);
      if (!CollectionUtils.isEmpty(dataList)) {
         dataGrid.setTotal(dataList.size());
      }
      return dataGrid;
   }

   /**
    *
    * @param oid
    * @param redisOid
    * @return
    */
   @Override
   public DataGrid<Map<String,String>> gridRowResemble(String oid,String redisOid){
      VciBaseUtil.alertNotNull(redisOid,"导入相似数据",redisOid,"数据缓存主键");
      List<DataResembleVO> codeImprotDataVOs = bladeRedis.get(redisOid);;
      DataGrid<Map<String, String>> dataGrid = new DataGrid<>();
      List<Map<String, String>> dataList = new ArrayList<>();

      if(!CollectionUtils.isEmpty(codeImprotDataVOs)){
         Map<String/**分类名称**/, DataResembleVO/**数据对象**/> rowResembleDataMap = codeImprotDataVOs.stream().collect(Collectors.toMap(s -> s.getOid(), t -> t,(o1, o2)->o2));
         if(rowResembleDataMap.containsKey(oid)){
            DataResembleVO dataResembleVO=  rowResembleDataMap.get(oid);
            dataList= dataResembleVO.getDataList();
         }
      }

      dataGrid.setData(dataList);
      if (!CollectionUtils.isEmpty(dataList)) {
         dataGrid.setTotal(dataList.size());
      }
      return dataGrid;
   }

   /**
    * å¯¼å‡ºä¸»é¢˜åº“的数据
    *
    * @param exportAttrDTO å¯¼å‡ºç›¸å…³çš„配置，必须要有主题库分类的主键
    * @return å¯¼å‡ºçš„excel的文件
    */
   @Override
   public String exportCode(CodeExportAttrDTO exportAttrDTO) {
      VciBaseUtil.alertNotNull(exportAttrDTO,"导出的配置",exportAttrDTO.getCodeClassifyOid(),"主题库分类的主键");
      CodeClassifyFullInfoBO classifyFullInfo = classifyService.getClassifyFullInfo(exportAttrDTO.getCodeClassifyOid());
      //获取最新的模板
      CodeClassifyTemplateVO templateVO = engineService.getUsedTemplateByClassifyOid(exportAttrDTO.getCodeClassifyOid());
      //先查询数据
      String btmTypeId = classifyFullInfo.getTopClassifyVO().getBtmTypeId();
      Map<String, String> conditionMap = exportAttrDTO.getConditionMap();
      if(conditionMap == null){
         conditionMap = new HashMap<>();
      }
      if(conditionMap.containsKey(VciQueryWrapperForDO.OID_FIELD)){
         conditionMap.put(VciQueryWrapperForDO.OID_FIELD,QueryOptionConstant.IN + "(" + VciBaseUtil.toInSql(conditionMap.get(VciQueryWrapperForDO.OID_FIELD)) + ")");
      }
      PageHelper pageHelper = new PageHelper(exportAttrDTO.getLimit()==null?-1:exportAttrDTO.getLimit());
      pageHelper.setPage(exportAttrDTO.getPage()==null?1:exportAttrDTO.getPage());
      pageHelper.setSort(exportAttrDTO.getSort());
      pageHelper.setOrder(exportAttrDTO.getOrder());

      pageHelper.addDefaultDesc("createTime");
      conditionMap.put("codeclsfpath","*" + exportAttrDTO.getCodeClassifyOid() + "*");
      conditionMap.put("lastr", "1");
      conditionMap.put("lastv", "1");

      String countSql = "select count(*) from " + VciBaseUtil.getTableName(btmTypeId) +" where 1=1" +
         " and lastr = '1'" +
         " and lastv='1'" +
         " and codeclsfpath like '%" + exportAttrDTO.getCodeClassifyOid() + "%'";

      //先查询总数
      int total = 0;
      if(exportAttrDTO.getEndPage()!=null && exportAttrDTO.getEndPage()>0
         &&exportAttrDTO.getPage() !=null && exportAttrDTO.getPage() >0
         &&exportAttrDTO.getEndPage()>exportAttrDTO.getPage()){
         //从多少页到多少页的查询方式，
         for(int i = exportAttrDTO.getPage() ;i <= exportAttrDTO.getEndPage();i++){
            PageHelper thisPage = new PageHelper(exportAttrDTO.getLimit()==null?-1:exportAttrDTO.getLimit());
            thisPage.setPage(exportAttrDTO.getPage()==null?1:exportAttrDTO.getPage());
            thisPage.setSort(exportAttrDTO.getSort());
            thisPage.setOrder(exportAttrDTO.getOrder());
            thisPage.addDefaultDesc("createTime");

            total += commonsMapper.queryCountBySql(countSql);
         }
      }else{

         total = commonsMapper.queryCountBySql(countSql);
      }
      List<String> selectFieldList = new ArrayList<>();
      if(!CollectionUtils.isEmpty(exportAttrDTO.getAttrIdIndexMap())){
         selectFieldList = exportAttrDTO.getAttrIdIndexMap().values().stream().map(s->s.toLowerCase(Locale.ROOT)).collect(Collectors.toList());
      }else{
         selectFieldList = templateVO.getAttributes().stream().filter(s->VciBaseUtil.getBoolean(s.getFormDisplayFlag())
            ||VciBaseUtil.getBoolean(s.getTableDisplayFlag())).map(s->s.getId().toLowerCase(Locale.ROOT)).collect(Collectors.toList());
      }
      //参照让平台直接查询就行
      List<String> finalSelectFieldList = selectFieldList;
      List<CodeClassifyTemplateAttrVO> referAttrVOs = templateVO.getAttributes().stream().filter(
         s -> StringUtils.isNotBlank(s.getReferBtmId())
            &&
            (finalSelectFieldList.size() ==0 || finalSelectFieldList.contains(s.getId().toLowerCase(Locale.ROOT)))
      ).collect(Collectors.toList());
      if(!CollectionUtils.isEmpty(referAttrVOs)){
         for (int i = 0; i < referAttrVOs.size(); i++) {
            selectFieldList.add(referAttrVOs.get(i).getId() + ".name");
         }
      }
      List<String> excelNameList = new CopyOnWriteArrayList<>();
      String tempFolder = LocalFileUtil.getDefaultTempFolder();
      if(total>EXPORT_LIMIT){
         //分组来执行
         int queryCount = (total-total%EXPORT_LIMIT)/EXPORT_LIMIT;
         if(total%EXPORT_LIMIT>0){
            queryCount = queryCount + 1;
         }
         List<Integer> indexList = new ArrayList<>();
         for (int i = 0; i <queryCount ; i++) {
            indexList.add(i);
         }
         Map<String, String> finalConditionMap = conditionMap;
         //并行查询看看
         SessionInfo sessionInfo = VciBaseUtil.getCurrentUserSessionInfo();
         indexList.stream().forEach(index->{
            //线程的方式，所以需要设置当前用户
            VciBaseUtil.setCurrentUserSessionInfo(sessionInfo);
            PageHelper thisPage = new PageHelper(EXPORT_LIMIT);
            thisPage.setPage(index+1);
            thisPage.setSort(exportAttrDTO.getSort());
            thisPage.setOrder(exportAttrDTO.getOrder());
            thisPage.addDefaultDesc("createTime");
            selectDataAndExportExcelName(btmTypeId, finalConditionMap,thisPage,finalSelectFieldList,
               classifyFullInfo,templateVO,exportAttrDTO,
               excelNameList,tempFolder,index);
         });
      }else{
         pageHelper.setLimit(total);
         pageHelper.setPage(1);
         selectDataAndExportExcelName(btmTypeId,conditionMap,pageHelper,finalSelectFieldList,
            classifyFullInfo,templateVO,exportAttrDTO,
            excelNameList,tempFolder,1);
      }
      if(excelNameList.size() ==0){
         throw new VciBaseException("没有数据可以被导出");
      }
      if(excelNameList.size() == 1){
         return excelNameList.get(0);
      }
      //是多个，我们需要打成压缩包
      String zipFileName = LocalFileUtil.getDefaultTempFolder() + File.separator + classifyFullInfo.getCurrentClassifyVO().getId() + "_" + classifyFullInfo.getCurrentClassifyVO().getName() + "_导出_" + excelNameList.size()+".zip";
      VciZipUtil zipUtil = new VciZipUtil();
      File file = new File(tempFolder);
      zipUtil.addFileToZip(file,zipFileName);
      File[] files = file.listFiles();
      for (int i = 0; i < files.length; i++) {
         LocalFileUtil.deleteTempFile(files[i],false);
      }
      LocalFileUtil.deleteTempFile(file,true);
      return zipFileName;
   }

   /**
    * æŸ¥è¯¢æ•°æ®å¹¶å¯¼å‡ºåˆ°excel
    * @param btmTypeId ä¸šåŠ¡ç±»åž‹
    * @param conditionMap æŸ¥è¯¢æ¡ä»¶
    * @param pageHelper åˆ†é¡µ
    * @param selectFieldList æŸ¥è¯¢çš„字段
    * @param classifyFullInfo åˆ†ç±»çš„全部信息
    * @param templateVO æ¨¡æ¿çš„信息
    * @param exportAttrDTO å¯¼å‡ºçš„属性
    * @param excelNameList excel的文件名称
    * @param tempFolder ä¸´æ—¶æ–‡ä»¶å¤¹
    * @param excelIndex excel的顺序
    */
   private void selectDataAndExportExcelName(String btmTypeId, Map<String, String> conditionMap, PageHelper pageHelper, List<String> selectFieldList,
                                   CodeClassifyFullInfoBO classifyFullInfo, CodeClassifyTemplateVO templateVO, CodeExportAttrDTO exportAttrDTO,
                                   List<String> excelNameList, String tempFolder,
                                   Integer excelIndex) {
      DataGrid<Map<String, String>> dataGrid = engineService.queryGrid(btmTypeId, templateVO, conditionMap, pageHelper);
      if(dataGrid == null || CollectionUtils.isEmpty(dataGrid.getData())){
         return;
      }
      //转换数据
      List<Map<String, String>> dataMap = dataGrid.getData();
      //封装查询出来的数据
      engineService.wrapperData(dataMap, templateVO, selectFieldList,false);
      //modify by weidy@2022-09-27
      //因为在列表和表单的显示的时候，我们的开关类型页面会处理，但是在导出的时候，我们需要将true和false都替换成中文
      engineService.wrapperBoolean(dataMap,templateVO);
      Map<String, CodeClassifyTemplateAttrVO> attrVOMap = templateVO.getAttributes().stream().filter(s->selectFieldList.contains(s.getId().toLowerCase(Locale.ROOT))).collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t));
      Map<Integer, String> attrIdIndexMap = exportAttrDTO.getAttrIdIndexMap();
      if (CollectionUtils.isEmpty(attrIdIndexMap)) {
         attrIdIndexMap = templateVO.getAttributes().stream().filter(s->selectFieldList.contains(s.getId().toLowerCase(Locale.ROOT))).collect(Collectors.toMap(s -> s.getOrderNum(), t -> t.getId()));
      }
      List<Integer> indexList = attrIdIndexMap.keySet().stream().sorted().collect(Collectors.toList());

      String excelName = tempFolder + File.separator +
         classifyFullInfo.getCurrentClassifyVO().getId() + "_" + classifyFullInfo.getCurrentClassifyVO().getName() + "_导出_" + excelIndex + ".xls";
      try {
         new File(excelName).createNewFile();
      } catch (Throwable e) {
         throw new VciBaseException(LangBaseUtil.getErrorMsg(e), new String[]{excelName}, e);
      }
      excelNameList.add(excelName);
      List<WriteExcelData> excelDataList = new ArrayList<>();
      Workbook workbook = new HSSFWorkbook();
      for (int i = 0; i < indexList.size(); i++) {
         String attrId = attrIdIndexMap.get(indexList.get(i)).toLowerCase(Locale.ROOT);
         if (attrVOMap.containsKey(attrId)) {
            CodeClassifyTemplateAttrVO attrVO = attrVOMap.get(attrId);
            Object text = attrVO.getName();
            text = exportKeyAndRequired(workbook,attrVO,text);
            WriteExcelData excelData = new WriteExcelData(0, i, text);
            if(text instanceof RichTextString){
               excelData.setFontColor(String.valueOf(HSSFColor.HSSFColorPredefined.RED.getIndex()));
            }
            excelDataList.add(excelData);
         }
      }
      final Integer[] rowIndex = {0};
      Map<Integer, String> finalAttrIdIndexMap = attrIdIndexMap;
      dataMap.stream().forEach(data -> {
         rowIndex[0]++;
         for (int i = 0; i < indexList.size(); i++) {
            Integer index = indexList.get(i);
            String attrId = finalAttrIdIndexMap.get(index).toLowerCase(Locale.ROOT);
            if (attrVOMap.containsKey(attrId)) {
               CodeClassifyTemplateAttrVO attrVO = attrVOMap.get(attrId);
               if (StringUtils.isNotBlank(attrVO.getEnumId()) || StringUtils.isNotBlank(attrVO.getEnumString())) {
                  attrId = attrId + "Text";
               }
               if (StringUtils.isNotBlank(attrVO.getReferBtmId()) || StringUtils.isNotBlank(attrVO.getReferConfig())) {
                  attrId = attrId + "name";
               }
               if(VciQueryWrapperForDO.LC_STATUS_FIELD.equalsIgnoreCase(attrId)){
                  attrId = VciQueryWrapperForDO.LC_STATUS_FIELD_TEXT.toLowerCase(Locale.ROOT);
               }
               excelDataList.add(new WriteExcelData(rowIndex[0], i, data.getOrDefault(attrId, "")));
            }
         }
      });
      WriteExcelOption excelOption = new WriteExcelOption(excelDataList);
      ExcelUtil.writeDataToFile(excelName, excelOption);
   }

   @Override
   public R batchImportData(List<CodeImprotSaveDatVO> codeImprotSaveDatVOList, String classifyAttr, boolean isImprot) {
      WriteExcelOption eo = new WriteExcelOption();
      AtomicBoolean success= new AtomicBoolean(true);
      codeImprotSaveDatVOList.stream().forEach(codeImprotSaveDatVO -> {
         List<SheetRowData> rowDataList = new ArrayList<>();
         List<ClientBusinessObject>cboList=new ArrayList<>();
         List<String> colList=codeImprotSaveDatVO.getClos();
         CodeOrderDTO orderDTO= codeImprotSaveDatVO.getOrderDTO();
         List<Map<String, String>> dataList= codeImprotSaveDatVO.getDataList();
         Map<Integer, String> fieldIndexMap = new HashMap();
         for (int i=0;i<dataList.size();i++){
            SheetRowData sheetRowData=new SheetRowData();
            Map<String,String> dataMap= dataList.get(i);
            Map<Integer, String> data = new HashMap();
            final int[] colIndex = {0};
            Map<Integer, String> finalFieldIndexMap = new HashMap<>();
            dataMap.forEach((field, value)->{
               if(!ROW_INDEX.equalsIgnoreCase(field) && !ERROR_MSG.equalsIgnoreCase(field)){
                  data.put(colIndex[0],value);
                  finalFieldIndexMap.put(colIndex[0]++,field);
               }
            });
            fieldIndexMap=finalFieldIndexMap;
            sheetRowData.setData(data);
            sheetRowData.setRowIndex(i+"");
            rowDataList.add(sheetRowData);
         }
         CodeClassifyFullInfoBO classifyFullInfo = classifyService.getClassifyFullInfo(orderDTO.getCodeClassifyOid());
         log.info("分类："+classifyFullInfo.getCurrentClassifyVO().getName()+"数据:"+codeImprotSaveDatVO.getDataList().size());

         // CodeClassifyTemplateVO codeClassifyTemplateVO=   engineService.getUsedTemplateByClassifyOid(orderDTO.getCodeClassifyOid());
         CodeClassifyTemplateVO codeClassifyTemplateVO=  templateService.getObjectHasAttrByOid(orderDTO.getTemplateOid());
         //规则的主键需要去获取
         CodeRuleVO ruleVO = engineService.getCodeRuleByClassifyFullInfo(classifyFullInfo);
         //除去默认的属性.还有只有表单显示的字段才导入
         List<CodeClassifyTemplateAttrVO> attrVOS = codeClassifyTemplateVO.getAttributes().stream().filter(s ->
            !DEFAULT_ATTR_LIST.contains(s.getId()) && VciBaseUtil.getBoolean(s.getFormDisplayFlag())
         ).collect(Collectors.toList());
         String fullPath = getFullPath(classifyFullInfo);
         excelToCbo(classifyFullInfo,fieldIndexMap,rowDataList, codeClassifyTemplateVO,cboList,fullPath,!isImprot);
         Map<String,String> errorMap=new HashMap<>();
         Map<String/**路径**/, CodeClassifyVO> pathMap=new HashMap<>() ;
         //校验编码规则和码段是否正确
         Map<String, List<String>> ruleRowIndexMap = new ConcurrentHashMap<>();
         Map<String, CodeRuleVO> ruleVOMap =new ConcurrentHashMap<>();
         if(isImprot) {
            Map<String/**主键**/, String/**路径**/> childOidPathMap = getChildClassifyPathMap(classifyFullInfo, fullPath);
            //都转换完了。需要批量检查
            //找所有的分类路径,需要校验路径是否正确，是否都在当前的分类的下级
            List<CodeClassifyVO> childClassifyVOs = classifyService.listChildrenClassify(orderDTO.getCodeClassifyOid(), true, classifyAttr, true);
            pathMap = Optional.ofNullable(childClassifyVOs).orElseGet(() -> new ArrayList<>()).stream().collect(Collectors.toMap(s -> s.getPath().startsWith("#") ? s.getPath().substring(1) : s.getPath(), t -> t));
            Map<String/**主键**/, CodeClassifyVO> classifyVOMap = Optional.ofNullable(childClassifyVOs).orElseGet(() -> new ArrayList<>()).stream().collect(Collectors.toMap(s -> s.getOid(), t -> t));
            classifyVOMap.put(classifyFullInfo.getCurrentClassifyVO().getOid(), classifyFullInfo.getCurrentClassifyVO());
            pathMap.put("#current#", classifyFullInfo.getCurrentClassifyVO());
            //我们需要判断这些分类的模板是不是一样的，只需要校验，不用获取
            //检查分类的路径
            checkClassifyPathInHistory(cboList, errorMap, pathMap, childOidPathMap);
            //检查规则
            Map<String/**分类主键**/, String/**规则主键**/> ruleOidMap = new ConcurrentHashMap<String, String>();
            List<String> unExistRuleClassifyOidList = new CopyOnWriteArrayList<>();
            checkRuleOidInHistory(classifyVOMap, ruleOidMap, unExistRuleClassifyOidList);
            ruleVOMap = ruleService.listCodeRuleByIds(ruleOidMap.values(), true).stream().collect(Collectors.toMap(s -> s.getOid(), t -> t));

            checkSecLengthInHistory(cboList, classifyVOMap, ruleVOMap, ruleOidMap, errorMap, ruleRowIndexMap);
         }

         //分类注入
         batchSwitchClassifyAttrOnOrder(attrVOS,cboList,classifyFullInfo,isImprot);
         //boolean
         reSwitchBooleanAttrOnOrder(attrVOS,cboList);
         //4.校验规则
         batchCheckVerifyOnOrder(attrVOS, cboList,errorMap);
         //5.校验枚举是否正确
         batchSwitchEnumAttrOnOrder(attrVOS, cboList, errorMap);
         //7.处理参照的情况
         batchSwitchReferAttrOnOrder(attrVOS,cboList,errorMap);
         //6.时间格式的验证
         //6.时间的，必须统一为yyyy-MM-dd HH:mm:ss
         batchSwitchDateAttrOnOrder(attrVOS,cboList,errorMap);
         //设置默认值
         batchSwitchAttrDefault(attrVOS, cboList);
         //最后弄组合规则
         batchSwitchComponentAttrOnOrder(attrVOS,cboList);
         //3.判断关键属性
         CodeImportResultVO keyResultVO = batchCheckKeyAttrOnOrder(classifyFullInfo, codeClassifyTemplateVO, cboList);
         Set<String> selfRepeatRowIndexList = keyResultVO.getSelfRepeatRowIndexList();
         Set<String> keyAttrRepeatRowIndexList = keyResultVO.getKeyAttrRepeatRowIndexList();
         if(!CollectionUtils.isEmpty(keyAttrRepeatRowIndexList)){
            keyAttrRepeatRowIndexList.stream().forEach(rowIndex->{
               errorMap.put(rowIndex,errorMap.getOrDefault(rowIndex,"") + ";关键属性与系统中的重复" );
            });
         }
         //4.校验规则
         batchCheckVerifyOnOrder(attrVOS, cboList,errorMap);

         if(isImprot){
            List<ClientBusinessObject> needSaveCboList = cboList.stream().filter(cbo -> {
               String rowIndex = cbo.getAttributeValue(IMPORT_ROW_INDEX);
               return !errorMap.containsKey(rowIndex);
            }).collect(Collectors.toList());
            List<ClientBusinessObject> finalNeedSaveCboList = needSaveCboList;
            Map<String, CodeRuleVO> finalRuleVOMap = ruleVOMap;
            ruleRowIndexMap.keySet().parallelStream().forEach(ruleOid -> {
               List <BaseModel>dataCBOList=new CopyOnWriteArrayList<>();
               List<String> rowIndexList = ruleRowIndexMap.get(ruleOid);
               List<ClientBusinessObject> thisCbos = needSaveCboList.stream().filter(cbo -> rowIndexList.contains(cbo.getAttributeValue(IMPORT_ROW_INDEX)) && !errorMap.containsKey(cbo.getAttributeValue(IMPORT_ROW_INDEX))).collect(Collectors.toList());
               if (!CollectionUtils.isEmpty(thisCbos)) {
                  thisCbos.stream().forEach(clientBusinessObject -> {
                     BaseModel baseModel = new BaseModel();
                     BeanUtil.convert(clientBusinessObject, baseModel);
                     dataCBOList.add(baseModel);
                  });
                  try {
                     productCodeService.productCodeAndSaveData(classifyFullInfo, codeClassifyTemplateVO, finalRuleVOMap.get(ruleOid), null, dataCBOList);
                  } catch (Throwable e) {
                     //success=false;
                     log.error("批量产生编码的时候出错了", e);
                     thisCbos.stream().forEach(cbo -> {
                        String rowIndex = cbo.getAttributeValue(IMPORT_ROW_INDEX);
                        errorMap.put(rowIndex, errorMap.getOrDefault(rowIndex, "") + ";系统错误，存储数据的时候出错了:"+e.getMessage());
                     });
                  }
               }
               engineService.batchSaveSelectChar(codeClassifyTemplateVO, dataCBOList);
            });
         }else {
            List<BaseModel> dataCBOList=new ArrayList<>();
            List<ClientBusinessObject> needSaveCboList = cboList.stream().filter(cbo -> {
               String rowIndex = cbo.getAttributeValue(IMPORT_ROW_INDEX);
               return !errorMap.containsKey(rowIndex);
            }).collect(Collectors.toList());
            log.info("分类：" + classifyFullInfo.getCurrentClassifyVO().getName() + "数据:" + needSaveCboList.size());
            if (!CollectionUtils.isEmpty(needSaveCboList)) {
               needSaveCboList.stream().forEach(clientBusinessObject -> {
                  BaseModel baseModel = new BaseModel();
                  BeanUtil.convert(clientBusinessObject, baseModel);
                  dataCBOList.add(baseModel);
               });
               try {
                  productCodeService.productCodeAndSaveData(classifyFullInfo, codeClassifyTemplateVO, ruleVO, orderDTO.getSecDTOList(), dataCBOList);
               } catch (Exception e) {
                  log.error("批量产生编码的时候出错了", e);
                  needSaveCboList.stream().forEach(cbo -> {
                     String rowIndex = cbo.getAttributeValue(IMPORT_ROW_INDEX);
                     errorMap.put(rowIndex, errorMap.getOrDefault(rowIndex, "") + ";系统错误，存储数据的时候出错了:"+e.getMessage());
                  });
               }
               //如果是编码生成失败，则直接就失败了，其他的判断出来有错误的我们都统一返回到excel里面
               engineService.batchSaveSelectChar(codeClassifyTemplateVO, dataCBOList);
            }
         }
         if(errorMap.size()>0) {
            success.set(false);
            LinkedList<WriteExcelData> excelDataList = new LinkedList<>();
            excelDataList.add(new WriteExcelData(0, 0, "错误信息"));
            final int[] index = {1};
            errorMap.forEach((key,v)->{
               excelDataList.add(new WriteExcelData(index[0]++, 0, "第"+(Integer.parseInt(key)+1)+"行数据："+v));
            });
            eo.addSheetDataList(codeClassifyTemplateVO.getName() + "导入模板", excelDataList);
         }
      });
      if(!success.get()){
         String excelName = LocalFileUtil.getDefaultTempFolder() + File.separator + (isImprot?"批量历史错误信息.xls":"批量申请错误信息.xls");
         ExcelUtil.writeDataToFile(excelName,eo);
         return  R.fail(excelName);
      }else {
         return R.success(isImprot ? "批量历史导入成功" : "批量申请成功");
      }
   }

   /***
    *根据数据oid从缓存中移除数据
    * @param redisOid redisid
    * @param codeClssifyOid å­˜å‚¨è§„则的oid
    * @param dataOids  æ‰€éœ€åˆ é™¤çš„数据
    * @return
    */
   @Override
   public R deleteDatas(String redisOid,String codeClssifyOid,String dataOids) {
      VciBaseUtil.alertNotNull(redisOid, "数据删除", redisOid, "数据缓存主键");
      VciBaseUtil.alertNotNull(codeClssifyOid, "数据删除", codeClssifyOid, "编码规则缓存主键");
      VciBaseUtil.alertNotNull(dataOids, "数据删除", dataOids, "所需删除的数据主键");
      try {
         List<CodeImprotDataVO> codeImprotDataVOs = bladeRedis.lRange(redisOid + "-" + codeClssifyOid,0,-1);
         List<String> dataOidList = new ArrayList<>();
         codeImprotDataVOs.stream().forEach(codeImprotDataVO -> {
            List<Map<String, String>> newDataList = new ArrayList<>();
            List<Map<String, String>> dataList = codeImprotDataVO.getDatas();
            dataList.stream().forEach(dataMap -> {
               String oid = dataMap.get("oid");
               if (!dataOidList.contains(oid)) {
                  newDataList.add(dataMap);
               }

            });
            codeImprotDataVO.setDatas(newDataList);

         });
         //重新缓存
         bladeRedis.del(redisOid + "-" + codeClssifyOid);
         bladeRedis.set(redisOid + "-" + codeClssifyOid, codeImprotDataVOs);
         bladeRedis.expire(redisOid + "-" + codeClssifyOid, BATCHADD_REDIS_TIME);
         return R.success("删除缓存数据成功");
      }catch (Throwable e){
         return R.fail("删除缓存数据失败!");
      }
   }

   /**
    * é›†æˆæ‰¹é‡ç”³è¯·æ•°æ®
    * @param orderDTO åˆ†ç±»çš„主键
    * @param dataObjectVO æ•°æ®ä¿¡æ¯
    * @param resultDataObjectDetailDOs é”™è¯¯ä¿¡æ¯
    * @return æœ‰é”™è¯¯ä¿¡æ¯çš„excel
    */
   @Override
   public void batchSyncApplyCode(CodeOrderDTO orderDTO, DataObjectVO dataObjectVO, LinkedList<XMLResultDataObjectDetailDO> resultDataObjectDetailDOs) {
      Map<String,String> errorMap=new HashMap<>();
      VciBaseUtil.alertNotNull(orderDTO,"编码申请相关的数据",orderDTO.getCodeClassifyOid(),"主题库分类主键");
      CodeClassifyFullInfoBO classifyFullInfo = classifyService.getClassifyFullInfo(orderDTO.getCodeClassifyOid());
      //规则的主键需要去获取
      CodeRuleVO ruleVO = engineService.getCodeRuleByClassifyFullInfo(classifyFullInfo);
      //1.判断规则中除了流水码段，是否有其他码段
      //engineService.checkSecValueOnOrder(ruleVO,orderDTO);
      //查询分类和模板
      //先找到每一行的标题，然后根据标题来获取对应的属性
      List<RowDatas> rowDataList = dataObjectVO.getRowData();
      Map<String , RowDatas>rowDataMap=new LinkedHashMap<>();
      rowDataList.stream().forEach(rowData->{
         rowDataMap.put(rowData.getRowIndex(),rowData);
      });
      //找第一行，为了找标题
      CodeClassifyTemplateVO templateVO = engineService.getUsedTemplateByClassifyOid(orderDTO.getCodeClassifyOid());

      //校验模板是不是最新的
      //checkTemplateSync(sheetDataSetList,templateVO);
      //除去默认的属性.还有只有表单显示的字段才导入
      List<CodeClassifyTemplateAttrVO> attrVOS = templateVO.getAttributes().stream().filter(s ->!DEFAULT_SYNC_ATTR_LIST.contains(s.getId()) && VciBaseUtil.getBoolean(s.getFormDisplayFlag())
      ).collect(Collectors.toList());
      Map<Integer/**列号**/,String/**字段的名称**/> fieldIndexMap = new HashMap<>();
      List<String> titleRowData = dataObjectVO.getColName();
      Map<String/**中文名称**/, String/**英文名称**/> attrNameIdMap = attrVOS.stream().collect(Collectors.toMap(s -> s.getName(), t -> t.getId().toLowerCase(Locale.ROOT),(o1, o2)->o2));
      getFieldIndexMap(titleRowData,attrNameIdMap,fieldIndexMap);

      //需要判断是否所有的属性都在模板上了
      List<CodeClassifyTemplateAttrVO> unExistAttrVOs = attrVOS.stream().filter(s -> !fieldIndexMap.containsValue(s.getId().toLowerCase(Locale.ROOT))
         && com.alibaba.cloud.commons.lang.StringUtils.isBlank(s.getComponentRule()) && com.alibaba.cloud.commons.lang.StringUtils.isBlank(s.getClassifyInvokeAttr())//组合规则和分类注入确实没给用户导出去
      ).collect(Collectors.toList());
      if(!CollectionUtils.isEmpty(unExistAttrVOs)){
         throw new VciBaseException("【" + unExistAttrVOs.stream().map(CodeClassifyTemplateAttrVO::getName) + "】这些属性在excel中没有找到");
      }
      List<ClientBusinessObject> cboList = new ArrayList<>();
      String fullPath = getFullPath(classifyFullInfo);

      // List<CodeClassifyProcessTempVO> codeClassifyProcessTempVOS=codeClassifyProcessTempService.listProcessTemplate(templateVO.getOid(),"code_cls_flow_use_order");
      boolean isProcess=false;
      //注释掉此处下面所有都按照不判断流程存储状态了
      /** if(!CollectionUtils.isEmpty(codeClassifyProcessTempVOS)){
       isProcess=true;
       }***/
      Map<String,String> codeOidToSystemOidMap=new HashMap<>();//存储编码数据和集成系统数据oid对照映射
      excelToCbo(classifyFullInfo,titleRowData,fieldIndexMap,rowDataList,templateVO,cboList,fullPath,isProcess,"create",errorMap,codeOidToSystemOidMap);

      //都转换完了。需要批量检查
      //如果出错了，我们依然执行有效的数据，无效的数据写回到excel中
      //2.判断必输项。。需要全部的属性，如果是必输，但是表单里面不显示的，只能是分类注入或者组合规则
      batchCheckRequiredAttrOnOrder(templateVO,cboList,errorMap);


      /**
       * å…³é”®ç†Ÿæ‚‰é”™è¯¯æç¤º
       */
      Map<String,String> errorKeyMap=new HashMap<>();


      //3.判断关键属性
      CodeImportResultVO keyResultVO = batchCheckKeyAttrOnOrder(classifyFullInfo, templateVO, cboList);
      Set<String> selfRepeatRowIndexList = keyResultVO.getSelfRepeatRowIndexList();
      Set<String> keyAttrRepeatRowIndexList = keyResultVO.getKeyAttrRepeatRowIndexList();
      if(!CollectionUtils.isEmpty(selfRepeatRowIndexList)){
         selfRepeatRowIndexList.stream().forEach(rowIndex->{
               /* //传入数据之间关键属性的校验
                RowDatas rowData= rowDataMap.get(rowIndex);
                XMLResultDataObjectDetailDO resultDataObjectDetailDO=new XMLResultDataObjectDetailDO();
                resultDataObjectDetailDO.setCode("");
                resultDataObjectDetailDO.setId(rowData.getOid());
                resultDataObjectDetailDO.setErrorid("1");
                resultDataObjectDetailDO.setMsg(errorMap.getOrDefault(rowIndex,"") + ";关键属性重复");
                resultDataObjectDetailDOs.add(resultDataObjectDetailDO);
                */
            errorKeyMap.put(rowIndex,errorMap.getOrDefault(rowIndex,"") + ";传入的数据中关键属性重复");
         });
      }
      /****
       * å…³é”®å±žæ€§ä¸Žç³»ç»Ÿä¸­é‡å¤çš„判断
       */
      if(!CollectionUtils.isEmpty(keyAttrRepeatRowIndexList)){
         keyAttrRepeatRowIndexList.stream().forEach(rowIndex->{
            //传入数据之间关键属性的校验
               /* RowDatas rowData= rowDataMap.get(rowIndex);
                XMLResultDataObjectDetailDO resultDataObjectDetailDO=new XMLResultDataObjectDetailDO();
                resultDataObjectDetailDO.setCode("");
                resultDataObjectDetailDO.setId(rowData.getOid());
                resultDataObjectDetailDO.setErrorid("1");
                resultDataObjectDetailDO.setMsg(errorMap.getOrDefault(rowIndex,"") + ";关键属性与系统中的重复" );
                resultDataObjectDetailDOs.add(resultDataObjectDetailDO);
                */
            errorKeyMap.put(rowIndex,errorMap.getOrDefault(rowIndex,"") + ";关键属性与系统中的重复" );
         });
      }
      //分类注入
      batchSwitchClassifyAttrOnOrder(attrVOS,cboList,classifyFullInfo,false);
      //boolean
      reSwitchBooleanAttrOnOrder(attrVOS,cboList);
      // cboList.stream().forEach(cbo->{
      //4.校验规则
      batchCheckVerifyOnOrder(attrVOS, cboList,errorMap);
      //5.校验枚举是否正确
      batchSwitchEnumAttrOnOrder(attrVOS,cboList,errorMap);
      //6.时间格式的验证
      //6.时间的，必须统一为yyyy-MM-dd HH:mm:ss
      batchSwitchDateAttrOnOrder(attrVOS,cboList,errorMap);
      //7.处理参照的情况
      batchSwitchReferAttrOnOrder(attrVOS,cboList,errorMap);
      //校验属性是否正确错误信息
      if(errorMap.size()>0){
         String[] newMsg = {""};
         cboList.stream().forEach(cbo -> {
            String rowIndex =cbo.getAttributeValue(IMPORT_ROW_INDEX);
            if(errorMap.containsKey(rowIndex)){
               String oid=cbo.getOid();
               String sourceOid=oid;
               if(codeOidToSystemOidMap.containsKey(oid)){
                  sourceOid=codeOidToSystemOidMap.get(oid);
               }
               String code="";
               String errorid="103";
               String mes=errorMap.get(rowIndex);
               XMLResultDataObjectDetailDO resultDataObjectDetailDO=new XMLResultDataObjectDetailDO();
               resultDataObjectDetailDO.setCode(code);
               resultDataObjectDetailDO.setId(sourceOid);
               resultDataObjectDetailDO.setErrorid(errorid);
               resultDataObjectDetailDO.setMsg(mes);
               resultDataObjectDetailDOs.add(resultDataObjectDetailDO);
            }
         });

      }

      Map<String,String> newKeyMap=new HashedMap();
      if(errorKeyMap.size()>0 ) {
         errorKeyMap.keySet().forEach(key->{
            if(!errorMap.containsKey(key)){
               newKeyMap.put(key,errorKeyMap.get(key));
            }
         });
         if(newKeyMap.size()>0) {
            List<BaseModel> editBoList = new ArrayList<>();
            Map<String, List<BaseModel>> indexTodataMap = keyResultVO.getIndexTODataMap();
            cboList.stream().forEach(cbo -> {
               String rowIndex = cbo.getAttributeValue(IMPORT_ROW_INDEX);
               if (indexTodataMap.containsKey(rowIndex)) {
                  String oid = cbo.getOid();
                  String sourceOid = oid;
                  String code = "";
                  String errorid = "201";
                  if(codeOidToSystemOidMap.containsKey(oid)){
                     sourceOid=codeOidToSystemOidMap.get(oid);
                  }
                  List<BaseModel> newCboList = indexTodataMap.get(rowIndex);
                  if (!CollectionUtils.isEmpty(newCboList)) {
                     BaseModel newCbo= newCboList.get(0);
                     String lcstatus =newCbo.getLcStatus();
                     String newOid =newCbo.getOid();
                     Date ts =newCbo.getTs();
                     code=newCbo.getId();
                     String lastmodifier=newCbo.getLastModifier();
                     if (!lcstatus.equals(CodeDefaultLC.RELEASED.getValue())) {
                        newCbo.setOid(newOid);
                        newCbo.setLastModifier(lastmodifier);
                        newCbo.setId(code);
                        newCbo.setTs(ts);
                        cbo.setLastModifier(cbo.getLastModifier());
                        editBoList.add(newCbo);
                     }
                     String mes = errorKeyMap.get(rowIndex);
                     XMLResultDataObjectDetailDO resultDataObjectDetailDO = new XMLResultDataObjectDetailDO();
                     resultDataObjectDetailDO.setCode(code);
                     resultDataObjectDetailDO.setId(sourceOid);
                     resultDataObjectDetailDO.setErrorid(errorid);
                     resultDataObjectDetailDO.setMsg(mes);
                     resultDataObjectDetailDOs.add(resultDataObjectDetailDO);
                  }
               }
            });
            //关键熟悉更改
            if (!CollectionUtils.isEmpty(editBoList)) {
               engineService.updateBatchByBaseModel(classifyFullInfo.getTopClassifyVO().getBtmTypeId(),editBoList);//保存数据
            }
            errorMap.putAll(errorKeyMap);
         }
      }

      //  });
      //设置默认值
      batchSwitchAttrDefault(attrVOS, cboList);
      //最后弄组合规则
      batchSwitchComponentAttrOnOrder(attrVOS,cboList);
      //要把以上的错误的都抛出后，再继续处理时间和组合规则
      List<ClientBusinessObject> needSaveCboList = cboList.stream().filter(cbo -> {
         String rowIndex =cbo.getAttributeValue(IMPORT_ROW_INDEX);
         return !errorMap.containsKey(rowIndex);
      }).collect(Collectors.toList());
      List<String> needRowIndexList = new ArrayList<>();
      if(!CollectionUtils.isEmpty(needSaveCboList)) {
         //9.我们处理业务数据
         //生成编码的内容

         List<String>allNeedSaveCboList=new ArrayList<>();
         List<BaseModel> dataCBOList=new ArrayList<>();
         needSaveCboList.stream().forEach(clientBusinessObject -> {
            BaseModel baseModel=new BaseModel();
            BeanUtil.convert(clientBusinessObject,baseModel);
         //(VciBaseUtil.objectToMapString(clientBusinessObject));
            dataCBOList.add(baseModel);
            allNeedSaveCboList.add(baseModel.getOid());
         });
         try {
            productCodeService.productCodeAndSaveData(classifyFullInfo, templateVO, ruleVO, orderDTO.getSecDTOList(), dataCBOList);
            //如果是编码生成失败，则直接就失败了，其他的判断出来有错误的我们都统一返回到excel里面
            engineService.batchSaveSelectChar(templateVO, dataCBOList);
            // if(!isProcess){
            dataCBOList.stream().forEach(needSaveCbo->{
               XMLResultDataObjectDetailDO resultDataObjectDetailDO=new XMLResultDataObjectDetailDO();
               resultDataObjectDetailDO.setCode(needSaveCbo.getId());
               String oid=needSaveCbo.getOid();
               String sourceOid=oid;
               if(codeOidToSystemOidMap.containsKey(oid)){
                  sourceOid=codeOidToSystemOidMap.get(oid);
               }
               resultDataObjectDetailDO.setId(sourceOid);
               resultDataObjectDetailDO.setErrorid("0");
               resultDataObjectDetailDO.setMsg("申请编码成功");
               resultDataObjectDetailDOs.add(resultDataObjectDetailDO);
            });
               /* }else{
                    needSaveCboList.stream().forEach(needSaveCbo->{
                        XMLResultDataObjectDetailDO resultDataObjectDetailDO=new XMLResultDataObjectDetailDO();
                       // resultDataObjectDetailDO.setCode(needSaveCbo.getId());//不用返回编码
                        String oid=needSaveCbo.getOid();
                        String sourceOid=oid;
                        if(codeOidToSystemOidMap.containsKey(oid)){
                            sourceOid=codeOidToSystemOidMap.get(oid);
                        }
                        resultDataObjectDetailDO.setId(sourceOid);
                        resultDataObjectDetailDO.setErrorid("204");
                        resultDataObjectDetailDO.setMsg("申请编码成功，等待编码系统发布！");
                        resultDataObjectDetailDOs.add(resultDataObjectDetailDO);
                    });

                }*/
         }catch (Throwable e){
            e.printStackTrace();
            needSaveCboList.stream().forEach(needSaveCbo->{
               XMLResultDataObjectDetailDO resultDataObjectDetailDO=new XMLResultDataObjectDetailDO();
               resultDataObjectDetailDO.setCode("");
               String oid=needSaveCbo.getOid();
               String sourceOid=oid;
               if(codeOidToSystemOidMap.containsKey(oid)){
                  sourceOid=codeOidToSystemOidMap.get(oid);
               }
               resultDataObjectDetailDO.setId(sourceOid);
               resultDataObjectDetailDO.setErrorid("1");
               resultDataObjectDetailDO.setMsg("保存出现问题:"+e.getMessage());
               resultDataObjectDetailDOs.add(resultDataObjectDetailDO);
            });

         }
      }

   }
   /***
    * é›†æˆæ‰¹é‡åŒæ­¥æ›´æ–°æŽ¥å£
    * @param codeClassifyVO;
    * @param dataObjectVO æ•°æ®ä¿¡æ¯
    * @param resultDataObjectDetailDOs é”™è¯¯ä¿¡æ¯
    */
   @Transactional(rollbackFor = VciBaseException.class)
   @Override
   public void batchSyncEditDatas(CodeClassifyVO codeClassifyVO, DataObjectVO dataObjectVO, LinkedList<XMLResultDataObjectDetailDO> resultDataObjectDetailDOs) {
      String errorid="";
      String msg="";
      //查询分类和模板
      //先找到每一行的标题，然后根据标题来获取对应的属性
      List<RowDatas> rowDataList = dataObjectVO.getRowData();
      Map<String, RowDatas> rowDataMap = new LinkedHashMap<>();
      Map<String, RowDatas> codeDataMap = new LinkedHashMap<>();
      rowDataList.stream().forEach(rowData -> {
         rowDataMap.put(rowData.getRowIndex(), rowData);
         codeDataMap.put(rowData.getCode(), rowData);
      });
      //找第一行，为了找标题
      CodeClassifyTemplateVO templateVO = engineService.getUsedTemplateByClassifyOid(codeClassifyVO.getOid());
      // åº”该都是一个分类下的业务数据，找第一条的就行
      CodeClassifyFullInfoBO classifyFullInfo = classifyService.getClassifyFullInfo(codeClassifyVO.getOid());
      //校验模板是不是最新的
      //checkTemplateSync(sheetDataSetList,templateVO);
      //除去默认的属性.还有只有表单显示的字段才导入
      List<CodeClassifyTemplateAttrVO> attrVOS = templateVO.getAttributes().stream().filter(s -> !DEFAULT_SYNC_ATTR_LIST.contains(s.getId()) && VciBaseUtil.getBoolean(s.getFormDisplayFlag())
      ).collect(Collectors.toList());
      Map<Integer/**列号**/, String/**字段的名称**/> fieldIndexMap = new HashMap<>();
      List<String> titleRowData = dataObjectVO.getColName();
      Map<String/**中文名称**/, String/**英文名称**/> attrNameIdMap = attrVOS.stream().collect(Collectors.toMap(s -> s.getName(), t -> t.getId().toLowerCase(Locale.ROOT), (o1, o2) -> o2));
      getFieldIndexMap(titleRowData, attrNameIdMap, fieldIndexMap);
      Map<String, String> cboOidMap = new HashMap<>();
      cboOidMap.put("id", QueryOptionConstant.IN + "(" + VciBaseUtil.toInSql(codeDataMap.keySet().toArray(new String[0])) + ")");
      String tableName ="";
      try {
         R<BtmTypeVO> r = btmTypeClient.getAllAttributeByBtmId(templateVO.getBtmTypeId());
         if(!r.isSuccess()) {
            throw new Throwable(r.getMsg());
         }
         BtmTypeVO btmTypeVO = r.getData();
         if (btmTypeVO == null) {
            throw new Throwable("根据业务类型未查询到业务类型对象！");
         }
         tableName = btmTypeVO.getTableName();
         if (StringUtils.isBlank(tableName)) {
            throw new Throwable("根据业务类型未查询到业务类型相关联的表");
         }
      }catch (Throwable e){
         log.error("查询业务对象表"+e);
         XMLResultDataObjectDetailDO xmlResultDataObjectDetailDO=new XMLResultDataObjectDetailDO();
         xmlResultDataObjectDetailDO.setErrorid("103");
         xmlResultDataObjectDetailDO.setMsg("查询业务对象表"+e);
         xmlResultDataObjectDetailDO.setId("");
         xmlResultDataObjectDetailDO.setCode("");
         resultDataObjectDetailDOs.add(xmlResultDataObjectDetailDO);
         return;
      }

      StringBuffer sb=new StringBuffer();
      sb.append(" select * from ");
      sb.append(tableName);
      sb.append(" where 1=1 ");
      sb.append(" id in (");
      sb.append(VciBaseUtil.toInSql(codeDataMap.keySet().toArray(new String[0])));
      sb.append(")");
      List<Map<String,String>> dataMapList=commonsMapper.queryByOnlySqlForMap(sb.toString());
      List<ClientBusinessObject> cboList=   ChangeMapTOClientBusinessObjects(dataMapList);
      Map<String, ClientBusinessObject> codeSystemObjectMap = cboList.stream().filter(systeDataObject -> systeDataObject != null && StringUtils.isNotBlank(systeDataObject.getId())).collect(Collectors.toList()).stream().collect(Collectors.toMap(s -> s.getId(), t -> t));
      Map<String, String> errorMap = new HashMap<>();
      List<CodeOrderDTO> codeOrderDTOList = new ArrayList<>();
      this.getCodeOrderDTOs(codeClassifyVO, templateVO, codeDataMap, codeSystemObjectMap, codeOrderDTOList, errorMap);
      // List<CodeClassifyProcessTempVO> codeClassifyProcessTempVOS=codeClassifyProcessTempService.listProcessTemplate(templateVO.getOid(),"code_cls_flow_use_order");
      boolean isProcess=false;
      /**  if(!CollectionUtils.isEmpty(codeClassifyProcessTempVOS)){
       isProcess=true;
       }**/

      Map<String, CodeOrderDTO> orderDTOMap = codeOrderDTOList.stream().filter(orderDTO -> orderDTO != null && StringUtils.isNotBlank(orderDTO.getId())).collect(Collectors.toList()).stream().collect(Collectors.toMap(s -> s.getId(), t -> t));
      List<BaseModel> updateList = new ArrayList<>();
      List<CodeAllCode> codeAllCodeList = new ArrayList<>();
      List<String> deleteList = new ArrayList<>();

      CodeClassifyTemplateVO firstTemplateVO = templateService.getObjectHasAttrByOid(orderDTOMap.values().stream().findFirst().get().getTemplateOid());
      Map<String, ClientBusinessObject> cboMap = cboList.stream().filter(cbo -> cbo != null).collect(Collectors.toList()).stream().collect(Collectors.toMap(s -> s.getId(), t -> t));
      //  boolean finalIsProcess = isProcess;
      orderDTOMap.keySet().stream().forEach(code -> {
         CodeOrderDTO orderDTO = orderDTOMap.get(code);
         ClientBusinessObject cbo = cboMap.get(code);
         String dataStatus=cbo.getLcStatus();
         RowDatas rowData=codeDataMap.get(code);
         String status=rowData.getStatus();
         String operation=rowData.getOperation();
         if (cbo.getTs().compareTo(orderDTO.getTs())==0?true:false) {
            // throw new VciBaseException("数据不是最新的，可能他人已经修改，请刷新后再试");
            errorMap.put(orderDTO.getId(),errorMap.getOrDefault(orderDTO.getId(),"")+";数据不是最新的，可能他人已经修改，请刷新后再试");
         }
           /* if (!CodeDefaultLC.EDITING.getValue().equalsIgnoreCase(cbo.getLcStatus()) && !orderDTO.isEditInProcess()) {
                throw new VciBaseException("数据不是{0}的状态，不允许修改", new String[]{CodeDefaultLC.EDITING.getText()});
            }*/
         if(operation.equals("update")) {
            //1. åˆ¤æ–­å¿…输项
            checkRequiredAttrOnOrder(templateVO, orderDTO, errorMap);
            //2.先注入，再组合，最后校验
            switchClassifyLevelOnOrder(templateVO, classifyFullInfo, orderDTO, errorMap);
            //3.处理组合规则。组合规则不能使用编码的属性，因为编码的生成可能是需要属性的
            switchComponentAttrOnOrder(templateVO, orderDTO);
            //4.校验规则
            checkVerifyOnOrder(templateVO, orderDTO, errorMap);
            //5.判断关键属性
            checkKeyAttrOnOrder(classifyFullInfo, templateVO, orderDTO, errorMap);
            //6.校验枚举的内容是否正确
            checkEnumOnOrder(templateVO, orderDTO, errorMap);
            //7.处理时间格式，在数据库里面不论是字符串还是日期格式，都使用相同的格式存储
            switchDateAttrOnOrder(templateVO, orderDTO);
            //默认的内容不能变，所以只需要拷贝自定义的相关属性即可
            copyValueToCBO(classifyFullInfo, cbo, orderDTO, templateVO, true, errorMap);
            //企业码和集团码的不修改
            cbo.setDescription(StringUtils.isBlank(orderDTO.getDescription())?"":orderDTO.getDescription());
            cbo.setName(orderDTO.getName());
            try {
               cbo.setAttributeValueWithNoCheck("description", orderDTO.getDescription());
               cbo.setAttributeValue("name", orderDTO.getName());
               //  if(finalIsProcess){//在流程中不允许更改
               //     errorMap.put(code,errorMap.getOrDefault(code, errorMap.getOrDefault(code,"")+";数据"+code+"在流程中，不允许更改!"));
               //  }else{
               cbo.setLcStatus(status);
               cbo.setAttributeValue("lcstatus",status);
               //  }
            } catch (VciBaseException e) {
               e.printStackTrace();
            }

            List<CodeAllCode>newCodeAllCodeList= codeAllCodeService.selectByWrapper(Wrappers.<CodeAllCode>query().lambda().eq(CodeAllCode::getCreateCodeOid, cbo.getOid()));
            if (!CollectionUtils.isEmpty(newCodeAllCodeList)) {
               CodeAllCode codeCbo = codeAllCodeList.get(0);
               log.info("codeCbos code:" + codeCbo.getId());
               codeCbo.setLcStatus(status);
               codeAllCodeList.add(codeCbo);
            }

            BaseModel baseModel=new BaseModel();
            BeanUtil.convert(cbo,baseModel);
            //baseModel.setData(VciBaseUtil.objectToMapString(cbo));
            updateList.add(baseModel);
         }else if(operation.equals("delete")){//如果在流程中不允许删除，不在流程中状态为发布或者停用的数据不允许删除，将其更改为停用，其他的情况直接删除
            //  if(finalIsProcess){
            //    errorMap.put(code,errorMap.getOrDefault(code, errorMap.getOrDefault(code,"")+";数据"+code+"在流程中，不允许删除!"));
            //}else {
            try {
               log.info("oid:" + cbo.getOid());
               List<CodeAllCode>newCodeAllCodeList= codeAllCodeService.selectByWrapper(Wrappers.<CodeAllCode>query().lambda().eq(CodeAllCode::getCreateCodeOid, cbo.getOid()));
               log.info("codeCbos size:" + newCodeAllCodeList.size());
               if (!CollectionUtils.isEmpty(newCodeAllCodeList)) {
                  CodeAllCode codeCbo = codeAllCodeList.get(0);
                  log.info("codeCbos code:" + codeCbo.getId());
                  codeCbo.setLcStatus(CodeDefaultLC.TASK_BACK.getValue());
                  codeAllCodeList.add(codeCbo);
               }
               deleteList.add(cbo.getOid());
            }catch (VciBaseException e) {
               e.printStackTrace();
            }
            // }
         }else if(operation.equals("editstatus")){
            try {
               //  if (finalIsProcess) {
               //      errorMap.put(code, errorMap.getOrDefault(code, errorMap.getOrDefault(code, "") + ";数据" + code + "在流程中，不允许更改状态!"));
               //   } else {
               cbo.setLcStatus(status);
               cbo.setAttributeValue("lcstatus", status);

               //  }

               List<CodeAllCode>newCodeAllCodeList= codeAllCodeService.selectByWrapper(Wrappers.<CodeAllCode>query().lambda().eq(CodeAllCode::getCreateCodeOid, cbo.getOid()));
               if (!CollectionUtils.isEmpty(newCodeAllCodeList)) {
                  CodeAllCode codeCbo = codeAllCodeList.get(0);
                  log.info("codeCbos code:" + codeCbo.getId());
                  codeCbo.setLcStatus(status);
                  codeAllCodeList.add(codeCbo);
               }

               BaseModel baseModel=new BaseModel();
               BeanUtil.convert(cbo,baseModel);
               //baseModel.setData(VciBaseUtil.objectToMapString(cbo));
               updateList.add(baseModel);
            }catch (VciBaseException e) {
               e.printStackTrace();
            }
         }
      });
      /**
       * é”™è¯¯ä¿¡æ¯è¾“出
       */
      if(errorMap.size()>0){
         errorMap.keySet().forEach(code->{
            if(codeDataMap.containsKey(code)){
               RowDatas rowDatas=  codeDataMap.get(code);
               String dataMsg=errorMap.get(code);
               String oid=rowDatas.getOid();
               XMLResultDataObjectDetailDO xmlResultDataObjectDetailDO=new XMLResultDataObjectDetailDO();
               xmlResultDataObjectDetailDO.setErrorid("103");
               xmlResultDataObjectDetailDO.setMsg(dataMsg);
               xmlResultDataObjectDetailDO.setId(oid);
               xmlResultDataObjectDetailDO.setCode(code);
               resultDataObjectDetailDOs.add(xmlResultDataObjectDetailDO);
            }
         });
      }else {
         //存储数据
         try {
            engineService.updateBatchByBaseModel(classifyFullInfo.getTopClassifyVO().getBtmTypeId(),updateList);
            codeAllCodeService.saveBatch(codeAllCodeList);
            if(deleteList.size()>0) {
               commonsMapper.deleteByTaleAndOid(tableName, VciBaseUtil.array2String(deleteList.toArray(new String[]{})));
            }
            errorid="0";
            msg="更新/状态更改/删除成功！";
         }catch (Throwable e){
            errorid="1";
            msg="保存失败："+e;
         }finally {
            String finalMsg = msg;
            String finalErrorid = errorid;
            cboList.stream().forEach(cbo->{
               String code =cbo.getId();
               if(codeDataMap.containsKey(code)) {
                  RowDatas rowDatas=codeDataMap.get(code);
                  String oid=rowDatas.getOid();
                  XMLResultDataObjectDetailDO xmlResultDataObjectDetailDO = new XMLResultDataObjectDetailDO();
                  xmlResultDataObjectDetailDO.setErrorid(finalErrorid);
                  xmlResultDataObjectDetailDO.setMsg(finalMsg);
                  xmlResultDataObjectDetailDO.setId(oid);
                  xmlResultDataObjectDetailDO.setCode(code);
                  resultDataObjectDetailDOs.add(xmlResultDataObjectDetailDO);
               }
            });

         }
      }
   }
   /**
    * æ ¡éªŒå±žæ€§æ˜¯å¦ä¸ºå¿…输
    *
    * @param templateVO æ¨¡æ¿çš„显示对象，需要包含模板属性
    * @param orderDTO   ç¼–码申请的信息
    */
   private void checkRequiredAttrOnOrder(CodeClassifyTemplateVO templateVO, CodeOrderDTO orderDTO,Map<String,String> errorMap) {
      Map<String, CodeClassifyTemplateAttrVO> requiredAttrMap = templateVO.getAttributes().stream().filter(
            s -> VciBaseUtil.getBoolean(s.getRequireFlag()) && StringUtils.isBlank(s.getComponentRule())
               && StringUtils.isBlank(s.getClassifyInvokeAttr()))
         .collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t));
      if (!CollectionUtils.isEmpty(requiredAttrMap)) {
         requiredAttrMap.forEach((attrId, attrVO) -> {
            //只有企业编码，状态，备注，模板主键，分类主键这几个是固定的，其余都是自行配置的
            if (StringUtils.isBlank(getValueFromOrderDTO(orderDTO, attrId))) {
               errorMap.put(orderDTO.getId(),errorMap.getOrDefault(orderDTO.getId(),"") + ";属性【{"+attrVO.getName()+"}】必须要输入(选择)内容" );
               //  throw new VciBaseException("属性【{0}】必须要输入(选择)内容", new String[]{attrVO.getName()});
            }
         });
      }
   }
   /**
    * è½¬æ¢ç»„合规则的值
    *
    * @param templateVO æ¨¡æ¿çš„显示对象，需要包含模板属性
    * @param orderDTO   ç¼–码申请的信息
    */
   private void switchComponentAttrOnOrder(CodeClassifyTemplateVO templateVO, CodeOrderDTO orderDTO) {
      Map<String, CodeClassifyTemplateAttrVO> compAttrVOMap = templateVO.getAttributes().stream().filter(s -> StringUtils.isNotBlank(s.getComponentRule())).collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t));
      if (!CollectionUtils.isEmpty(compAttrVOMap)) {
         Map<String, String> dataMap = WebUtil.objectToMapString(orderDTO);

         Map<String, String> dataLowMap = new HashMap<>();
         if (!CollectionUtils.isEmpty(dataMap)) {
            dataMap.forEach((key, value) -> {
               dataLowMap.put(key.toLowerCase(Locale.ROOT), value);
            });
         }
         dataLowMap.putAll(orderDTO.getData());
         compAttrVOMap.forEach((attrId, attrVO) -> {
            dataLowMap.put(attrId, formulaService.getValueByFormula(dataLowMap, attrVO.getComponentRule()));
         });
         dataLowMap.forEach((key, value) -> {
            setValueToOrderDTO(orderDTO, key, value);
         });
      }
   }

   /**
    * æ ¡éªŒæ­£åˆ™è¡¨è¾¾å¼æ˜¯å¦æ­£ç¡®
    *
    * @param templateVO æ¨¡æ¿çš„信息，必须包含属性的内容
    * @param orderDTO   ç¼–码申请的相关的信息
    */
   private void checkVerifyOnOrder(CodeClassifyTemplateVO templateVO, CodeOrderDTO orderDTO,Map<String,String> errorMap) {
      Map<String, CodeClassifyTemplateAttrVO> verifyAttrVOMap = templateVO.getAttributes().stream().filter(s -> StringUtils.isNotBlank(s.getVerifyRule())).collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t));
      if (!CollectionUtils.isEmpty(verifyAttrVOMap)) {
         verifyAttrVOMap.forEach((attrId, attrVO) -> {
            String value = getValueFromOrderDTO(orderDTO, attrId);
            if (StringUtils.isNotBlank(value) && !value.matches(attrVO.getVerifyRule())) {
               errorMap.put(orderDTO.getId(),errorMap.getOrDefault(orderDTO.getId(),"")+";属性["+attrVO.getName()+"]的值不符合校验规则的要求");
               //校验正则表达式
               // throw new VciBaseException("属性[{0}]的值不符合校验规则的要求", new String[]{attrVO.getName()});
            }
         });
      }
   }
   /**
    * æ ¡éªŒå…³é”®å±žæ€§
    *
    * @param classifyFullInfo åˆ†ç±»çš„全部信息
    * @param templateVO       æ¨¡æ¿çš„内容，必须包含模板属性
    * @param orderDTO         ç¼–码申请的相关的信息
    */
   private void checkKeyAttrOnOrder(CodeClassifyFullInfoBO classifyFullInfo, CodeClassifyTemplateVO templateVO, CodeOrderDTO orderDTO,Map<String,String> errorMap) {
      //先获取关键属性的规则，也利用继承的方式
      CodeKeyAttrRepeatVO keyRuleVO = keyRuleService.getRuleByClassifyFullInfo(classifyFullInfo);
      //注意的是keyRuleVO可能为空，表示不使用规则控制
      //获取所有的关键属性
      Map<String, CodeClassifyTemplateAttrVO> ketAttrMap = templateVO.getAttributes().stream().filter(s -> VciBaseUtil.getBoolean(s.getKeyAttrFlag())).collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t));
      Map<String, String> conditionMap = new HashMap<>();
      boolean trimAll = keyRuleVO == null ? false : VciBaseUtil.getBoolean(keyRuleVO.getIgnoreallspaceflag());
      //全部去空的优先级大于去空
      boolean trim = keyRuleVO == null ? false : VciBaseUtil.getBoolean(keyRuleVO.getIgnorespaceflag());
      boolean ignoreCase = keyRuleVO == null ? false : VciBaseUtil.getBoolean(keyRuleVO.getIgnorecaseflag());
      boolean ignoreWidth = keyRuleVO == null ? false : VciBaseUtil.getBoolean(keyRuleVO.getIgnorewidthflag());
      ketAttrMap.forEach((attrId, attrVO) -> {
         String value = getValueFromOrderDTO(orderDTO, attrId);
         if (value == null) {
            value = "";
         }
         engineService.wrapperKeyAttrConditionMap(value, keyRuleVO, attrId, trim, ignoreCase, ignoreWidth, trimAll, conditionMap);
      });

      //没有限制分类，但是一个模板只可能在一个业务类型里面，所以直接查询这个业务类型即可

      if (!CollectionUtils.isEmpty(conditionMap)) {
         final String[] sql = {"select count(*) from " + VciBaseUtil.getTableName(classifyFullInfo.getTopClassifyVO().getBtmTypeId()) + " where 1 = 1 "};
         conditionMap.forEach((key, value) -> {
            sql[0] += " and " + key + " = " + value;
         });
         if (StringUtils.isNotBlank(orderDTO.getOid())) {
            //修改的时候，需要排除自己
            sql[0] += " and oid != '" + orderDTO.getOid() + "'";
         } else if (StringUtils.isNotBlank(orderDTO.getCopyFromVersion())) {
            sql[0] += " and oid != '" + orderDTO.getCopyFromVersion() + "'";
         }
         sql[0] += " and lastR = '1' and lastV = '1' ";
         if (commonsMapper.queryCountBySql(sql[0]) > 0) {
            String ruleInfoMsg = keyRuleVO == null ? "" : "查询规则：去除空格--{0},忽略大小写--{1},忽略全半角--{2},忽略全部空格--{3}";
            String[] objs = new String[]{trim ? "是" : "否", ignoreCase ? "是" : "否", ignoreWidth ? "是" : "否", trimAll ? "是" : "否"};
            String defaultValue=";根据您填写的关键属性的内容，结合关键属性查询规则，发现这个数据已经在系统中存在了。请修正!。";
            String errormsg=defaultValue+ MessageFormat.format(ruleInfoMsg, objs);
            errorMap.put(orderDTO.getId(),errorMap.getOrDefault(orderDTO.getId(),"")+errormsg);
            // throw new VciBaseException("根据您填写的关键属性的内容，结合关键属性查询规则，发现这个数据已经在系统中存在了。请修正!。" + ruleInfoMsg, objs);
         }
      }
   }
   /**
    * æ ¡éªŒæžšä¸¾çš„内容
    *
    * @param templateVO æ¨¡æ¿çš„显示对象，需要包含属性
    * @param orderDTO   ç¼–码申请的信息
    */
   private void checkEnumOnOrder(CodeClassifyTemplateVO templateVO, CodeOrderDTO orderDTO,Map<String,String> errorMap) {
      //如果枚举可以修改，则不需要校验是否符合枚举的选项
      Map<String, CodeClassifyTemplateAttrVO> enumAttrVOMap = templateVO.getAttributes().stream().filter(s -> (StringUtils.isNotBlank(s.getEnumString()) || StringUtils.isNotBlank(s.getEnumId())) && !VciBaseUtil.getBoolean(s.getEnumEditFlag())).collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t));
      if (!CollectionUtils.isEmpty(enumAttrVOMap)) {
         enumAttrVOMap.forEach((attrId, attrVO) -> {
            String value = getValueFromOrderDTO(orderDTO, attrId);
            if (StringUtils.isNotBlank(value)) {
               //有值才能校验
               List<KeyValue> comboboxKVs = this.engineService.listComboboxItems(attrVO);
               if (!comboboxKVs.stream().anyMatch(s -> value.equalsIgnoreCase(s.getKey()))) {
                  errorMap.put(orderDTO.getId(),errorMap.getOrDefault(orderDTO.getId(),"")+";属性【"+attrVO.getName()+"】的值不符合枚举的要求");
                  //throw new VciBaseException("属性【{0}】的值不符合枚举的要求", new String[]{attrVO.getName()});
               }
            }
         });
      }
   }
   /**
    * è½¬æ¢æ—¶é—´çš„格式
    *
    * @param templateVO æ¨¡æ¿çš„显示对象，需要包含属性
    * @param orderDTO   ç¼–码申请的信息
    */
   private void switchDateAttrOnOrder(CodeClassifyTemplateVO templateVO, CodeOrderDTO orderDTO) {
      Map<String, CodeClassifyTemplateAttrVO> dateAttrVOMap = templateVO.getAttributes().stream().filter(s -> StringUtils.isNotBlank(s.getCodeDateFormat())).collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t));
      if (!CollectionUtils.isEmpty(dateAttrVOMap)) {
         dateAttrVOMap.forEach((attrId, attrVO) -> {
            String value = getValueFromOrderDTO(orderDTO, attrId);
            if (StringUtils.isNotBlank(value)) {
               DateConverter dateConverter = new DateConverter();
               dateConverter.setAsText(value);
               value = VciDateUtil.date2Str(dateConverter.getValue(), VciDateUtil.DateTimeMillFormat);
               setValueToOrderDTO(orderDTO, attrId, value);
            }
         });
      }
   }

   /**
    * æ‹·è´æ•°æ®åˆ°cbo对象上
    *
    * @param classifyFullInfo åˆ†ç±»çš„全部信息
    * @param cbo              ä¸šåŠ¡æ•°æ®
    * @param orderDTO         ç¼–码申请的信息
    * @param templateVO       æ¨¡æ¿çš„显示对象
    * @param edit             æ˜¯å¦ä¸ºä¿®æ”¹
    */
   private void copyValueToCBO(CodeClassifyFullInfoBO classifyFullInfo, ClientBusinessObject cbo,
                        CodeOrderDTO orderDTO, CodeClassifyTemplateVO templateVO,
                        boolean edit,Map<String,String> errorMap) {
      String fullPath = "";
      if (!CollectionUtils.isEmpty(classifyFullInfo.getParentClassifyVOs())) {
         fullPath = classifyFullInfo.getParentClassifyVOs().stream().sorted(((o1, o2) -> o2.getDataLevel().compareTo(o1.getDataLevel())))
            .map(CodeClassifyVO::getOid).collect(Collectors.joining("##"));
      } else {
         fullPath = classifyFullInfo.getCurrentClassifyVO().getOid();
      }
      orderDTO.getData().forEach((key, value) -> {
         if (!edit || (!engineService.checkUnAttrUnEdit(key) &&
            !VciQueryWrapperForDO.LC_STATUS_FIELD.equalsIgnoreCase(key))) {
            try {
               cbo.setAttributeValue(key, value);
            } catch (VciBaseException e) {
               log.error("设置属性的值错误", e);
            }
         }
      });
      try {
         cbo.setAttributeValue(CODE_CLASSIFY_OID_FIELD, classifyFullInfo.getCurrentClassifyVO().getOid());
         cbo.setAttributeValue(CODE_TEMPLATE_OID_FIELD, templateVO.getOid());
         cbo.setAttributeValue(CODE_FULL_PATH_FILED, fullPath);
         if (!edit && StringUtils.isBlank(orderDTO.getLcStatus())) {
            //找生命周期的起始状态，
            if (StringUtils.isNotBlank(cbo.getLctid())) {
               //OsLifeCycleVO lifeCycleVO = lifeCycleService.getLifeCycleById(cbo.getLctid());
//               if (lifeCycleVO != null) {
//                  cbo.setLcStatus(lifeCycleVO.getStartStatus());
//               } else {
                  cbo.setLcStatus(CodeDefaultLC.EDITING.getValue());
//               }
            } else {
               cbo.setLcStatus(CodeDefaultLC.EDITING.getValue());
            }

         }
         int secret = VciBaseUtil.getInt(cbo.getAttributeValue(SECRET_FIELD));
         if (secret == 0 || !secretService.checkDataSecret(secret).getData()) {
            Integer userSecret = VciBaseUtil.getCurrentUserSecret();
            cbo.setAttributeValue(SECRET_FIELD, String.valueOf((userSecret == null || userSecret == 0) ? UserSecretEnum.NONE.getValue() : userSecret));
         }
      } catch (Throwable e) {
         log.error("设置默认的属性的值错误", e);
      }
   }
   /**
    * è®¾ç½®æ–°çš„值到申请对象上
    *
    * @param orderDTO ç¼–码申请对象
    * @param attrId   å±žæ€§çš„编号
    * @param value    å€¼
    */
   private void setValueToOrderDTO(CodeOrderDTO orderDTO, String attrId, String value) {
      attrId = attrId.toLowerCase(Locale.ROOT);
      if (VciQueryWrapperForDO.BASIC_FIELD_MAP.containsKey(attrId)) {
         WebUtil.setValueToField(WebUtil.getFieldForObject(attrId, orderDTO.getClass()).getName(), orderDTO, value);
      } else {
         orderDTO.getData().put(attrId, value);
      }
   }
   /**
    * ä»Žç¼–码申请信息对象上获取某个属性的值
    *
    * @param orderDTO ç¼–码申请对象
    * @param attrId   å±žæ€§çš„编号
    * @return å€¼
    */
   private String getValueFromOrderDTO(CodeOrderDTO orderDTO, String attrId) {
      attrId = attrId.toLowerCase(Locale.ROOT);
      String value = null;
      if (VciQueryWrapperForDO.BASIC_FIELD_MAP.containsKey(attrId)) {
         value = WebUtil.getStringValueFromObject(WebUtil.getValueFromField(WebUtil.getFieldForObject(attrId, orderDTO.getClass()).getName(), orderDTO));
      } else {
         //说明是自行配置的
         //前端必须要传递小写的属性
         value = orderDTO.getData().getOrDefault(attrId, "");
      }
      return value;
   }
   /**
    * å¤„理分类注入的信息
    *
    * @param templateVO         æ¨¡æ¿çš„显示对象，必须要后模板的属性
    * @param classifyFullInfoBO åˆ†ç±»çš„全路径
    * @param orderDTO           ç¼–码申请的信息
    */
   private void switchClassifyLevelOnOrder(CodeClassifyTemplateVO templateVO, CodeClassifyFullInfoBO classifyFullInfoBO, CodeOrderDTO orderDTO,Map<String,String> errorMap) {
      Map<String, CodeClassifyTemplateAttrVO> classifyAttrVOMap = templateVO.getAttributes().stream().filter(
         s -> StringUtils.isNotBlank(s.getClassifyInvokeAttr()) && StringUtils.isNotBlank(s.getClassifyInvokeLevel())
      ).collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t));
      if (classifyFullInfoBO.getTopClassifyVO() == null) {
         //需要重新查询一下，因为这个是指定的分类进来的

      }
      if (!CollectionUtils.isEmpty(classifyAttrVOMap)) {
         classifyAttrVOMap.forEach((attrId, attrVO) -> {
            //分类注入的编号或者名称，
            //层级包含指定层和最小层
            CodeClassifyVO classifyVO = null;
            if (!CodeLevelTypeEnum.MIN.getValue().equalsIgnoreCase(attrVO.getClassifyInvokeLevel()) && !"min".equalsIgnoreCase(attrVO.getClassifyInvokeLevel())) {
               //指定了层级的
               //注意，因为查询上级分类出来的层级是倒序的，即顶层节点是最大的值
               List<CodeClassifyVO> classifyVOS = classifyFullInfoBO.getParentClassifyVOs().stream().sorted(((o1, o2) -> o2.getDataLevel().compareTo(o1.getDataLevel()))).collect(Collectors.toList());
               int level = VciBaseUtil.getInt(attrVO.getClassifyInvokeLevel());
               if (classifyVOS.size() >= level && level > 0) {
                  classifyVO = classifyVOS.get(level - 1);
               }
            } else {
               //当前的分类
               classifyVO = classifyFullInfoBO.getCurrentClassifyVO();
            }
            if (classifyVO == null) {
               //说明层级有误
               errorMap.put(orderDTO.getId(),errorMap.getOrDefault(orderDTO.getId(),"")+";分类树上没有层级[" + attrVO.getClassifyInvokeLevel() + "]");
               //orderDTO.getData().put(attrId, "分类树上没有层级[" + attrVO.getClassifyinvokelevel() + "]");
               // classifyVO = classifyFullInfoBO.getCurrentClassifyVO();
            } else {
               Map<String, String> classifyDataMap = VciBaseUtil.objectToMapString(classifyVO);
               String value = classifyDataMap.getOrDefault(attrVO.getClassifyInvokeAttr(), "");
               orderDTO.getData().put(attrId, value);
            }
         });
      }
   }
   /***
    *
    * @param codeClassifyVO
    * @param templateVO
    * @param codeDataMap
    * @param codeSystemObjectMap
    * @param codeOrderDTOList
    * @param errorMap
    * @return
    */
   private void   getCodeOrderDTOs(CodeClassifyVO codeClassifyVO,CodeClassifyTemplateVO templateVO,Map<String ,RowDatas>codeDataMap,Map<String, ClientBusinessObject> codeSystemObjectMap,List<CodeOrderDTO> codeOrderDTOList,Map<String,String> errorMap){
      codeDataMap.keySet().forEach(code->{
         RowDatas rowDatas=codeDataMap.get(code);
         Map<String, String> data= rowDatas.getFiledValue();
         CodeOrderDTO orderDTO = new CodeOrderDTO();
         if(codeSystemObjectMap.containsKey(code)){
            ClientBusinessObject sysDataObject= codeSystemObjectMap.get(code);
            orderDTO.setCodeClassifyOid(codeClassifyVO.getOid());//分类主键
            orderDTO.setOid(sysDataObject.getOid());//数据oid
            orderDTO.setLcStatus(rowDatas.getStatus());//状态
            orderDTO.setId(code);
            orderDTO.setTs(sysDataObject.getTs());
            orderDTO.setBtmname(codeClassifyVO.getBtmname());//业务类型
            orderDTO.setDescription("集成调用:更新");//数据描述
            if(data.containsKey("name")){
               String name=data.get("name");
               orderDTO.setName(name);//名称属性值
            }
            orderDTO.setData(data);//设置数据
            orderDTO.setSecDTOList(null);//分类码段
            orderDTO.setEditInProcess(false);//是否在流程中
            orderDTO.setTemplateOid(templateVO.getOid());
         }else{
            errorMap.put("code","编码为：【"+code+"】的数据在系统中不存在");
         }
         codeOrderDTOList.add(orderDTO);
      });
   }

   /**
    * èŽ·å–分类的全路径
    * @param classifyFullInfo åˆ†ç±»çš„全部信息
    * @return å…¨è·¯å¾„
    */
   private String getFullPath(CodeClassifyFullInfoBO classifyFullInfo){
      String fullPath = "";
      if(!CollectionUtils.isEmpty(classifyFullInfo.getParentClassifyVOs())){
         fullPath = classifyFullInfo.getParentClassifyVOs().stream().sorted(((o1, o2) -> o1.getDataLevel().compareTo(o2.getDataLevel())))
            .map(CodeClassifyVO::getOid).collect(Collectors.joining("##"));
      }else{
         fullPath = classifyFullInfo.getCurrentClassifyVO().getOid();
      }
      return fullPath;
   }

   /**
    * æ£€æŸ¥ç æ®µçš„长度是否符合要求
    * @param cboList æ•°æ®
    * @param classifyVOMap åˆ†ç±»æ˜ å°„
    * @param ruleVOMap è§„则对象
    * @param ruleOidMap åˆ†ç±»åŒ…含规则
    * @param errorMap é”™è¯¯çš„信息
    * @param ruleRowIndexMap è§„则包含的行号，key是规则主键，value是包含的全部行号
    */
   private void checkSecLengthInHistory(List<ClientBusinessObject> cboList,Map<String,CodeClassifyVO> classifyVOMap,Map<String,CodeRuleVO> ruleVOMap,
                               Map<String/**分类主键**/,String/**规则主键**/> ruleOidMap,Map<String,String> errorMap,Map<String,List<String>> ruleRowIndexMap){

      cboList.stream().forEach(cbo-> {
         String rowIndex = cbo.getAttributeValue(IMPORT_ROW_INDEX);
         String secLength = cbo.getAttributeValue(CODE_SEC_LENGTH_FIELD);
         //找分类
         String classifyOid = cbo.getAttributeValue(CODE_CLASSIFY_OID_FIELD);
         CodeClassifyVO classifyVO = classifyVOMap.get(classifyOid);
         if (classifyVO != null) {
            //2#2#4#1这样的方式
            CodeRuleVO ruleVO = ruleVOMap.getOrDefault(ruleOidMap.get(classifyVO.getOid()), null);
            if(ruleVO!=null){
               String[] secValues = secLength.split("#");
               //总长度和编码的长度
               String code = cbo.getAttributeValue(CODE_FIELD);
               if(code.length() != Arrays.stream(secValues).mapToInt(s->VciBaseUtil.getInt(s)).sum()){
                  errorMap.put(rowIndex,errorMap.getOrDefault(rowIndex,"") + ";码段宽度与系统中的编码规则不同" );
               }else if(secValues.length != ruleVO.getSecVOList().size()){
                  errorMap.put(rowIndex,errorMap.getOrDefault(rowIndex,"") + ";码段宽度与系统中的编码规则不同" );
               } else {
                  //每一个长度都不能超过码段的
                  boolean fined = false;
                  for (int j = 0; j < ruleVO.getSecVOList().size(); j++) {
                     CodeBasicSecVO secVO = ruleVO.getSecVOList().get(j);
                     String length= secValues[j];
                     if(StringUtils.isNotBlank(secVO.getCodeSecLength())&&VciBaseUtil.getInt(length)>VciBaseUtil.getInt(secVO.getCodeSecLength())){
                        errorMap.put(rowIndex,errorMap.getOrDefault(rowIndex,"") + ";码段宽度与系统中的编码规则不同" );
                        fined = true;
                        break;
                     }
                  }
                  /**for (int i = 0; i < secValues.length; i++) {
                   for (int j = 0; j < ruleVO.getSecVOList().size(); j++) {
                   CodeBasicSecVO secVO = ruleVO.getSecVOList().get(j);
                   if (VciBaseUtil.getInt(secValues[i]) > VciBaseUtil.getInt(secVO.getCodeSecLength())) {
                   errorMap.put(rowIndex,errorMap.getOrDefault(rowIndex,"") + ";码段宽度与系统中的编码规则不同" );
                   fined = true;
                   break;
                   }
                   }
                   if(fined){
                   break;
                   }
                   }***/
                  if(!fined){
                     //暂时不取流水的内容，因为调用produceCode的时候去处理
                     List<String> rowIndexList = ruleRowIndexMap.getOrDefault(ruleVO.getOid(), new ArrayList<>());
                     rowIndexList.add(rowIndex);
                     ruleRowIndexMap.put(ruleVO.getOid(),rowIndexList);
                  }
               }
            }else{
               errorMap.put(rowIndex,errorMap.getOrDefault(rowIndex,"") + ";分类没有设置编码规则" );
            }
         }
      });
   }
   /**
    * excel转换为cbo的对象
    * @param classifyFullInfo åˆ†ç±»çš„全部信息
    * @param fieldIndexMap å­—段的位置
    * @param rowDataList excel里的行数据
    * @param templateVO æ¨¡æ¿çš„显示对象
    * @param cboList æ•°æ®çš„列表
    * @param fullPath å…¨è·¯å¾„
    * @param operation æ“ä½œç±»åž‹
    * @param errorMap é”™è¯¯ä¿¡æ¯è®°å½•
    */
   private void excelToCbo(CodeClassifyFullInfoBO classifyFullInfo,List<String> titleRowData,Map<Integer,String> fieldIndexMap,List<RowDatas> rowDataList,
                     CodeClassifyTemplateVO templateVO,List<ClientBusinessObject> cboList,
                     String fullPath,boolean isProcess,String operation,Map<String,String> errorMap,Map<String,String> codeOidToSystemOidMap){
      rowDataList.stream().forEach(rowData -> {
         String oid=rowData.getOid();
         String rowNumber=rowData.getRowIndex();
         ClientBusinessObject cbo = new ClientBusinessObject();
         DefaultAttrAssimtUtil.addDefaultAttrAssimt(cbo, classifyFullInfo.getTopClassifyVO().getBtmTypeId());
         rowData.getData().forEach((index,value)->{
            String field = fieldIndexMap.get(index);
            if(StringUtils.isBlank(field)){
               errorMap.put(rowNumber,"属性：【" +titleRowData.get(index)+ "】在系统中不存在");
            }
            try {
               cbo.setAttributeValueWithNoCheck(field,value);
               if(WebUtil.isDefaultField(field)){
                  WebUtil.setValueToField(field, cbo, value);
               }
            } catch (VciBaseException e) {
               log.error("设置属性的值错误",e);
               errorMap.put(rowNumber,"属性：【" +titleRowData.get(index)+ "】在系统中不存在");
            }
         });
         try {
            cbo.setAttributeValue(IMPORT_ROW_INDEX,rowData.getRowIndex());
            cbo.setAttributeValue(CODE_TEMPLATE_OID_FIELD,templateVO.getOid());
            if(operation.equals("create")){
               log.info("分类对象："+classifyFullInfo.getCurrentClassifyVO());
               log.info("codeClassoid:"+classifyFullInfo.getCurrentClassifyVO().getOid());
               cbo.setAttributeValue(CODE_CLASSIFY_OID_FIELD,classifyFullInfo.getCurrentClassifyVO().getOid());
               cbo.setAttributeValue(CODE_FULL_PATH_FILED,fullPath);
               int secret = VciBaseUtil.getInt(cbo.getAttributeValue(SECRET_FIELD));
               if(secret == 0 || !secretService.checkDataSecret(secret).getData() ){
                  Integer userSecret = VciBaseUtil.getCurrentUserSecret();
                  String secretValue= String.valueOf((userSecret==null || userSecret ==0)? UserSecretEnum.NONE.getValue():userSecret);
                  cbo.setAttributeValue(SECRET_FIELD,secretValue);
               }
               if(rowData.getStatus().equals(CodeDefaultLC.DISABLE.getValue())){//停用
                  cbo.setLcStatus(CodeDefaultLC.DISABLE.getValue());
               }else if(rowData.getStatus().equals(CodeDefaultLC.EDITING.getValue())){//编辑
                  cbo.setLcStatus(CodeDefaultLC.EDITING.getValue());
               }else if(rowData.getStatus().equals(CodeDefaultLC.AUDITING.getValue())) {//审批中
                  cbo.setLcStatus(CodeDefaultLC.AUDITING.getValue());
               }else if(rowData.getStatus().equals(CodeDefaultLC.TASK_BACK.getValue())){//回收
                  cbo.setLcStatus(CodeDefaultLC.TASK_BACK.getValue());
               }else{
                  cbo.setLcStatus(CodeDefaultLC.RELEASED.getValue());//发布
               }
               /**  if(!isProcess){
                cbo.setLcStatus(CodeDefaultLC.RELEASED.getValue());
                }else {
                if(rowData.getStatus().equals(CodeDefaultLC.DISABLE.getValue())){//停用
                cbo.setLcStatus(CodeDefaultLC.DISABLE.getValue());
                }else if(rowData.getStatus().equals(CodeDefaultLC.EDITING.getValue())){//编辑
                cbo.setLcStatus(CodeDefaultLC.EDITING.getValue());
                }else {//发布
                cbo.setLcStatus(CodeDefaultLC.RELEASED.getValue());
                }
                }***/
               cbo.setCreator(rowData.getCreator());
               cbo.setLastModifier(rowData.getEditor()==null?"":rowData.getEditor());
            }else if(operation.equals("update")){
               //此时还没有转换路径
               //cbo.setAttributeValue(CODE_FULL_PATH_FILED, childOidPathMap.getOrDefault(rowData.getData().getOrDefault(CODE_CLASSIFY_OID_FIELD,""),fullPath));
               if(rowData.getStatus().equals(CodeDefaultLC.DISABLE.getValue())){//停用
                  cbo.setLcStatus(CodeDefaultLC.DISABLE.getValue());
               }else if(rowData.getStatus().equals(CodeDefaultLC.RELEASED.getValue())){//发布
                  cbo.setLcStatus(CodeDefaultLC.RELEASED.getValue());
               }else if(rowData.getStatus().equals(CodeDefaultLC.EDITING.getValue())){//编辑
                  cbo.setLcStatus(CodeDefaultLC.EDITING.getValue());
               }else if(rowData.getStatus().equals(CodeDefaultLC.AUDITING.getValue())) {//审批中
                  cbo.setLcStatus(CodeDefaultLC.AUDITING.getValue());
               }else if(rowData.getStatus().equals(CodeDefaultLC.TASK_BACK.getValue())){//回收
                  cbo.setLcStatus(CodeDefaultLC.TASK_BACK.getValue());
               }
               cbo.setLastModifier(rowData.getEditor() == null ? "" : rowData.getEditor());//修改者
            }else if(operation.equals("delete")){
               if(rowData.getStatus().equals(CodeDefaultLC.TASK_BACK.getValue())){//回收
                  cbo.setLcStatus(CodeDefaultLC.TASK_BACK.getValue());
               }else{
                  cbo.setLcStatus(CodeDefaultLC.DISABLE.getValue());//停用
               }
            }


         }catch (Throwable e){
            log.error("设置默认的属性的值错误",e);
            if(e instanceof  VciBaseException){
               errorMap.put(rowNumber,"设置默认的属性的值错误"+((VciBaseException) e).getMessage());
            }else{
               errorMap.put(rowNumber,"设置默认的属性的值错误"+e.getMessage());
            }

         }finally {
            codeOidToSystemOidMap.put(cbo.getOid(),oid);
         }
         cbo.setDescription("");
         cboList.add(cbo);
      });

   }
   /**
    * excel转换为cbo的对象
    * @param classifyFullInfo åˆ†ç±»çš„全部信息
    * @param codeImprotDataVO: åˆ†ç±»å¯¹åº”的数据
    * @param cboList æ•°æ®çš„列表
    * @param newCode æ˜¯å¦ä¸ºæ‰¹é‡ç”³è¯·
    */
   private void excelToCbo(CodeClassifyFullInfoBO classifyFullInfo,CodeImprotDataVO codeImprotDataVO,List<ClientBusinessObject> cboList, boolean newCode){
      String fullPath = getFullPath(classifyFullInfo);
      codeImprotDataVO.getDatas().stream().forEach(rowData -> {
         ClientBusinessObject cbo=new ClientBusinessObject();
         DefaultAttrAssimtUtil.addDefaultAttrAssimt(cbo, classifyFullInfo.getTopClassifyVO().getBtmTypeId());
         rowData.forEach((field,value)->{
            try {
               cbo.setAttributeValueWithNoCheck(field,value);
               if(WebUtil.isDefaultField(field)){
                  WebUtil.setValueToField(field, cbo, value);
               }
            } catch (VciBaseException e) {
               log.error("设置属性的值错误",e);
            }
         });
         try {
            cbo.setAttributeValue(CODE_TEMPLATE_OID_FIELD,codeImprotDataVO.getTemplateOid());
            cbo.setAttributeValue(IMPORT_ROW_INDEX,rowData.get(IMPORT_ROW_INDEX));
            if(newCode){
               cbo.setAttributeValue(CODE_CLASSIFY_OID_FIELD,classifyFullInfo.getCurrentClassifyVO().getOid());
               cbo.setAttributeValue(CODE_FULL_PATH_FILED,fullPath);
               //cbo.setLcStatus(CodeDefaultLC.EDITING.getValue());
               int secret = VciBaseUtil.getInt(cbo.getAttributeValue(SECRET_FIELD));
               if(secret == 0 || !secretService.checkDataSecret(secret).getData() ){
                  Integer userSecret = VciBaseUtil.getCurrentUserSecret();
                  cbo.setAttributeValue(SECRET_FIELD,String.valueOf((userSecret==null || userSecret ==0)? UserSecretEnum.NONE.getValue():userSecret));
               }
               cbo.setLcStatus(CodeDefaultLC.EDITING.getValue());
            }else{
               //此时还没有转换路径
               //cbo.setAttributeValue(CODE_FULL_PATH_FILED, childOidPathMap.getOrDefault(rowData.getData().getOrDefault(CODE_CLASSIFY_OID_FIELD,""),fullPath));
               cbo.setLcStatus(CodeDefaultLC.RELEASED.getValue());
            }
            rowData.put("oid",cbo.getOid());

         }catch (Throwable e){
            log.error("设置默认的属性的值错误",e);
         }
         cboList.add(cbo);
      });

   }
   /**
    * excel转换为cbo的对象
    * @param classifyFullInfo åˆ†ç±»çš„全部信息
    * @param fieldIndexMap å­—段的位置
    * @param rowDataList excel里的行数据
    * @param templateVO æ¨¡æ¿çš„显示对象
    * @param cboList æ•°æ®çš„列表
    * @param fullPath å…¨è·¯å¾„
    * @param newCode æ˜¯å¦ä¸ºæ‰¹é‡ç”³è¯·
    */
   private void excelToCbo(CodeClassifyFullInfoBO classifyFullInfo,Map<Integer,String> fieldIndexMap,List<SheetRowData> rowDataList,
                     CodeClassifyTemplateVO templateVO,List<ClientBusinessObject> cboList,
                     String fullPath,boolean newCode){
      rowDataList.stream().forEach(rowData -> {
         ClientBusinessObject cbo=new ClientBusinessObject();
          DefaultAttrAssimtUtil.addDefaultAttrAssimt(cbo, classifyFullInfo.getTopClassifyVO().getBtmTypeId());
         rowData.getData().forEach((index,value)->{
            String field = fieldIndexMap.get(index);
            if (StringUtils.isBlank(field)) {
               throw new VciBaseException("第" + (index + 1) + "列的标题在系统中不存在");
            }
            try {
               cbo.setAttributeValueWithNoCheck(field, value);
               if (WebUtil.isDefaultField(field)) {
                  WebUtil.setValueToField(field, cbo, value);
               }
            } catch (VciBaseException e) {
               log.error("设置属性的值错误", e);
            }
         });
         try {
            cbo.setAttributeValue(CODE_TEMPLATE_OID_FIELD,templateVO.getOid());
            cbo.setAttributeValue(IMPORT_ROW_INDEX,rowData.getRowIndex());
            if(newCode){
               cbo.setAttributeValue(CODE_CLASSIFY_OID_FIELD,classifyFullInfo.getCurrentClassifyVO().getOid());
               cbo.setAttributeValue(CODE_FULL_PATH_FILED,fullPath);
               //cbo.setLcStatus(CodeDefaultLC.EDITING.getValue());
               int secret = VciBaseUtil.getInt(cbo.getAttributeValue(SECRET_FIELD));
               if(secret == 0 || !secretService.checkDataSecret(secret).getData() ){
                  Integer userSecret = VciBaseUtil.getCurrentUserSecret();
                  cbo.setAttributeValue(SECRET_FIELD,String.valueOf((userSecret==null || userSecret ==0)? UserSecretEnum.NONE.getValue():userSecret));
               }
               cbo.setLcStatus(CodeDefaultLC.EDITING.getValue());
            }else{
               //此时还没有转换路径
               //cbo.setAttributeValue(CODE_FULL_PATH_FILED, childOidPathMap.getOrDefault(rowData.getData().getOrDefault(CODE_CLASSIFY_OID_FIELD,""),fullPath));
               cbo.setLcStatus(CodeDefaultLC.RELEASED.getValue());
            }

         }catch (Throwable e){
            log.error("设置默认的属性的值错误",e);
         }
         cboList.add(cbo);
      });

   }

   /**
    * æ£€æŸ¥æ ¡éªŒè§„则没有通过的内容
    * @param attrVOS éœ€è¦æ ¡éªŒçš„属性
    * @param dataList æ•°æ®çš„列表
    * @param errorMap é”™è¯¯çš„信息映射
    * @return æ ¡éªŒä¸é€šè¿‡çš„行数
    */
   private void batchCheckVerifyOnOrder(Collection<CodeClassifyTemplateAttrVO> attrVOS, List<ClientBusinessObject> dataList,Map<String,String> errorMap) {
      Map<String, CodeClassifyTemplateAttrVO> verifyAttrVOMap = attrVOS.stream().filter(s -> StringUtils.isNotBlank(s.getVerifyRule()) && StringUtils.isBlank(s.getComponentRule())
         &&StringUtils.isBlank(s.getClassifyInvokeAttr())
      ).collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t));
      if(!CollectionUtils.isEmpty(verifyAttrVOMap)){
         Map<String/**行号**/,List<String>/**校验不通过的属性**/> unPassCheckMap = new HashMap<>();
         verifyAttrVOMap.forEach((attrId,attrVO)->{
            dataList.stream().forEach(cbo -> {
               String value = cbo.getAttributeValue(attrId);
               if(StringUtils.isNotBlank(value) && !value.matches(attrVO.getVerifyRule())){
                  String rowIndex = cbo.getAttributeValue(IMPORT_ROW_INDEX);
                  List<String> unPassAttrs = unPassCheckMap.getOrDefault(rowIndex, new ArrayList<>());
                  unPassAttrs.add(attrVO.getName());
                  unPassCheckMap.put(rowIndex,unPassAttrs);
               }
            });
         });
         if(!CollectionUtils.isEmpty(unPassCheckMap)){
            unPassCheckMap.forEach((rowIndex,unPassAttrs)->{
               errorMap.put(rowIndex,";属性[" + unPassAttrs.stream().collect(Collectors.joining(",")) + "]内容不符合校验规则的要求");
            });
         }
      }
   }
   /**
    * æ‰¹é‡è½¬æ¢æ—¶é—´éƒ½ä¸ºæŒ‡å®šçš„格式
    * @param attrVOS æ¨¡æ¿å±žæ€§
    * @param cboList æ•°æ®çš„列表
    * @param errorMap é”™è¯¯çš„信息
    */
   private void batchSwitchDateAttrOnOrder(Collection<CodeClassifyTemplateAttrVO> attrVOS,List<ClientBusinessObject> cboList,Map<String,String> errorMap){
      Map<String, CodeClassifyTemplateAttrVO> dateAttrVOMap =attrVOS.stream().filter(s ->
         StringUtils.isNotBlank(s.getCodeDateFormat()) && VciBaseUtil.getBoolean(s.getCodeDateFormat()) && StringUtils.isBlank(s.getComponentRule())
            && StringUtils.isBlank(s.getClassifyInvokeAttr())
      ).collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t));
      if(!CollectionUtils.isEmpty(dateAttrVOMap)) {
         dateAttrVOMap.forEach((attrId, attrVO) -> {
            cboList.stream().forEach(cbo -> {
               String value = cbo.getAttributeValue(attrId);
               if (value == null) {
                  value = "";
               }
               if (StringUtils.isNotBlank(value)) {
                  boolean formated = false;
                  if(StringUtils.isNotBlank(attrVO.getCodeDateFormat())){
                     try {
                        Date date = VciDateUtil.str2Date(value, attrVO.getCodeDateFormat());
                        if(date!=null){
                           cbo.setAttributeValue(attrId,value);
                           formated = true;
                        }
                     } catch (Exception e) {
                        //说明不是这个格式
                     }
                  }
                  if(!formated) {
                     try {
                        DateConverter dateConverter = new DateConverter();
                        dateConverter.setAsText(value);
                        value = VciDateUtil.date2Str(dateConverter.getValue(), VciDateUtil.DateTimeMillFormat);
                        cbo.setAttributeValue(attrId,value);
                     }catch (Throwable e){
                        //转换不了
                        String rowIndex = cbo.getAttributeValue(IMPORT_ROW_INDEX);
                        errorMap.put(rowIndex,errorMap.getOrDefault(rowIndex,"") + ";属性[" + attrVO.getName() + "]时间格式不正确" );
                     }
                  }
               }
            });
         });
      }
   }

   /**
    * ç³»ç»Ÿæ¨¡æ¿ä¸­é»˜è®¤å€¼è®¾ç½®
    * @param attrVOS æ¨¡æ¿å±žæ€§
    * @param dataList excel的数据内容
    */
   private void batchSwitchAttrDefault(Collection<CodeClassifyTemplateAttrVO> attrVOS,List<ClientBusinessObject> dataList) {
      Map<String, CodeClassifyTemplateAttrVO> dateAttrVOMap = attrVOS.stream().filter(s -> StringUtils.isNotBlank(s.getDefaultValue())).collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t));
      if(!CollectionUtils.isEmpty(dateAttrVOMap)) {
         dateAttrVOMap.forEach((attrId, attrVO) -> {
            String defaultValue = attrVO.getDefaultValue();
            dataList.stream().forEach(cbo -> {
               String dataValue= cbo.getAttributeValue(attrId);
               if(StringUtils.isBlank(dataValue)){
                  dataValue=defaultValue;
               }
               try {
                  cbo.setAttributeValue(attrId, dataValue);
               }catch (Throwable e){
                  log.error("设置属性的错误",e);
               }
            });
         });
      }
   }

   /**
    * è½¬ç§»boolean型的属性
    * @param attrVOS å±žæ€§çš„对象
    * @param dataList æ•°æ®
    */
   private void reSwitchBooleanAttrOnOrder(Collection<CodeClassifyTemplateAttrVO> attrVOS,List<ClientBusinessObject> dataList){
      Map<String, CodeClassifyTemplateAttrVO> booleanAttrMap = attrVOS.stream().filter(
         s -> VciFieldTypeEnum.VTBoolean.name().equalsIgnoreCase(s.getAttributeDataType())
      ).collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t));
      if (!CollectionUtils.isEmpty(booleanAttrMap)) {
         booleanAttrMap.forEach((attrId, attrVO) -> {
            dataList.stream().forEach(cbo -> {
               String text = cbo.getAttributeValue(attrId);
               try {
                  if (BooleanEnum.TRUE.getValue().equalsIgnoreCase(text) || "是".equalsIgnoreCase(text)) {
                     cbo.setAttributeValue(attrId, BooleanEnum.TRUE.getValue());
                  } else {
                     cbo.setAttributeValue(attrId, BooleanEnum.FASLE.getValue());
                  }
               }catch (Throwable e){

               }
            });
         });
      }
   }

   /**
    * å¤„理组合规则
    * @param attrVOS æ¨¡æ¿å±žæ€§
    * @param dataList excel的数据内容
    */
   private void batchSwitchComponentAttrOnOrder(Collection<CodeClassifyTemplateAttrVO> attrVOS,List<ClientBusinessObject> dataList) {
      Map<String, CodeClassifyTemplateAttrVO> dateAttrVOMap = attrVOS.stream().filter(s -> StringUtils.isNotBlank(s.getComponentRule())).collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t));
      if(!CollectionUtils.isEmpty(dateAttrVOMap)) {
         dateAttrVOMap.forEach((attrId, attrVO) -> {
            dataList.stream().forEach(cbo -> {
               //从excel上把属性转换为map
               Map<String,String> thisRowDataMap = new HashMap<>();
               copyValueToMapFromCbos(cbo,thisRowDataMap);
               //组合内容
               String value = formulaService.getValueByFormula(thisRowDataMap,attrVO.getComponentRule());
               if(value == null){
                  value = "";
               }
               try {
                  cbo.setAttributeValue(attrId, value);
               }catch (Throwable e){
                  log.error("设置属性的错误",e);
               }
            });
         });
      }
   }

   /**
    * è½¬æ¢å‚照的值
    * @param attrVOS å±žæ€§çš„显示对象
    * @param dataList æ•°æ®åˆ—表
    * @param errorMap é”™è¯¯çš„信息
    */
   private void batchSwitchReferAttrOnOrder(Collection<CodeClassifyTemplateAttrVO> attrVOS,List<ClientBusinessObject> dataList,Map<String,String> errorMap){
      Map<String, CodeClassifyTemplateAttrVO> referAttrVOMap = attrVOS.stream().filter(
         s -> (StringUtils.isNotBlank(s.getReferBtmId()) || StringUtils.isNotBlank(s.getReferConfig()))
      ).collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t));
      if(!CollectionUtils.isEmpty(referAttrVOMap)){
         Map<String/**表格和值的属性**/,Map<String/**显示属性的值**/,List<String>/**表格里的值**/>> linkValueMap = new HashMap<>();
         referAttrVOMap.forEach((attrId,attrVO)->{
            dataList.stream().forEach(cbo -> {
               String text = cbo.getAttributeValue(attrId);
               if(StringUtils.isNotBlank(text)){
                  UIFormReferVO referVO = getReferVO(attrVO);
                  String valueField = getValueField(referVO);
                  String showText = getTextField(referVO);
                  String tableAndAttr = VciBaseUtil.getTableName(referVO.getReferType()) + "#" + valueField;
                  Map<String, List<String>> showTextMap = linkValueMap.getOrDefault(tableAndAttr, new HashMap<>());
                  List<String> textList = showTextMap.getOrDefault(showText, new ArrayList<>());
                  if(!textList.contains(text)) {
                     textList.add(text);
                  }
                  showTextMap.put(showText,textList);
                  linkValueMap.put(tableAndAttr,showTextMap);
               }
            });
         });
         if(!CollectionUtils.isEmpty(linkValueMap)){
            //需要逐个表的值字段，逐个查询
            Map<String/**表格和值属性**/,Map<String/**显示属性**/, Map<String/**值**/,String/**显示的值**/>>> linkCboMap = new HashMap<>();
            linkValueMap.forEach((tableAndAttr,showValueMap)->{
               String[] split = tableAndAttr.split("#");
               String table = split[0];
               String valueField = split[1].toLowerCase(Locale.ROOT);
               Map<String,Map<String,String>> dataMap = new HashMap<>();
               showValueMap.forEach((showText,valueList)->{
                  Map<String,String> valueOidTextMap = new HashMap<>();
                  List<List<String>> valueCollections = VciBaseUtil.switchListForOracleIn(valueList);
                  String sql = "select " + valueField + "," + showText.toLowerCase(Locale.ROOT) +" from " + table + "  where " + showText + " in (%s)";
                  valueCollections.stream().forEach(values->{
                     List<Map<String,String>> dataMapList = commonsMapper.queryByOnlySqlForMap(String.format(sql, VciBaseUtil.toInSql(values.toArray(new String[0]))));
                     List<ClientBusinessObject> cbos=   ChangeMapTOClientBusinessObjects(dataMapList);
                     if(!CollectionUtils.isEmpty(cbos)){
                        valueOidTextMap.putAll(cbos.stream().collect(Collectors.toMap(s->s.getAttributeValue(valueField),t->t.getAttributeValue(showText))));
                     }
                  });
                  dataMap.put(showText,valueOidTextMap);
               });
               linkCboMap.put(tableAndAttr,dataMap);
            });
            referAttrVOMap.forEach((attrId,attrVO)->{
               dataList.stream().forEach(cbo -> {
                  String text = cbo.getAttributeValue(attrId);
                  if (StringUtils.isNotBlank(text)) {
                     UIFormReferVO referVO = getReferVO(attrVO);
                     String valueField = getValueField(referVO);
                     String showText = getTextField(referVO);
                     String tableAndAttr = VciBaseUtil.getTableName(referVO.getReferType()) + "#" + valueField;
                     if(!linkCboMap.containsKey(tableAndAttr)){
                        String rowIndex = cbo.getAttributeValue(IMPORT_ROW_INDEX);
                        errorMap.put(rowIndex,errorMap.getOrDefault(rowIndex,"") + ";参数属性[" + attrVO.getName() + "]的值在系统中不存在" );

                     }else{
                        Map<String, Map<String, String>> dataMap = linkCboMap.get(tableAndAttr);
                        if(!dataMap.containsKey(showText)){
                           String rowIndex = cbo.getAttributeValue(IMPORT_ROW_INDEX);
                           errorMap.put(rowIndex,errorMap.getOrDefault(rowIndex,"") + ";参数属性[" + attrVO.getName() + "]的值在系统中不存在" );
                        }else{
                           Map<String, String> data = dataMap.get(showText);
                           final boolean[] fined = {false};
                           data.forEach((key,value)->{
                              if(value.equalsIgnoreCase(text)){
                                 fined[0] = true;
                                 try {
                                    cbo.setAttributeValue(attrId, key);
                                 }catch (Throwable e){

                                 }
                              }
                           });
                           if(!fined[0]){
                              String rowIndex = cbo.getAttributeValue(IMPORT_ROW_INDEX);
                              errorMap.put(rowIndex,errorMap.getOrDefault(rowIndex,"") + ";参数属性[" + attrVO.getName() + "]的值在系统中不存在" );
                           }
                        }
                     }
                  }
               });
            });
         }
      }

   }
   /**
    * æ‰¹é‡æ£€æŸ¥ä¼ä¸šç¼–码是否存在
    * @param templateVO æ¨¡æ¿çš„显示对象
    * @param cboList æ•°æ®çš„列表
    * @param errorMap é”™è¯¯çš„信息
    */
   private void batchCheckIdExistOnOrder(CodeClassifyTemplateVO templateVO,List<ClientBusinessObject> cboList,Map<String ,String> errorMap) throws Throwable{
      List<String> existIds = new ArrayList<>();
      String tableName ="";
      try {
         R<BtmTypeVO> r = btmTypeClient.getAllAttributeByBtmId(templateVO.getBtmTypeId());
         if(!r.isSuccess()) {
            throw new Throwable(r.getMsg());
         }
         BtmTypeVO btmTypeVO = r.getData();
         if (btmTypeVO == null) {
            throw new Throwable("根据业务类型未查询到业务类型对象！");
         }
         tableName = btmTypeVO.getTableName();
         if (StringUtils.isBlank(tableName)) {
            throw new Throwable("根据业务类型未查询到业务类型相关联的表");
         }
      }catch (Throwable e){
         throw e;
      }
      String finalTableName = tableName;
      VciBaseUtil.switchCollectionForOracleIn(cboList).stream().forEach(cbos -> {
         Map<String, String> conditionMap = new HashMap<>();
         conditionMap.put("id", QueryOptionConstant.IN + "(" + VciBaseUtil.toInSql(cbos.stream().map(s -> s.getId()).collect(Collectors.toSet()).toArray(new String[0])) + ")");

         StringBuffer sb=new StringBuffer();
         sb.append(" select id from ");
         sb.append(finalTableName);
         sb.append(" where 1=1 ");
         sb.append(" and id in (");
         sb.append(VciBaseUtil.toInSql(cbos.stream().map(s -> s.getId()).collect(Collectors.toSet()).toArray(new String[0])));
         sb.append(")");
         List<String> idList= commonsMapper.selectById(sb.toString());
         //业务数据如果码值回收会直接删除数据，所以这里直接判断是否存在即可
         existIds.addAll(Optional.ofNullable(idList).orElseGet(() -> new ArrayList<>()).stream().map(s -> s.toLowerCase(Locale.ROOT)).collect(Collectors.toList()));
      });
      if(!CollectionUtils.isEmpty(existIds)){
         String idFieldName = templateVO.getAttributes().stream().filter(s -> VciQueryWrapperForDO.ID_FIELD.equalsIgnoreCase(s.getId())).findFirst().orElseGet(() -> new CodeClassifyTemplateAttrVO()).getName();
         if(StringUtils.isBlank(idFieldName)){
            idFieldName = "企业编码";
         }
         String finalIdFieldName = idFieldName;
         cboList.stream().forEach(cbo->{
            String id = cbo.getId();
            if(StringUtils.isBlank(id)){
               id = cbo.getAttributeValue("id");
            }
            if(existIds.contains(id)){
               String rowIndex = cbo.getAttributeValue(IMPORT_ROW_INDEX);
               String msg = errorMap.getOrDefault(rowIndex, "");
               msg+=";" + finalIdFieldName + "的值在系统中已经存在";
               errorMap.put(rowIndex,msg);
            }
         });
      }
   }
   /***
    * æ ¡éªŒåˆ†ç±»å¯¹åº”的模板信息
    * @param titleRowData
    * @param sheetDataSetList
    * @param shetNumber
    * @param pathMap
    * @param errorMap
    * @return
    * @throws Throwable
    */
   private LinkedList<CodeClassifyTemplateVO> checkSamesTemplate(List<String> titleRowData,  List<SheetDataSet> sheetDataSetList,int shetNumber,Map<String/**路径**/, CodeClassifyVO> pathMap,Map<String,String>errorMap) throws Throwable {
      Map<String,String>pathOidMap =new HashMap<>();
      Map<String,String> templateIdRowIndex=new HashedMap();
      SheetDataSet dataSet=  sheetDataSetList.get(shetNumber);
      LinkedHashMap<String,CodeClassifyTemplateVO> codeClassifyTemplateVOMap=new LinkedHashMap <String,CodeClassifyTemplateVO>();
      for (int i=0; i<titleRowData.size();i++){
         String title= titleRowData.get(i);
         if(title.equals("分类路径")) {
            int finalI = i;
            dataSet.getRowData().stream().forEach(sheetRowData -> {
               String Path = sheetRowData.getData().get(finalI);
               String rowIndex=sheetRowData.getRowIndex();
               if(StringUtils.isBlank(Path)){
                  Path= "#current#";
               }
               CodeClassifyTemplateVO newTemplateVO=new CodeClassifyTemplateVO();
               String templateOid="";
               if(pathOidMap.containsKey(Path)){
                  templateOid= pathOidMap.get(Path) ;
                  newTemplateVO=codeClassifyTemplateVOMap.get(templateOid);
               }else{
                  if (pathMap.containsKey(Path)) {
                     CodeClassifyVO codeClassifyVO = pathMap.get(Path);
                     newTemplateVO = engineService.getUsedTemplateByClassifyOid(codeClassifyVO.getOid());
                     if (newTemplateVO != null) {
                        templateOid = newTemplateVO.getOid();
                     } else {
                        errorMap.put(rowIndex, "第" + rowIndex + "行，分类路径未查询到相应的分类模板");
                     }
                  } else {
                     errorMap.put(rowIndex, "第" + rowIndex + "行，分类路径未查询到相应的分类");
                  }

               }
               pathOidMap.put(Path, templateOid);
               codeClassifyTemplateVOMap.put(templateOid, newTemplateVO);
               templateIdRowIndex.put(templateOid, templateIdRowIndex.getOrDefault(templateOid, "") + "，" +rowIndex );
            });
            break;
         }
      }
      LinkedList<CodeClassifyTemplateVO> codeClassifyTemplateVOList=new LinkedList<>();
      StringBuffer sb=new StringBuffer();
      codeClassifyTemplateVOMap.keySet().forEach(tempateOid->{
         String templateOidInExcel="";
         String tempateName="";
         CodeClassifyTemplateVO t= codeClassifyTemplateVOMap.get(tempateOid);
         codeClassifyTemplateVOList.add(t);
         if(!CollectionUtils.isEmpty(sheetDataSetList)
            && sheetDataSetList.size()>1 && !CollectionUtils.isEmpty(sheetDataSetList.get(sheetDataSetList.size()-1).getColName())){
            List<SheetRowData>  rowData=  sheetDataSetList.get(sheetDataSetList.size()-1).getRowData();
            templateOidInExcel=rowData.get(shetNumber).getData().get(0);
            tempateName=rowData.get(shetNumber).getData().get(2);
            //templateOidInExcel = sheetDataSetList.get(sheetDataSetList.size()-1).getColName().get(sheetDataSetList.size()-i);
         }
         if(StringUtils.isBlank(templateOidInExcel) || !templateOidInExcel.equalsIgnoreCase(tempateOid)){
            sb.append("模板【"+tempateName+"】中第"+templateIdRowIndex.get(tempateOid)+"行数据不属于当前模板的数据，请核对!");
         }
      });
      if(StringUtils.isNotBlank(sb.toString())){
         throw  new Throwable(sb.toString());
      }
      if(codeClassifyTemplateVOList.size()>1){
         String message="模板【"+dataSet.getSheetName()+"】根据分类路径判断，分类存在多个模板";

         throw  new Throwable(message);
      }
      if(codeClassifyTemplateVOList.size()==0){
         String message="模板【"+dataSet.getSheetName()+"】根据数据分类路径判断，未匹配到对应模板";
         throw  new Throwable(message);
      }
      return codeClassifyTemplateVOList ;
   }
   /**
    * ä»Žå±žæ€§ä¸ŠèŽ·å–参照的内容
    * @param attrVO å±žæ€§çš„信息
    * @return å‚照的内容
    */
   private UIFormReferVO getReferVO(CodeClassifyTemplateAttrVO attrVO){
      UIFormReferVO referVO = null;
      if(StringUtils.isNotBlank(attrVO.getReferConfig())){
         referVO = JSONObject.parseObject(attrVO.getReferConfig(),UIFormReferVO.class);
      }else{
         referVO = new UIFormReferVO();
         referVO.setReferType(attrVO.getReferBtmId());
         referVO.setValueField(VciQueryWrapperForDO.OID_FIELD);
         referVO.setTextField("name");
      }
      return referVO;
   }

   /**
    * èŽ·å–参照中的值的字段
    * @param referVO å‚照的对象
    * @return é»˜è®¤ä¸ºOid，有多个的时候，获取第一个
    */
   private String getValueField(UIFormReferVO referVO){
      String showText = referVO.getValueField();
      if(StringUtils.isBlank(showText)){
         return "oid";
      }
      if(showText.contains(",")){
         //防止万一有多个，看看有没有oid
         List<String> strings = VciBaseUtil.str2List(showText);
         if(strings.contains("oid")){
            showText = "oid";
         }else{
            showText = strings.get(0);
         }
      }
      return showText;
   }

   /**
    * èŽ·å–参照中的显示内容的字段
    * @param referVO å‚照的对象
    * @return é»˜è®¤ä¸ºname，有多个的时候，获取第一个
    */
   private String getTextField(UIFormReferVO referVO){
      String showText = referVO.getTextField();
      if(StringUtils.isBlank(showText)){
         return "name";
      }
      if(showText.contains(",")){
         //防止万一有多个，看看有没有name
         List<String> strings = VciBaseUtil.str2List(showText);
         if(strings.contains("name")){
            showText = "name";
         }else{
            showText = strings.get(0);
         }
      }
      return showText;
   }
   /**
    * å¤„理枚举的显示对象
    * @param attrVOS æ¨¡æ¿å±žæ€§
    * @param dataList excel的数据内容
    * @param errorMap é”™è¯¯ä¿¡æ¯çš„映射
    */
   private void batchSwitchEnumAttrOnOrder(Collection<CodeClassifyTemplateAttrVO> attrVOS,List<ClientBusinessObject> dataList,
                                 Map<String,String> errorMap ) {
      Map<String, CodeClassifyTemplateAttrVO> dateAttrVOMap = attrVOS.stream().filter(
         s -> (StringUtils.isNotBlank(s.getEnumString()) || StringUtils.isNotBlank(s.getEnumId()))
      ).collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t));
      if (!CollectionUtils.isEmpty(dateAttrVOMap)) {
         dateAttrVOMap.forEach((attrId, attrVO) -> {
            dataList.stream().forEach(cbo -> {
               String text = cbo.getAttributeValue(attrId);
               if(StringUtils.isNotBlank(text)){
                  List<KeyValue> valueList = engineService.listComboboxItems(attrVO);
                  boolean fined = false;
                  for (int i = 0; i < valueList.size(); i++) {
                     KeyValue keyValue = valueList.get(i);
                     //if(keyValue.getValue().equalsIgnoreCase(text)){
                     if(keyValue.getValue().equalsIgnoreCase(text)||keyValue.getKey().equalsIgnoreCase(text)){
                        try {
                           cbo.setAttributeValue(attrId, keyValue.getKey());
                        }catch (Throwable e){
                           log.error("设置属性出错");
                        }
                        fined = true;
                        break;
                     }
                  }
                  if(!fined){
                     String rowIndex = cbo.getAttributeValue(IMPORT_ROW_INDEX);
                     errorMap.put(rowIndex,errorMap.getOrDefault(rowIndex,"") + ";属性[" + attrVO.getName() + "]的值不符合下拉的要求");
                  }
               }
            });
         });
      }
   }

   /**
    * æ‰¹é‡æ ¡éªŒæ•°æ®çš„信息
    * @param templateVO æ¨¡æ¿çš„显示对象
    * @param cboList æ•°æ®çš„内容
    */
   private void batchCheckRequiredAttrOnOrder(CodeClassifyTemplateVO templateVO,List<ClientBusinessObject> cboList,Map<String,String> errorMap){
      Map<String, CodeClassifyTemplateAttrVO> requiredAttrMap = templateVO.getAttributes().stream().filter(s ->
         VciBaseUtil.getBoolean(s.getRequireFlag()) && StringUtils.isBlank(s.getComponentRule()) && StringUtils.isBlank(s.getClassifyInvokeLevel())//不能是组合的和分类注入的
      ).collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t));
      //与MdmEngineServiceImpl里面的checkRequiredAttrOnOrder é€»è¾‘应该相似
      if(!CollectionUtils.isEmpty(requiredAttrMap)) {
         Set<String> nullRowIndex = cboList.stream().filter(cbo -> requiredAttrMap.keySet().stream().anyMatch(attrId -> StringUtils.isBlank(cbo.getAttributeValue(attrId)))).map(cbo -> cbo.getAttributeValue(IMPORT_ROW_INDEX)).collect(Collectors.toSet());
         if(!CollectionUtils.isEmpty(nullRowIndex)){
            String checkAttr = requiredAttrMap.values().stream().map(CodeClassifyTemplateAttrVO::getName).collect(Collectors.joining(","));
            nullRowIndex.stream().forEach(rowIndex->{
               errorMap.put(rowIndex,errorMap.getOrDefault(rowIndex,"") + ";校验规则不通过，有校验的属性为" + checkAttr);
            });
         }
      }
   }
   /**
    * å¤„理分类注入
    * @param attrVOS æ¨¡æ¿å±žæ€§
    * @param dataList excel的数据内容
    * @param classifyFullInfo åˆ†ç±»çš„全路径
    */
   private void batchSwitchClassifyAttrOnOrder(Collection<CodeClassifyTemplateAttrVO> attrVOS,List<ClientBusinessObject> dataList,
                                    CodeClassifyFullInfoBO classifyFullInfo,boolean isImPort) {
      Map<String, CodeClassifyTemplateAttrVO> dateAttrVOMap = attrVOS.stream().filter(
         s -> StringUtils.isNotBlank(s.getClassifyInvokeAttr()) && StringUtils.isNotBlank(s.getClassifyInvokeAttr())
      ).collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t));
      Map<String,CodeClassifyFullInfoBO> classifyFullInfoMap=new HashMap<>();
      classifyFullInfoMap.put(classifyFullInfo.getCurrentClassifyVO().getOid(),classifyFullInfo);
      if (!CollectionUtils.isEmpty(dateAttrVOMap)) {
         dataList.stream().forEach(cbo -> {
            dateAttrVOMap.forEach((attrId, attrVO) -> {
               //分类注入的编号或者名称，
               //层级包含指定层和最小层
               CodeClassifyVO classifyVO = null;
               if(!CodeLevelTypeEnum.MIN.getValue().equalsIgnoreCase(attrVO.getClassifyInvokeLevel()) && !"min".equalsIgnoreCase(attrVO.getClassifyInvokeLevel())) {
                  //指定了层级的
                  //注意，因为查询上级分类出来的层级是倒序的，即顶层节点是最大的值
                  if(isImPort){
                     if(!classifyFullInfoMap.containsKey(cbo.getAttributeValue(CODE_CLASSIFY_OID_FIELD))) {
                        CodeClassifyFullInfoBO currentClassifyFullInfo = classifyService.getClassifyFullInfo(cbo.getAttributeValue(CODE_CLASSIFY_OID_FIELD));
                        classifyFullInfoMap.put(currentClassifyFullInfo.getCurrentClassifyVO().getOid(), currentClassifyFullInfo);
                     }
                  }
                  CodeClassifyFullInfoBO newClassifyFullInfo= classifyFullInfoMap.get(cbo.getAttributeValue(CODE_CLASSIFY_OID_FIELD));
                  List<CodeClassifyVO> classifyVOS = newClassifyFullInfo.getParentClassifyVOs().stream().sorted(((o1, o2) -> o2.getDataLevel().compareTo(o1.getDataLevel()))).collect(Collectors.toList());
                  int level = VciBaseUtil.getInt(attrVO.getClassifyInvokeLevel());
                  if (classifyVOS.size()>=level && level > 0 ) {
                     classifyVO = classifyVOS.get(level-1);
                  }
               }else{
                  //当前的分类
                  classifyVO = classifyFullInfo.getCurrentClassifyVO();
               }
               try {
                  if (classifyVO == null) {
                     //说明层级有误
                     cbo.setAttributeValue(attrId, "分类树上没有层级[" + attrVO.getClassifyInvokeLevel() + "]");
                  } else {
                     Map<String, String> classifyDataMap = VciBaseUtil.objectToMapString(classifyVO);
                     String value = classifyDataMap.getOrDefault(attrVO.getClassifyInvokeAttr(), "");
                     cbo.setAttributeValue(attrId, value);
                  }
               } catch (Throwable e) {
                  log.error("设置属性错误", e);
               }
            });
         });
      }
   }
   /**
    * æ ¡éªŒå…³é”®å±žæ€§
    * @param classifyFullInfo åˆ†ç±»çš„全部信息
    * @param templateVO æ¨¡æ¿çš„内容，必须包含模板属性
    * @param cboList æ‰¹é‡çš„数据
    */
   private CodeImportResultVO batchCheckKeyAttrOnOrder(CodeClassifyFullInfoBO classifyFullInfo, CodeClassifyTemplateVO templateVO,
                                          List<ClientBusinessObject> cboList) {
      //与MdmEngineServiceImpl里的checkKeyAttrOnOrder相似
      //先获取关键属性的规则，也利用继承的方式
      CodeKeyAttrRepeatVO keyRuleVO = keyRuleService.getRuleByClassifyFullInfo(classifyFullInfo);
      //注意的是keyRuleVO可能为空，表示不使用规则控制
      //获取所有的关键属性
      Map<String/**属性的编号**/, CodeClassifyTemplateAttrVO> ketAttrMap = templateVO.getAttributes().stream().filter(s -> VciBaseUtil.getBoolean(s.getKeyAttrFlag())).collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t));

      boolean trimAll =keyRuleVO ==null?false: VciBaseUtil.getBoolean(keyRuleVO.getIgnoreallspaceflag());
      //全部去空的优先级大于去空
      boolean trim =keyRuleVO ==null?false:  VciBaseUtil.getBoolean(keyRuleVO.getIgnorespaceflag());
      boolean ignoreCase = keyRuleVO ==null?false: VciBaseUtil.getBoolean(keyRuleVO.getIgnorecaseflag());
      boolean ignoreWidth = keyRuleVO ==null?false: VciBaseUtil.getBoolean(keyRuleVO.getIgnorewidthflag());

      //1. æˆ‘们需要先判断excel导入的内容是否正确
      CodeImportResultVO resultVO = new CodeImportResultVO();
      resultVO.setKeyAttrRuleInfo(String.format(keyRuleVO ==null?"":"查询规则：去除空格--{0},忽略大小写--{1},忽略全半角--{2},忽略全部空格--{3}",
         new String[]{trim?"是":"否",ignoreCase?"是":"否",ignoreWidth?"是":"否",trimAll?"是":"否"}));
      resultVO.setSelfRepeatRowIndexList(getSelfRepeatRowIndex(ketAttrMap,cboList,keyRuleVO));
      if(!CollectionUtils.isEmpty(resultVO.getSelfRepeatRowIndexList())){
         //我们移除本身重复的数据
         cboList = cboList.stream().filter(s->!resultVO.getSelfRepeatRowIndexList().contains(s.getAttributeValue(IMPORT_ROW_INDEX))).collect(Collectors.toList());
      }
      //2.判断关键属性在系统里是否重复
      //因为数据量很大，所以得想办法并行
      //SessionInfo sessionInfo = VciBaseUtil.getCurrentUserSessionInfo();
      Map<String,List<BaseModel>> indexTODataMap=new HashMap<>();
      List<ClientBusinessObject> repeatDataMap = cboList.parallelStream().filter(cbo -> {
         //每行都得查询.如果其中出现了错误，我们就直接抛出异常，其余的显示
         //VciBaseUtil.setCurrentUserSessionInfo(sessionInfo);
         Map<String, String> conditionMap = new HashMap<>();
         ketAttrMap.forEach((attrId, attrVO) -> {
            String value =cbo.getAttributeValue(attrId.toLowerCase(Locale.ROOT));
            if (value == null) {
               value = "";
            }
            value= value.replace(REQUIRED_CHAR,SPECIAL_CHAR);
            engineService.wrapperKeyAttrConditionMap(value, keyRuleVO, attrId, trim, ignoreCase, ignoreWidth, trimAll, conditionMap);
         });
         if (!CollectionUtils.isEmpty(ketAttrMap)) {
            CodeTemplateAttrSqlBO sqlBO = engineService.getSqlByTemplateVO(classifyFullInfo.getTopClassifyVO().getBtmTypeId(), templateVO, conditionMap, null);
            boolean isKeyCheck= commonsMapper.queryCountBySql(sqlBO.getSqlCount()) > 0;
            if(isKeyCheck){
               List<Map<String,String>> newDataList=  commonsMapper.queryByOnlySqlForMap(sqlBO.getSqlUnPage());
               //List<ClientBusinessObject> newCboList=   ChangeMapTOClientBusinessObjects(newDataList);
               List<BaseModel> newCboList=new ArrayList<>();
               newDataList.stream().forEach(stringStringMap -> {
                  BaseModel baseModel=new BaseModel();
                  DefaultAttrAssimtUtil.copplyDefaultAttrAssimt(stringStringMap,baseModel);
                  newCboList.add(baseModel);
               });
               if(!CollectionUtils.isEmpty(newCboList)) {
                  indexTODataMap.put(cbo.getAttributeValue(IMPORT_ROW_INDEX), newCboList);
               }
            }
            return isKeyCheck;
         }else{
            return false;
         }
      }).collect(Collectors.toList());
      if(!CollectionUtils.isEmpty(repeatDataMap)){
         resultVO.setKeyAttrRepeatRowIndexList(repeatDataMap.stream().map(s->s.getAttributeValue(IMPORT_ROW_INDEX)).collect(Collectors.toSet()));
      }
      resultVO.setIndexTODataMap(indexTODataMap);
      //resultVO.setSuccess(true);
      return resultVO;
   }

   /**
    * æ£€æŸ¥åˆ†ç±»çš„路径是否存在
    * @param cboList ä¸šåŠ¡æ•°æ®
    * @param errorMap é”™è¯¯ä¿¡æ¯
    * @param pathMap è·¯å¾„和分类的映射
    */
   private void checkClassifyPathInHistory(List<ClientBusinessObject> cboList,
                                 Map<String,String> errorMap,     Map<String/**路径**/,CodeClassifyVO> pathMap,
                                 Map<String/**主键**/, String/**路径**/> childOidPathMap) {
      cboList.parallelStream().forEach(cbo -> {
         String classifyPath = cbo.getAttributeValue(CODE_CLASSIFY_OID_FIELD);
         //如果path为空，则表示是导入当前分类
         if(StringUtils.isBlank(classifyPath)){
            classifyPath = "#current#";
         }
         if ( !pathMap.containsKey(classifyPath)) {
            String row_index = cbo.getAttributeValue(IMPORT_ROW_INDEX);
            errorMap.put(row_index,errorMap.getOrDefault(row_index,"") + ";分类路径不存在");
         } else {
            //转一下分类的主键
            try {
               String classifyOid = pathMap.get(classifyPath).getOid();
               cbo.setAttributeValueWithNoCheck(CODE_CLASSIFY_OID_FIELD, classifyOid);
               cbo.setAttributeValue(CODE_FULL_PATH_FILED, childOidPathMap.getOrDefault(classifyOid,classifyPath));
            } catch (VciBaseException e) {
               log.error("设置属性的错误", e);
            }
         }
      });
   }

   /**
    * æ£€æŸ¥åˆ†ç±»ä»¥åŠå­åˆ†ç±»æ˜¯å¦éƒ½æœ‰ç¼–码规则
    * @param classifyVOMap åˆ†ç±»çš„显示对象映射
    * @param ruleOidMap è§„则的主键映射
    * @param unExistRuleClassifyOidList ä¸å­˜åœ¨ç¼–码规则的分类的主键
    */
   private void checkRuleOidInHistory( Map<String/**主键**/,CodeClassifyVO> classifyVOMap,  Map<String/**分类主键**/,String/**规则主键**/> ruleOidMap,
                              List<String> unExistRuleClassifyOidList   ){
      if(!CollectionUtils.isEmpty(classifyVOMap)){
         classifyVOMap.values().parallelStream().forEach(classifyVO->{
            if(StringUtils.isNotBlank(classifyVO.getCodeRuleOid())){
               ruleOidMap.put(classifyVO.getOid(),classifyVO.getCodeRuleOid());
            }else{
               //递归找上级
               List<String> ruleOidList = new ArrayList<>();
               recursionRule(classifyVOMap,classifyVO.getParentCodeClassifyOid(),ruleOidList);
               if(!CollectionUtils.isEmpty(ruleOidList)){
                  ruleOidMap.put(classifyVO.getOid(),ruleOidList.get(0));
               }else{
                  unExistRuleClassifyOidList.add(classifyVO.getOid());
               }
            }
         });
      }
      log.info(";;;;");
   }
   /**
    * é€’归找编码规则
    * @param classifyVOMap åˆ†ç±»çš„显示对象映射
    * @param classifyOid åˆ†ç±»çš„主键
    * @param ruleOidList è§„则的主键list
    */
   private void recursionRule(Map<String, CodeClassifyVO> classifyVOMap,String classifyOid,List<String> ruleOidList){
      if(classifyVOMap.containsKey(classifyOid)){
         CodeClassifyVO classifyVO = classifyVOMap.get(classifyOid);
         if(StringUtils.isNotBlank(classifyVO.getCodeRuleOid())){
            ruleOidList.add(classifyVO.getCodeRuleOid());
            return;
         }else{
            recursionRule(classifyVOMap,classifyVO.getParentCodeClassifyOid(),ruleOidList);
         }
      }else{
         Map<String, CodeClassifyVO> parentClassifyVOMap=new HashMap<>();
         CodeClassifyVO codeClassifyVO= this.classifyService.getObjectByOid(classifyOid);
         parentClassifyVOMap.put(codeClassifyVO.getOid(),codeClassifyVO);
         recursionRule(parentClassifyVOMap,codeClassifyVO.getOid(),ruleOidList);
      }
   }

   /**
    * èŽ·å–子分类的路径
    * @param classifyFullInfo åˆ†ç±»å…¨éƒ¨ä¿¡æ¯
    * @param fullPath åˆ†ç±»çš„全路径
    * @return å­åˆ†ç±»çš„路径，key是分类的主键
    */
   private Map<String/**分类的主键**/,String/**分类路径**/> getChildClassifyPathMap(CodeClassifyFullInfoBO classifyFullInfo,String fullPath){
      List<CodeClassifyVO> childPathVOs = classifyService.listChildrenClassify(classifyFullInfo.getCurrentClassifyVO().getOid(), true, VciQueryWrapperForDO.OID_FIELD, true);
      Map<String/**分类的主键**/,String/**分类的主键**/> childOidPathMap = new ConcurrentHashMap<>();
      if(!CollectionUtils.isEmpty(childPathVOs)){
         childPathVOs.parallelStream().forEach(childPath->{
            // String thisClassifyPath = fullPath + "##" + childPath.getPath().replace("#" + classifyFullInfo.getCurrentClassifyVO().getOid() + "#","").replace("#","##");
            List<String> list=Arrays.asList(childPath.getPath().split("#"));
            List<String> newPahtList=  list.stream().sorted(Comparator.comparing(s -> s,Comparator.reverseOrder())).collect(Collectors.toList());
            String thisClassifyPath=StringUtils.join(newPahtList,"##")+fullPath;
            childOidPathMap.put(childPath.getOid(),thisClassifyPath);
         });
      }
      return childOidPathMap;
   }


   /**
    * èŽ·å–导入的内容中关键属性重复的行号
    * @param ketAttrMap å…³é”®å±žæ€§çš„映射
    * @param dataList å¯¼å…¥çš„数据
    * @param keyRuleVO å…³é”®å±žæ€§æŽ§åˆ¶è§„则
    * @return é‡å¤çš„行号
    */
   private Set<String> getSelfRepeatRowIndex(Map<String/**属性的编号**/, CodeClassifyTemplateAttrVO> ketAttrMap,
                                   List<ClientBusinessObject> dataList,CodeKeyAttrRepeatVO keyRuleVO){
      Set<String> selfRepeatRowIndexList = new CopyOnWriteArraySet<>();
      boolean trimAll =keyRuleVO ==null?false: VciBaseUtil.getBoolean(keyRuleVO.getIgnoreallspaceflag());
      //全部去空的优先级大于去空
      boolean trim =keyRuleVO ==null?false:  VciBaseUtil.getBoolean(keyRuleVO.getIgnorespaceflag());
      boolean ignoreCase = keyRuleVO ==null?false: VciBaseUtil.getBoolean(keyRuleVO.getIgnorecaseflag());
      boolean ignoreWidth = keyRuleVO ==null?false: VciBaseUtil.getBoolean(keyRuleVO.getIgnorewidthflag());
      //必须将属性按照顺序排序好
      List<CodeClassifyTemplateAttrVO> attrVOList = ketAttrMap.values().stream().sorted(((o1, o2) -> o1.getOrderNum().compareTo(o2.getOrderNum()))).collect(Collectors.toList());
      Map<String/**行号**/,String/**关键属性的组合内容**/> rowIndexKeyStringMap = new HashMap<>();
      dataList.parallelStream().forEach(cbo-> {
         String rowIndex = cbo.getAttributeValue(IMPORT_ROW_INDEX);
         StringBuilder sb = new StringBuilder();
         for (int i = 0; i < attrVOList.size(); i++) {
            CodeClassifyTemplateAttrVO attrVO = attrVOList.get(i);
            String attrId = attrVO.getId().toLowerCase(Locale.ROOT);
            String value = cbo.getAttributeValue( attrId);
            if (value == null) {
               value = "";
            }
            if(trim){
               value = value.trim();
            }
            if(trimAll){
               value = value.replace(" ","");
            }
            if(ignoreCase){
               value = value.toLowerCase(Locale.ROOT);
            }
            if(ignoreWidth){
               value = VciBaseUtil.toDBC(value);
            }
            sb.append(value).append("${ks}");
         }
         String keyString = sb.toString();
         if(rowIndexKeyStringMap.containsValue(keyString) && StringUtils.isNotBlank(keyString)){
            selfRepeatRowIndexList.add(rowIndex);
         }else {
            rowIndexKeyStringMap.put(rowIndex, sb.toString());
         }
      });
      //因为只是关键属性重复，所以我们不能重复的多条选一条来报错
      return selfRepeatRowIndexList;
   }
   /**
    * excel的标题上获取字段所在的位置
    * @param titleRowData æ ‡é¢˜çš„内容
    * @param attrNameIdMap æ¨¡æ¿ä¸­å±žæ€§åç§°å’Œè‹±æ–‡çš„映射
    * @param fieldIndexMap ä½ç½®å’Œè‹±æ–‡å­—段的映射
    */
   private void getFieldIndexMap(List<String> titleRowData,Map<String/**名称**/,String/**字段名**/> attrNameIdMap,Map<Integer/**位置**/,String/**英文名字**/> fieldIndexMap){
      for (int i = 0; i < titleRowData.size(); i++) {
         String title = titleRowData.get(i);
         String id = attrNameIdMap.getOrDefault(title.replace(KEY_ATTR_CHAR,"").replace(REQUIRED_CHAR
            ,""),"");
         if(com.alibaba.cloud.commons.lang.StringUtils.isBlank(id) && "分类路径".equalsIgnoreCase(title)){
            id = CODE_CLASSIFY_OID_FIELD;
         }
         if(com.alibaba.cloud.commons.lang.StringUtils.isBlank(id) && "码段宽度".equalsIgnoreCase(title)){
            id = CODE_SEC_LENGTH_FIELD;
         }
         if(com.alibaba.cloud.commons.lang.StringUtils.isBlank(id) && "企业编码".equalsIgnoreCase(title)){
            id = CODE_FIELD;
         }
         if(com.alibaba.cloud.commons.lang.StringUtils.isNotBlank(id)){
            fieldIndexMap.put(i,id);
         }
      }
   }
   private List<ClientBusinessObject> ChangeMapTOClientBusinessObjects(List<Map<String,String>> oldDataMap){
      List<ClientBusinessObject> clientBusinessObjectList=new ArrayList<>();
      oldDataMap.stream().forEach(dataMap->{
         ClientBusinessObject clientBusinessObject=new ClientBusinessObject();
         DefaultAttrAssimtUtil.copplyDefaultAttrAssimt(dataMap,clientBusinessObject);
         for (String key:dataMap.keySet()){
            Object value= dataMap.getOrDefault(key,"");
            clientBusinessObject.setAttributeValue(key,value.toString());
         }
         clientBusinessObjectList.add(clientBusinessObject);
      });
      return clientBusinessObjectList;
   }

   /***
    * æ ¹æ®ä¸åŒæ¨¡æ¿ç»„织execl数据
    * @param dataSet
    * @param pathMap
    * @param errorMap
    */
   private void createExeclClassData(SheetDataSet dataSet,Map<String/**路径**/, CodeClassifyVO> pathMap,Map<String,String>errorMap,List<CodeImprotDataVO> codeClassifyDatas){

      Map<String,CodeImprotDataVO> pathDatas=new HashMap<>();
      List<String> titleRowData= dataSet.getColName();
      List<SheetRowData>  rowDataList= dataSet.getRowData();
      LinkedHashMap<String,CodeClassifyTemplateVO> codeClassifyTemplateVOMap=new LinkedHashMap <String,CodeClassifyTemplateVO>();
      LinkedHashMap<String,CodeRuleVO> codeRuleVOVOMap=new LinkedHashMap <String,CodeRuleVO>();

      for (int i=0;i<titleRowData.size();i++){
         String title= titleRowData.get(i);
         if(title.equals("分类路径")) {
            int finalI = i;
            rowDataList.stream().forEach(sheetRowData -> {
               CodeImprotDataVO dataVO=new CodeImprotDataVO();
               String Path = sheetRowData.getData().get(finalI);
               String rowIndex=sheetRowData.getRowIndex();
               Map<Integer, String> execlData= sheetRowData.getData();
               CodeClassifyTemplateVO newTemplateVO=new CodeClassifyTemplateVO();
               CodeRuleVO codeRuleVO=new CodeRuleVO();
               if(StringUtils.isEmpty(Path)){
                  Path="#current#";
               }

               if(pathMap.containsKey(Path)){
                  CodeClassifyVO codeClassifyVO=pathMap.get(Path);
                  if(codeClassifyTemplateVOMap.containsKey(Path)){
                     newTemplateVO=  codeClassifyTemplateVOMap.get(Path);
                     codeRuleVO=  codeRuleVOVOMap.get(Path);
                     if(newTemplateVO==null||StringUtils.isBlank(newTemplateVO.getOid())){
                        errorMap.put(rowIndex,"第"+rowIndex+"行，分类路径未查询到相应的分类模板");
                     }
                     if(codeRuleVO==null||StringUtils.isBlank(codeRuleVO.getOid())){
                        errorMap.put(rowIndex,"第"+rowIndex+"行，分类路径未查询到相应的分类规则");
                     }
                  }else{
                     newTemplateVO =engineService.getUsedTemplateByClassifyOid(codeClassifyVO.getOid());
                     if(newTemplateVO==null||StringUtils.isBlank(newTemplateVO.getOid())){
                        errorMap.put(rowIndex,"第"+rowIndex+"行，分类路径未查询到相应的分类模板");
                     }
                     codeRuleVO=engineService.getCodeRuleByClassifyOid(codeClassifyVO.getOid());
                     if(codeRuleVO==null||StringUtils.isBlank(codeRuleVO.getOid())){
                        errorMap.put(rowIndex,"第"+rowIndex+"行，分类路径未查询到相应的分类规则");
                     }
                  }
                  if(pathMap.containsKey(Path)){
                     dataVO=pathDatas.getOrDefault(Path,dataVO);
                  }
                  dataVO.setTemplateOid(newTemplateVO==null?"":newTemplateVO.getOid());
                  dataVO.setCodeClassifyTemplateVO(newTemplateVO);
                  dataVO.setCodeClassifyVO(codeClassifyVO);
                  dataVO.setCodeRuleVO(codeRuleVO);
                  dataVO.setRowIndex(rowIndex);
                  dataVO.setCodeClassifyOid(codeClassifyVO.getOid());//设置分类oid
                  dataVO.setCodeRuleOid(codeRuleVO==null?"":codeRuleVO.getOid());
                  createExeclClassData(titleRowData,newTemplateVO,execlData,dataVO);
                  pathDatas.put(Path,dataVO);
                  codeClassifyTemplateVOMap.put(Path, newTemplateVO);
                  codeRuleVOVOMap.put(Path,codeRuleVO);
               }else{
                  errorMap.put(rowIndex,"第"+rowIndex+"行，分类路径未查询到相应的分类");
               }
            });
            break;
         }
      }
      List <CodeImprotDataVO> newCodeImprotDataVO= pathDatas.values().stream().collect(Collectors.toList());
      codeClassifyDatas.addAll(newCodeImprotDataVO);
      log.info("222");
   }
   /***
    *  @param titleRowData
    * @param newTemplateVO
    * @param execlData
    * @param codeImprotDataVO
    */
   private void createExeclClassData(List<String> titleRowData, CodeClassifyTemplateVO newTemplateVO, Map<Integer, String> execlData, CodeImprotDataVO codeImprotDataVO){
      //除去默认的属性.还有只有表单显示的字段才导入
      List<CodeClassifyTemplateAttrVO> attrVOS = newTemplateVO.getAttributes().stream().filter(s ->
         !DEFAULT_ATTR_LIST.contains(s.getId()) && VciBaseUtil.getBoolean(s.getFormDisplayFlag())
      ).collect(Collectors.toList());
      Map<String/**中文名称**/, String/**英文名称**/> attrNameIdMap = attrVOS.stream().collect(Collectors.toMap(s -> s.getName(), t -> t.getId()));
      List<String> fields=new ArrayList<>();
      Map<String,String> filedValueMap=new HashMap<>();
      List<String> colNames=new ArrayList<>();
      for (int i = 0; i < titleRowData.size(); i++) {
         String title = titleRowData.get(i);
         title=title.replace(KEY_ATTR_CHAR,"").replace(REQUIRED_CHAR,"");
         String id = attrNameIdMap.getOrDefault(title,"");
         if(StringUtils.isBlank(id) && "分类路径".equalsIgnoreCase(title)){
            id = CODE_CLASSIFY_OID_FIELD;
         }
         if(StringUtils.isBlank(id) && "码段宽度".equalsIgnoreCase(title)){
            id = CODE_SEC_LENGTH_FIELD;
         }
         if(StringUtils.isBlank(id) && "企业编码".equalsIgnoreCase(title)){
            id = CODE_FIELD;
         }
         if(StringUtils.isNotBlank(id)){
            // fieldIndexMap.put(i,id);id
            fields.add(id);
            colNames.add(title);
            String value= StringUtils.isNotBlank(execlData.get(i))?execlData.get(i):"";
            filedValueMap.put(id,value);

         }
      }
      // filedValueMap.put(CODE_CLASSIFY_OID_FIELD,codeImprotDataVO.getCodeClassifyOid());//将当前分类oid存入字段中
      filedValueMap.put("codeclassifyid",codeImprotDataVO.getCodeClassifyOid());
      filedValueMap.put(IMPORT_ROW_INDEX,codeImprotDataVO.getRowIndex());
      filedValueMap.put("codetemplateoid",newTemplateVO.getOid());
      codeImprotDataVO.setFields(fields);
      codeImprotDataVO.setColNames(colNames);
      codeImprotDataVO.getDatas().add(filedValueMap);
   }
   /***
    * æ­£ç¡®é”™è¯¯æ•°æ®redis缓存
    * @param uuid
    * @param templateVO
    * @param rowIndexCbo
    * @param dataSet
    * @param fieldIndexMap
    * @param errorMap
    * @param isok
    */
   private void createRedisDatas(String uuid,CodeClassifyTemplateVO templateVO,Map<String,ClientBusinessObject> rowIndexCbo, SheetDataSet dataSet, Map<Integer/**列号**/,String/**字段的名称**/> fieldIndexMap,Map<String,String> errorMap,boolean isok){
      List<SheetRowData>  needsheetRowDataList =new ArrayList<>();
      if(errorMap.size()>0) {
         //要把以上的错误的都抛出后，再继续处理时间和组合规则
         needsheetRowDataList = dataSet.getRowData().stream().filter(cbo -> {
            String rowIndex=cbo.getRowIndex();
            return  isok? !errorMap.containsKey(rowIndex):errorMap.containsKey(rowIndex);
         }).collect(Collectors.toList());

      }else{
         needsheetRowDataList= dataSet.getRowData();
      }
      Map<String/**中文名称**/, SheetRowData/**英文名称**/> rowIdexDataMap = needsheetRowDataList.stream().collect(Collectors.toMap(s -> s.getRowIndex(), t -> t,(o1, o2)->o2));
      Map<String,CodeImprotDataVO> clsfDataMap=new HashMap<>();
      rowIndexCbo .forEach((rowIndex, cbo) -> {
         CodeImprotDataVO codeImprotDataVO = new CodeImprotDataVO();
         codeImprotDataVO.setTemplateOid(templateVO.getOid());
         List<Map<String, String>> dataList = new ArrayList<>();
         if(rowIdexDataMap.containsKey(rowIndex)){
            SheetRowData sheetRowData=rowIdexDataMap.get(rowIndex);
            Map<String, String> dataMap = new HashMap<>();
            Map<Integer, String> data = sheetRowData.getData();
            fieldIndexMap.forEach((integer, s) -> {
               String field = fieldIndexMap.get(integer);
               if (data.containsKey(integer)) {
                  String vlues = data.get(integer);
                  dataMap.put(field, vlues);
               }
            });
            dataMap.put("oid",cbo.getOid());
            dataList.add(dataMap);
         }
         if(clsfDataMap.containsKey(templateVO.getOid())){
            codeImprotDataVO=clsfDataMap.get(templateVO.getOid());
            dataList.addAll(codeImprotDataVO.getDatas());
         }
         codeImprotDataVO.setColNames(dataSet.getColName());
         codeImprotDataVO.setDatas(dataList);
         clsfDataMap.put(templateVO.getOid(),codeImprotDataVO);
      });
      if(!CollectionUtils.isEmpty(clsfDataMap)) {
         Collection codeImprotDataVOS=clsfDataMap.values();
         List<CodeImprotDataVO> codeImprotDataVOList=new ArrayList<>();
         codeImprotDataVOList.addAll(codeImprotDataVOS);
         bladeRedis.set(uuid+"-"+templateVO.getOid(), codeImprotDataVOList);
         bladeRedis.expire(uuid+"-"+templateVO.getOid(),BATCHADD_REDIS_TIME);//redis过期时间
      }
   }

   /******
    * æ ¹æ®ç¼–码规则缓存数据
    * @param uuid
    * @param codeImprotDataVOs
    * @param errorMap
    * @param isok
    */
   private void createRedisDatas(String uuid, List<CodeImprotDataVO> codeImprotDataVOs, Map<String, String> errorMap, boolean isok){
      codeImprotDataVOs.stream().forEach(codeImprotDataVO -> {
         List<Map<String, String>>  dataLists=new ArrayList<>();
         CodeImprotDataVO newCodeImprotDataVO=new CodeImprotDataVO();
         if(errorMap.size()>0) {
            //要把以上的错误的都抛出后，再继续处理时间和组合规则
            dataLists = codeImprotDataVO.getDatas().stream().filter(cbo -> {
               String rowIndex=cbo.get(IMPORT_ROW_INDEX);
               String msg=StringUtils.isBlank(errorMap.get(rowIndex))?"":errorMap.get(rowIndex);
               cbo.put("errorMsg",msg);
               return  isok? !errorMap.containsKey(rowIndex):errorMap.containsKey(rowIndex);
            }).collect(Collectors.toList());

         }else{
            dataLists= codeImprotDataVO.getDatas();
         }
         BeanUtilForVCI.copyPropertiesIgnoreCase(codeImprotDataVO,newCodeImprotDataVO);
         newCodeImprotDataVO.setDatas(dataLists);
         List<CodeImprotDataVO> codeImprotDataVOList=new ArrayList<>();
         codeImprotDataVOList.add(newCodeImprotDataVO);
         /***update æ›´æ”¹æˆä»¥è§„则分组*****/
         String codeRuleOid=codeImprotDataVO.getCodeRuleOid();
         log.info(uuid+"-"+codeRuleOid+":条目数"+codeImprotDataVOList.size());
         if(codeImprotDataVOList.size()>0) {
            bladeRedis.set(uuid + "-" + codeRuleOid, codeImprotDataVOList);
            bladeRedis.expire(uuid + "-" + codeRuleOid, BATCHADD_REDIS_TIME);//redis过期时间

         }

         /*** String codeClassifyOid=codeImprotDataVO.getCodeClassifyOid();

          redisService.setCacheList(uuid+"-"+codeClassifyOid,codeImprotDataVOList);
          logger.info(uuid+"-"+codeClassifyOid+":条目数"+codeImprotDataVOList.size());
          redisService.expire(uuid+"-"+codeClassifyOid,BATCHADD_REDIS_TIME);//redis过期时间***/
      });
   }

   /****
    * æ•°æ®ç›¸ä¼¼é¡¹æ•°æ®æ ¡éªŒredis缓存
    * @param codeClassifyOid
    * @param templateVO
    * @param cboList
    * @param resembleMap
    * @param btmtypeid
    * @param dataResembleVOS
    */
   private void bathcResembleQuery(String codeClassifyOid, CodeClassifyTemplateVO templateVO, List<ClientBusinessObject> cboList,Map<String,String>resembleMap,String btmtypeid,List<DataResembleVO> dataResembleVOS){
      CodeClassifyFullInfoBO fullInfoBO = classifyService.getClassifyFullInfo(codeClassifyOid);
      Map<String, String> conditionMap = new HashMap<>();
      CodeResembleRuleVO resembleRuleVO = Optional.ofNullable(engineService.getUseResembleRule(fullInfoBO, fullInfoBO.getCurrentClassifyVO())).orElseGet(() -> new CodeResembleRuleVO());
      //需要获取是否有相似查询属性
      Map<String, CodeClassifyTemplateAttrVO> attrVOs = templateVO.getAttributes().stream().filter(s -> VciBaseUtil.getBoolean(s.getSameRepeatAttrFlag())).collect(Collectors.toMap(s -> s.getId(), t -> t));
      if (CollectionUtils.isEmpty(attrVOs)) {
         return;
      }
      Map<String,CodeImprotResembleVO> codeImprotResembleVOMap=new HashMap<>();
      List<CodeImprotResembleVO> codeImprotResembleVOList=new ArrayList<>();
      Map<String,String> rowIndePathMap=new HashMap<>();
      cboList.stream().forEach(clientBusinessObject -> {
         CodeImprotResembleVO codeImprotResembleVO=new CodeImprotResembleVO();
         final String[] path = {""};
         List<String> fieldList=new ArrayList<>();
         List<String> rowIndeList=new ArrayList<>();
         String rowIndex = clientBusinessObject.getAttributeValue(IMPORT_ROW_INDEX);
         attrVOs.forEach((attrId, attrVO) -> {
            String value="";
                /*if (VciQueryWrapperForDO.BASIC_FIELD_MAP.containsKey(attrId)) {
                    value = WebUtil.getStringValueFromObject(WebUtil.getValueFromField(WebUtil.getFieldForObject(attrId, orderDTO.getClass()).getName(), orderDTO));
                }else {*/
            value= clientBusinessObject.getAttributeValue(attrId);
            // }
            fieldList.add(attrId);
            value=StringUtils.isBlank(value)?"":value;
            path[0] +=value+"#";
            engineService.wrapperResembleConditionMap(value, resembleRuleVO, attrId, conditionMap);
         });
         List<Map<String,String>> dataMap=new ArrayList<>();
         if(codeImprotResembleVOMap.containsKey(path[0])) {
            codeImprotResembleVO=codeImprotResembleVOMap.get(path[0]);
            rowIndeList=codeImprotResembleVO.getRownIndex();
            dataMap=  codeImprotResembleVO.getDataList();
            resembleMap.put(rowIndex, "存在相似数据");
         }else{
            if (!CollectionUtils.isEmpty(conditionMap)) {
               Map<String, String> andConditionMap = new HashMap<>();
               andConditionMap.put("lastr", "1");
               andConditionMap.put("lastv", "1");
               conditionMap.putAll(andConditionMap);
               PageHelper pageHelper = new PageHelper(-1);
               pageHelper.addDefaultDesc("id");
               CodeTemplateAttrSqlBO sqlBO = engineService.getSqlByTemplateVO(btmtypeid, templateVO, conditionMap, pageHelper);
               List<Map<String,String>> dataMapList=commonsMapper.queryByOnlySqlForMap(sqlBO.getSqlUnPage());
               List<ClientBusinessObject> resembleCboList=   ChangeMapTOClientBusinessObjects(dataMapList);
               if(!CollectionUtils.isEmpty(resembleCboList)) {
                  List<Map<String, String>> finalDataMap = dataMap;
                  resembleCboList.stream().forEach(cbo->{
                     Map<String,String> resembDataMap=new HashMap<>();
                     fieldList.stream().forEach(field->{
                        String value=cbo.getAttributeValue(field);
                        value=StringUtils.isBlank(value)?"":value;
                        resembDataMap.put(field,value);
                     });
                     resembDataMap.put("codetemplateoid",templateVO.getOid());
                     resembDataMap.put("id",StringUtils.isBlank(cbo.getAttributeValue("id"))?"":cbo.getAttributeValue("id"));
                     resembDataMap.put("rowIndex","");
                     resembDataMap.put("oid",cbo.getOid());
                     finalDataMap.add(resembDataMap);
                  });
                  resembleMap.put(rowIndex, "存在相似数据");

               }
            }
         }
         rowIndePathMap.put(rowIndex,path[0]);
         rowIndeList.add(rowIndex);
         codeImprotResembleVO.setPath(path[0]);
         codeImprotResembleVO.setRownIndex(rowIndeList);
         codeImprotResembleVO.setConditionMap(conditionMap);
         codeImprotResembleVO.setFields(fieldList);
         codeImprotResembleVO.setDataList(dataMap);
         codeImprotResembleVOMap.put(path[0],codeImprotResembleVO);
      });
      Map<String, ClientBusinessObject> cboMap = cboList.stream().filter(cbo -> cbo != null).collect(Collectors.toList()).stream().collect(Collectors.toMap(s -> s.getAttributeValue((IMPORT_ROW_INDEX)), t -> t));
      if(!CollectionUtils.isEmpty(rowIndePathMap)){
         rowIndePathMap.forEach((rowIndex, path) -> {
            if(codeImprotResembleVOMap.containsKey(path)){
               CodeImprotResembleVO codeImprotResembleVO=  codeImprotResembleVOMap.get(path);
               List<String> fieldList=codeImprotResembleVO.getFields();
               List<String> rownIndexList= codeImprotResembleVO.getRownIndex();
               List<String> newRownIndexList = rownIndexList.stream().filter(cbo -> {
                  return rowIndex!=cbo;
               }).collect(Collectors.toList());
               newRownIndexList.stream().forEach(s -> {
                  resembleMap.put(s, "存在相似数据");
               });
               List<Map<String, String>>newDataList=new ArrayList<>();
               DataResembleVO dataResembleVO=new DataResembleVO();
               dataResembleVO.setOid(cboMap.get(rowIndex).getOid());
               List<ClientBusinessObject> needSaveCboList = cboList.stream().filter(cbo -> {
                  String newRowIndex = cbo.getAttributeValue(IMPORT_ROW_INDEX);
                  return rownIndexList.contains(newRowIndex)&&(!newRowIndex.equalsIgnoreCase(rowIndex));
               }).collect(Collectors.toList());
               if(!CollectionUtils.isEmpty(needSaveCboList)) {
                  needSaveCboList.stream().forEach(cbo -> {
                     String newRowIndex = cbo.getAttributeValue(IMPORT_ROW_INDEX);
                     Map<String, String> resembDataMap = new HashMap<>();
                     fieldList.stream().forEach(field -> {
                        String value = cbo.getAttributeValue(field);
                        value = StringUtils.isBlank(value) ? "" : value;
                        resembDataMap.put(field, value);
                     });
                     resembDataMap.put("codetemplateoid",templateVO.getOid());
                     resembDataMap.put("id",StringUtils.isBlank(cbo.getAttributeValue("id"))?"":cbo.getAttributeValue("id"));
                     resembDataMap.put("rowIndex", newRowIndex);
                     resembDataMap.put("oid",cbo.getOid());
                     newDataList.add(resembDataMap);
                  });
               }
               List<Map<String, String>>dataList=codeImprotResembleVO.getDataList();
               newDataList.addAll(dataList);
               dataResembleVO.setDataList(newDataList);
               dataResembleVOS.add(dataResembleVO);
            }
         });
      }
   }

   /***
    * å­˜å‚¨åˆ†ç±»å¯¹è±¡åŠå…¶åˆ—名
    * @param uuid
    * @param templateVOList
    * @param dataSet
    * @param fieldIndexMap
    * @param iscContain
    */
   private  void createRedisByCodeClassify(String uuid,CodeClassifyTemplateVO templateVOList,SheetDataSet dataSet, Map<Integer/**列号**/,String/**字段的名称**/> fieldIndexMap,boolean iscContain){
      List<ColumnVO> columnVOList = new ArrayList<>();
      List<String> outNameList = dataSet.getColName();
      fieldIndexMap.forEach((integer, s) -> {
         ColumnVO columnVOS = new ColumnVO();
         String field = fieldIndexMap.get(integer);
         String outName = outNameList.get(integer);
         columnVOS.setField(field);
         columnVOS.setTitle(outName);
         columnVOList.add(columnVOS);
      });
      CodeImportTemplateVO codeImportTemplateVO=new CodeImportTemplateVO();
      codeImportTemplateVO.setCodeClassifyTemplateVO(templateVOList);
      codeImportTemplateVO.setCloNamesList(columnVOList);
      List<CodeImportTemplateVO> codeImportTemplateVOs= new ArrayList<>();

      codeImportTemplateVOs.add(codeImportTemplateVO);
      if(codeImportTemplateVOs.size()>0) {
         bladeRedis.set(uuid, codeImportTemplateVOs);
         bladeRedis.expire(uuid, BATCHADD_REDIS_TIME);//redis过期时间
      }
   }
   /**
    * æ‹·è´ä¸šåŠ¡ç±»åž‹åˆ°map
    * @param cbo ä¸šåŠ¡æ•°æ®
    * @param map map
    */
   public static void copyValueToMapFromCbos(ClientBusinessObject cbo,Map<String,String> map){
      if(cbo!=null){
         copyValueToMapFromBos(cbo,map);
      }
   }

   /**
    * æ‹·è´ä¸šåŠ¡ç±»åž‹åˆ°map
    * @param bo ä¸šåŠ¡æ•°æ®
    * @param map map
    */
   public static void copyValueToMapFromBos(ClientBusinessObject bo,Map<String,String> map){
      if(bo!=null ){
         //先把所有的字段映射找到
         AttributeValue[] newAList = bo.newAttrValList;
         AttributeValue[] hisAList = bo.hisAttrValList;
         if(hisAList!=null&&hisAList.length>0){//
            for(int i = 0 ; i < hisAList.length;i++){
               AttributeValue av = hisAList[i];
               String attrName = av.attrName.toLowerCase();
               map.put(attrName, av.attrVal);
            }
         }
         if(newAList!=null&&newAList.length>0){//NEW的优先级高些
            for(int i = 0 ; i < newAList.length;i++){
               AttributeValue av = newAList[i];
               String attrName = av.attrName.toLowerCase();
               map.put(attrName, av.attrVal);
            }
         }
      }
   }

}