ubcs.git - Gitblit

			@@ -1,14 +1,19 @@
			package com.vci.ubcs.code.service.impl;

			import com.alibaba.fastjson.JSON;
			import com.alibaba.fastjson.JSONObject;
			import com.alibaba.nacos.common.utils.StringUtils;
			import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
			import com.baomidou.mybatisplus.core.toolkit.Wrappers;
			import com.google.protobuf.ServiceException;
			import com.vci.ubcs.code.applyjtcodeservice.entity.DockingPreAttrMapping;
			import com.vci.ubcs.code.applyjtcodeservice.feign.IMdmInterJtClient;
			import com.vci.ubcs.code.applyjtcodeservice.vo.DockingPreAttrMappingVO;
			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.constant.MdmEngineConstant;
			import com.vci.ubcs.code.dto.*;
			import com.vci.ubcs.code.entity.CodeAllCode;
			import com.vci.ubcs.code.enumpack.CodeDefaultLC;
			import com.vci.ubcs.code.enumpack.CodeLevelTypeEnum;
			@@ -36,6 +41,7 @@
			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.util.SaveLogUtil;
			import com.vci.ubcs.starter.web.constant.QueryOptionConstant;
			import com.vci.ubcs.starter.web.enumpck.BooleanEnum;
			import com.vci.ubcs.starter.web.enumpck.UserSecretEnum;
			@@ -45,6 +51,7 @@
			import com.vci.ubcs.starter.web.util.*;
			import lombok.RequiredArgsConstructor;
			import lombok.extern.slf4j.Slf4j;
			import oracle.sql.TIMESTAMP;
			import org.apache.commons.collections4.map.HashedMap;
			import org.apache.poi.hssf.usermodel.HSSFRichTextString;
			import org.apache.poi.hssf.usermodel.HSSFWorkbook;
			@@ -53,8 +60,10 @@
			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.secure.utils.AuthUtil;
			import org.springblade.core.tool.api.R;
			import org.springblade.core.tool.utils.Func;
			import org.springblade.core.tool.utils.StringUtil;
			import org.springframework.beans.BeanUtils;
			import org.springframework.beans.factory.annotation.Autowired;
			import org.springframework.beans.factory.annotation.Value;
			@@ -62,14 +71,24 @@
			import org.springframework.transaction.annotation.Transactional;
			import org.springframework.util.CollectionUtils;
			import javax.annotation.Resource;
			import java.beans.BeanInfo;
			import java.beans.Introspector;
			import java.beans.PropertyDescriptor;
			import java.io.File;
			import java.io.IOException;
			import java.lang.reflect.Method;
			import java.math.BigDecimal;
			import java.text.MessageFormat;
			import java.text.SimpleDateFormat;
			import java.time.LocalDateTime;
			import java.time.ZoneId;
			import java.time.ZonedDateTime;
			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.concurrent.atomic.AtomicReference;
			import java.util.stream.Collectors;

			import static com.alibaba.druid.util.FnvHash.Constants.LIMIT;
			@@ -97,18 +116,25 @@

			@Value("${batchadd.redis.time:6000000}")
			public int BATCHADD_REDIS_TIME;

			@Value("${batchadd.import_data_limit:5001}")
			private Integer IMPORT_DATA_LIMIT;

			/**
			* 主题库分类的服务
			*/
			@Resource
			private ICodeClassifyService classifyService;

			@Resource
			private MdmEngineService mdmEngineService;

			/**
			* 通用查询
			*/
			@Resource
			private CommonsMapper commonsMapper;

			/****
			* 码值服务
			*/
			@@ -166,11 +192,16 @@
			*/
			@Resource
			private IWebSecretClient secretService;
			/**
			* 日志保存工具类
			*/
			@Autowired
			private SaveLogUtil saveLogUtil;

			/**
			* 导出的十万条
			* 客户现场excel为老版本，导出的总数限制为65535
			*/
			public static final int EXPORT_LIMIT = 100000;
			public static final int EXPORT_LIMIT = 65535;

			/**
			* 批量申请：选取选中分类下的所有模板关键属性，相似属性，必填属性，写入execl中
			@@ -346,10 +377,12 @@
			@Override
			public String createImportExcel(String codeClassifyOid, boolean isHistory) {
			List<CodeClassifyTemplateVO> templateVOList=new ArrayList<>();

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

			CodeClassifyVO codeClassifyVO = classifyService.getObjectByOid(codeClassifyOid);

			//获取码段宽度
			String secWidth = getCodeSegmentWidth(codeClassifyVO.getOid());

			if(isHistory){
			templateVOList= templateService.childTemplates(codeClassifyOid);
			@@ -389,17 +422,17 @@
			&& (isHistory \|\| VciBaseUtil.getBoolean(s.getFormDisplayFlag()))
			).collect(Collectors.toList());

			if (CollectionUtils.isEmpty(templateAttrVOS)) {
			throw new VciBaseException("模板没有配置任何【表单显示】为【是】的属性");
			}
			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():"企业编码"));
			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():"企业编码",idAttrVOList.get(0).getId()));
			}
			for (int i = 0; i < templateAttrVOS.size(); i++) {
			CodeClassifyTemplateAttrVO attrVO = templateAttrVOS.get(i);
			@@ -407,7 +440,7 @@
			Object text = attrVO.getName();
			text = exportKeyAndRequired(workbook,attrVO,text);
			int colIndex = (isHistory?3:0) + i;
			WriteExcelData excelData = new WriteExcelData(0, colIndex, text);
			WriteExcelData excelData = new WriteExcelData(0, colIndex, text,attrVO.getId());
			if(StringUtils.isNotBlank(attrVO.getCodeDateFormat())
			\|\| VciFieldTypeEnum.VTDateTime.name().equalsIgnoreCase(attrVO.getAttributeDataType())
			\|\| VciFieldTypeEnum.VTDate.name().equalsIgnoreCase(attrVO.getAttributeDataType())
			@@ -464,6 +497,147 @@
			}

			/**
			* 生成批量修改导入的文件
			*
			* @param codeClassifyOid 分类的主键
			* @return excel的文件地址
			*/
			@Override
			public String downloadImportExcelBatchEdit(String codeClassifyOid) {
			List<CodeClassifyTemplateVO> templateVOList=new ArrayList<>();
			VciBaseUtil.alertNotNull("导出模板","导出的配置",codeClassifyOid,"主题库分类的主键");

			CodeClassifyVO codeClassifyVO = classifyService.getObjectByOid(codeClassifyOid);

			templateVOList= templateService.childTemplates(codeClassifyOid);

			WriteExcelOption eo = new WriteExcelOption();
			eo.setAppend(true);
			//增加模板的信息导入
			LinkedList<WriteExcelData> tempEDList = new LinkedList<>();
			tempEDList.add(new WriteExcelData(0,0,"编号"));
			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())
			&& (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,"编码(id)",""));
			// excelDataList.add(new WriteExcelData(0,1,"码段宽度",""));
			// excelDataList.add(new WriteExcelData(0,1,!CollectionUtils.isEmpty(idAttrVOList)?idAttrVOList.get(0).getName():"企业编码",idAttrVOList.get(0).getId()));
			// }
			for (int i = 0; i < templateAttrVOS.size(); i++) {
			CodeClassifyTemplateAttrVO attrVO = templateAttrVOS.get(i);

			Object text = attrVO.getName();
			text = exportKeyAndRequired(workbook,attrVO,text);
			int colIndex = 1 + i;
			WriteExcelData excelData = new WriteExcelData(0, colIndex, text,attrVO.getId());
			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() + ("_属性批量修改模板.xls");
			eo.addSheetDataList(templateVOList.size()+"模板信息【请勿删除或移动】",tempEDList);
			ExcelUtil.writeDataToFile(excelName,eo);
			return excelName;
			}

			/**
			* 获取码段宽度
			* @param codeClassifyOid
			* @return
			*/
			private String getCodeSegmentWidth(String codeClassifyOid){
			CodeClassifyVO codeClassifyVO = classifyService.getObjectByOid(codeClassifyOid);
			// 要获取码段宽度，先要获取规则，当前没有往上找
			CodeRuleVO codeRuleByClassifyFullInfo = mdmEngineService.getCodeRuleByClassifyFullInfo(classifyService.getClassifyFullInfo(codeClassifyOid));
			List<CodeBasicSecVO> secVOList = codeRuleByClassifyFullInfo.getSecVOList();
			if(secVOList.isEmpty()){
			return "";
			}

			StringBuffer secWidth = new StringBuffer("");

			for (int j = 0; j < secVOList.size(); j++) {
			CodeBasicSecVO secVO = secVOList.get(j);
			int width = VciBaseUtil.getInt(secVO.getCodeSecLength()) + ((secVO.getPrefixCode() + secVO.getSuffixCode()).length());
			secWidth.append(width).append("#");
			}
			return secWidth.toString().substring(0, secWidth.length() - 1);
			}

			/**
			* 导出的时候封装必输和关键属性
			* @param attrVO 属性的显示对象
			* @param text 单元格的值
			@@ -503,7 +677,7 @@
			* @return 有错误信息的excel的文件
			*/
			@Override
			public CodeImProtRusultVO batchImportCode(CodeOrderDTO orderDTO, File file) {
			public CodeImProtRusultVO batchImportCode(CodeOrderDTO orderDTO, File file) throws Exception {
			VciBaseUtil.alertNotNull(orderDTO,"编码申请相关的数据",orderDTO.getCodeClassifyOid(),"主题库分类主键");
			ReadExcelOption reo = new ReadExcelOption();
			reo.setReadAllSheet(true);
			@@ -523,7 +697,7 @@
			//校验模板是不是最新的
			checkTemplateSync(sheetDataSetList,templateVO,0);
			//先不用管属性是否都存在，先转换一下数据
			Map<String,String> errorMap = new HashMap<>();
			Map<String,String> errorMap = new ConcurrentHashMap<>();
			String redisUUid=batchImportCodes(orderDTO,templateVO,dataSet,errorMap,true);
			CodeImProtRusultVO codeImProtRusultVO = new CodeImProtRusultVO();
			List<String> needRowIndexList = new ArrayList<>();
			@@ -643,13 +817,12 @@

			});


			//都转换完了。需要批量检查
			//如果出错了，我们依然执行有效的数据，无效的数据写回到excel中
			//2.判断必输项。。需要全部的属性，如果是必输，但是表单里面不显示的，只能是分类注入或者组合规则
			batchCheckRequiredAttrOnOrder(templateVO,allCboList,errorMap);
			//3.判断关键属性
			CodeImportResultVO keyResultVO = batchCheckKeyAttrOnOrder(classifyFullInfo, templateVO, allCboList);
			CodeImportResultVO keyResultVO = batchCheckKeyAttrOnOrder(classifyFullInfo, templateVO, allCboList,errorMap);
			Set<String> selfRepeatRowIndexList = keyResultVO.getSelfRepeatRowIndexList();
			Set<String> keyAttrRepeatRowIndexList = keyResultVO.getKeyAttrRepeatRowIndexList();
			if(!CollectionUtils.isEmpty(selfRepeatRowIndexList)){
			@@ -659,7 +832,7 @@
			}
			if(!CollectionUtils.isEmpty(keyAttrRepeatRowIndexList)){
			keyAttrRepeatRowIndexList.stream().forEach(rowIndex->{
			errorMap.put(rowIndex,errorMap.getOrDefault(rowIndex,"") + ";关键属性与系统中的重复" );
			errorMap.put(rowIndex, "关键属性与系统中的重复;" + errorMap.getOrDefault(rowIndex,"") );
			});
			}
			//分类注入
			@@ -776,36 +949,364 @@
			*/
			@Override
			public CodeImProtRusultVO batchImportHistoryData(String codeClassifyOid, String classifyAttr,File file) throws Throwable{
			try {
			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;
			//long start = System.currentTimeMillis();
			// 记录导入成功的总数
			List<Integer> importCount = new ArrayList<>();
			CodeClassifyFullInfoBO classifyFullInfo = classifyService.getClassifyFullInfo(codeClassifyOid);
			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;
			}
			// 单次导入数量限制
			if(sheetDataSetList.get(i).getRowData().size() > IMPORT_DATA_LIMIT){
			throw new ServiceException(StringUtil.format("为了保证系统的稳定性，请一次不要导入超过{}条的数据",IMPORT_DATA_LIMIT));
			}
			//历史导入的时候不处理编码
			//----逻辑内容----
			//1. 分类的路径可以在页面上选择是分类编号还是分类的名称
			//2. 分类的路径，必须是当前导入选择的分类的节点，以及其下级节点
			//3. 通过数据要导入的分类去查找对应的编码规则
			//4. 数据存储和批量申请一样，
			//5. 需要单独处理企业编码的内容，
			// 5.1 企业编码在当前excel里不能重复
			// 5.2 企业编码在系统中不能重复（可以是已经回收的）
			// 5.3 企业编码的长度，和编码规则的长度要对应上
			// 5.4 获取流水码段的值，去除填充的字符，看流水号是多少，然后将流水号和现在的最大流水号判断，小于就直接录入，大于则修改最大流水号
			// 5.5 存储企业编码到allcode中
			//查询分类和模板

			//先找到每一行的标题，然后根据标题来获取对应的属性
			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,errorMap);
			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("导入的数据所选择的分类都没有设置编码规则");
			}
			// TODO: 该用oid查询规则的，别用id
			Map<String, CodeRuleVO> ruleVOMap = ruleService.listCodeRuleByOids(ruleOidMap.values()).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 CopyOnWriteArrayList<>();
			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 {
			// TODO 多线程流问题
			productCodeService.productCodeAndSaveData(classifyFullInfo, finalTemplateVO, ruleVOMap.get(ruleOid), null, dataCBOList);
			importCount.add(dataCBOList.size());
			} catch (Throwable e) {
			log.error("批量产生编码的时候出错了", e);
			thisCbos.stream().forEach(cbo -> {
			String rowIndex = cbo.getAttributeValue(IMPORT_ROW_INDEX);
			errorMap.put(rowIndex, errorMap.getOrDefault(rowIndex, "") + ";系统错误，存储数据的时候出错了:"+e.getMessage());
			});
			}
			}
			});
			if (errorMap.size() > 0) {
			isExport = true;
			}
			createWriteExcelData(rowDataList, errorMap, new ArrayList<>(), titleRowData, shetNameMap, finalTemplateVO);
			engineService.batchSaveSelectChar(templateVO, dataCBOIdList);
			}
			}
			//long end = System.currentTimeMillis();
			//log.info("=============for执行时间================="+String.valueOf((end-start)/1000));
			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("");
			saveLogUtil.operateLog("历史数据导入",true, StringUtil.format("错误信息：{}",JSON.toJSONString(shetNameMap)));
			}else{
			saveLogUtil.operateLog("历史数据导入",false, StringUtil.format("导入到分类{}中，导入成功总数为：{}", JSON.toJSONString(classifyFullInfo),importCount.get(0)));
			}
			if(isCreateUUid){
			codeImProtRusultVO.setRedisUuid(uuid);
			}
			return codeImProtRusultVO;
			}catch (Exception e){
			saveLogUtil.operateLog("历史数据导入",true,e.toString());
			throw e;
			}
			}

			/**
			* 导入批量编辑数据
			*
			* @param codeClassifyOid 分类的主键
			* @param classifyAttr 分类路径使用的属性
			* @param file excel文件的信息
			* @return 有错误信息的excel
			*/
			@Override
			public CodeImProtRusultVO batchImportEdit(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万条的数据");
			if (sheetDataSetList.get(0).getRowData().size() > LIMIT + 1) {
			throw new ServiceException("为了保证系统的稳定性，请一次不要导入超过1万条的数据");
			}
			Map<String,List<WriteExcelData>> shetNameMap=new HashMap<>();
			//相似项目查重
			String uuid=VciBaseUtil.getPk();
			boolean isCreateUUid=false;
			if (sheetDataSetList.get(0).getRowData().size() == 0) {
			throw new ServiceException("未读取到excle相关数据，请确认！！！");
			}
			boolean isExport=false;
			long start = System.currentTimeMillis();
			Map<String,List<WriteExcelData>> shetNameMap=new HashMap<>();
			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中
			// 单次导入数量限制
			if(sheetDataSetList.get(i).getRowData().size() > IMPORT_DATA_LIMIT){
			throw new ServiceException("为了保证系统的稳定性，请一次不要导入超过"+IMPORT_DATA_LIMIT+"条的数据");
			}
			//查询分类和模板
			CodeClassifyFullInfoBO classifyFullInfo = classifyService.getClassifyFullInfo(codeClassifyOid);

			@@ -814,10 +1315,7 @@
			List<SheetRowData> rowDataList = dataSet.getRowData();

			//找第一行，为了找标题
			CodeClassifyTemplateVO templateVO = new CodeClassifyTemplateVO();
			/** if (!templateService.checkChildHasSameTemplate(classifyFullInfo.getCurrentClassifyVO().getOid())) {
			throw new VciBaseException("当前的分类以及下级分类的模板不相同");
			}***/
			CodeClassifyTemplateVO templateVO ;
			//都转换完了。需要批量检查
			//找所有的分类路径,需要校验路径是否正确，是否都在当前的分类的下级
			List<CodeClassifyVO> childClassifyVOs = classifyService.listChildrenClassify(codeClassifyOid, true, classifyAttr, true);
			@@ -827,239 +1325,66 @@
			pathMap.put("#current#",classifyFullInfo.getCurrentClassifyVO());

			try {
			titleRowData.add("分类路径");
			List<CodeClassifyTemplateVO> templateVOList= checkSamesTemplate(titleRowData,sheetDataSetList,i,pathMap,errorMap);
			titleRowData.remove(titleRowData.size()-1);
			templateVO= templateVOList.get(0);
			}catch (Throwable e){
			throw new VciBaseException(e.getMessage());
			}

			CodeClassifyTemplateVO finalTemplateVO = templateVO;

			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();
			fieldIndexMap.put(0,"id");
			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);
			CodeOrderDTO orderDTO = new CodeOrderDTO();
			for (SheetRowData sheetRowData : needowDataList) {
			//查询数据
			Map<String, String> conditionMap = new HashMap<>();
			conditionMap.put("t.id", sheetRowData.getData().get(0));
			conditionMap.put("t.lastv", "1");
			CodeTemplateAttrSqlBO sqlBO = mdmEngineService.getSqlByTemplateVO(classifyFullInfo.getTopClassifyVO().getBtmTypeId(), templateVO, conditionMap, new PageHelper(-1));
			//我们使用和业务类型的来查询
			List<Map> cbosB = commonsMapper.selectBySql(sqlBO.getSqlUnPage());
			if(cbosB.size() == 0){
			throw new ServiceException("编码："+ sheetRowData.getData().get(0) + ",未能查询到相关数据。");
			}
			});
			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 + "】在系统中已经被占用");
			});
			}
			excelToCboEdit(fieldIndexMap, sheetRowData, orderDTO, cbosB.get(0));
			orderDTO.setCopyFromVersion(orderDTO.getOid());
			orderDTO.setOid(null);
			try {
			mdmEngineService.upSaveCode(orderDTO);
			List<Map> newCbos = commonsMapper.selectBySql(sqlBO.getSqlUnPage());
			//对码值表进行处理替换创建数据的oid
			QueryWrapper<CodeAllCode> wrapper = new QueryWrapper<>();
			wrapper.eq("CREATECODEOID",orderDTO.getCopyFromVersion());
			List<CodeAllCode> codeAllCodes = codeAllCodeService.selectByWrapper(wrapper);
			codeAllCodes.get(0).setCreateCodeOid(newCbos.get(0).get("OID").toString());
			codeAllCodes.get(0).setLastModifyTime(new Date());
			codeAllCodes.get(0).setTs(new Date());
			codeAllCodes.get(0).setLastModifier(AuthUtil.getUser().getUserName());
			codeAllCodeService.updateBatchById(codeAllCodes);
			} catch (Throwable e) {
			log.error("批量产生编码的时候出错了", e);
			errorMap.put(sheetRowData.getRowIndex(), ";系统错误，存储数据的时候出错了:"+e.getMessage());
			}
			});

			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);
			isExport = true;
			}
			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;
			}
			createWriteExcelData(rowDataList, errorMap, new ArrayList<>(), titleRowData, shetNameMap, finalTemplateVO);

			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 {
			// TODO 多线程流问题
			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);
			}
			}
			long end = System.currentTimeMillis();
			log.debug("=============for执行时间================="+String.valueOf(start-end));
			String excelFileName="";
			if(isExport&&!CollectionUtils.isEmpty(shetNameMap)) {
			excelFileName = LocalFileUtil.getDefaultTempFolder() + File.separator + "错误信息.xls";
			@@ -1078,14 +1403,13 @@
			if(StringUtils.isNotBlank(excelFileName)) {
			codeImProtRusultVO.setFilePath(excelFileName);
			codeImProtRusultVO.setFileOid("");
			saveLogUtil.operateLog("数据批量更改",true, StringUtil.format("错误信息：{}",JSON.toJSONString(shetNameMap)) );
			}else{
			saveLogUtil.operateLog("数据批量更改",false, StringUtil.format("导入成功总数为：{}",
			sheetDataSetList.size()-1));
			}
			if(isCreateUUid){
			codeImProtRusultVO.setRedisUuid(uuid);
			}

			return codeImProtRusultVO;
			}

			/*private void converBaseModels(List<ClientBusinessObject> clientBusinessObjects,List<BaseModel>dataCBOList){
			clientBusinessObjects.stream().forEach(clientBusinessObject -> {
			BaseModel baseModel=new BaseModel();
			@@ -1139,7 +1463,6 @@
			* @param currentTemplateVO
			* @param templateColumnVOMap
			*/

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

			List<CodeClassifyTemplateAttrVO> templateAttrVOS = currentTemplateVO.getAttributes().stream().filter(s ->
			@@ -1250,7 +1573,6 @@

			}


			/***
			* 批量处理申请数据
			* @param orderDTO
			@@ -1258,140 +1580,148 @@
			* @param dataSet
			* @return
			*/
			private String batchImportCodes(CodeOrderDTO orderDTO,CodeClassifyTemplateVO templateVO,SheetDataSet dataSet,Map<String,String> errorMap,boolean isEnumType){
			private String batchImportCodes(CodeOrderDTO orderDTO,CodeClassifyTemplateVO templateVO,SheetDataSet dataSet,Map<String,String> errorMap,boolean isEnumType) throws Exception {
			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();
			String uuid = "";
			try {
			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> 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);
			//需要判断是否所有的属性都在模板上了
			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) + "】这些属性在列表中没有找到");
			}
			}
			//排除错误的，剩下正确的
			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="";
			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,errorMap);
			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);
			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="";

			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("批了申请时失败");
			//要把以上的错误的都抛出后，再继续处理时间和组合规则
			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("批量申请时失败");
			throw e;
			}
			}
			}
			}
			if(!isCreateUUid){
			return uuid="";
			if(!isCreateUUid){
			return uuid="";
			}
			saveLogUtil.operateLog("批量申请编码",false, StringUtil.format("批量导入申请成功共{}条数据，生成的码值如下【{}】",codeList.size(),codeList));
			}catch (Exception e){
			saveLogUtil.operateLog("批量申请编码",true,e.toString());
			throw e;
			}
			return uuid;
			}
			@@ -1508,10 +1838,10 @@
			tableName = VciBaseUtil.getTableName(btmTypeId);
			}

			String countSql = "select count(*) from " + tableName +" where 1=1" +
			String countSql = "select count() from (select FROM " + tableName +" where 1=1" +
			" and lastr = '1'" +
			" and lastv='1'" +
			" and codeclsfpath like '%" + exportAttrDTO.getCodeClassifyOid() + "%'";
			" and codeclsfpath like '%" + exportAttrDTO.getCodeClassifyOid() + "%' {}";

			//先查询总数
			int total = 0;
			@@ -1525,11 +1855,9 @@
			thisPage.setSort(exportAttrDTO.getSort());
			thisPage.setOrder(exportAttrDTO.getOrder());
			thisPage.addDefaultDesc("createTime");

			total += commonsMapper.queryCountBySql(countSql);
			total += commonsMapper.queryCountBySql(StringUtil.format(countSql," limit " + exportAttrDTO.getLimit() +" offset "+ i +")subquery;"));
			}
			}else{

			total = commonsMapper.queryCountBySql(countSql);
			}
			List<String> selectFieldList = new ArrayList<>();
			@@ -1565,10 +1893,10 @@
			}
			Map<String, String> finalConditionMap = conditionMap;
			//并行查询看看
			SessionInfo sessionInfo = VciBaseUtil.getCurrentUserSessionInfo();
			//SessionInfo sessionInfo = VciBaseUtil.getCurrentUserSessionInfo();
			indexList.stream().forEach(index->{
			//线程的方式，所以需要设置当前用户
			VciBaseUtil.setCurrentUserSessionInfo(sessionInfo);
			//VciBaseUtil.setCurrentUserSessionInfo(sessionInfo);
			PageHelper thisPage = new PageHelper(EXPORT_LIMIT);
			thisPage.setPage(index+1);
			thisPage.setSort(exportAttrDTO.getSort());
			@@ -1729,7 +2057,7 @@
			).collect(Collectors.toList());
			String fullPath = getFullPath(classifyFullInfo);
			excelToCbo(classifyFullInfo,fieldIndexMap,rowDataList, codeClassifyTemplateVO,cboList,fullPath,!isImprot);
			Map<String,String> errorMap=new HashMap<>();
			Map<String,String> errorMap=new ConcurrentHashMap<>();
			Map<String/路径/, CodeClassifyVO> pathMap=new HashMap<>() ;
			//校验编码规则和码段是否正确
			Map<String, List<String>> ruleRowIndexMap = new ConcurrentHashMap<>();
			@@ -1750,7 +2078,8 @@
			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));
			// TODO 改用oid查询的，这儿不该用id
			ruleVOMap = ruleService.listCodeRuleByOids(ruleOidMap.values()).stream().collect(Collectors.toMap(s -> s.getOid(), t -> t));

			checkSecLengthInHistory(cboList, classifyVOMap, ruleVOMap, ruleOidMap, errorMap, ruleRowIndexMap);
			}
			@@ -1773,12 +2102,12 @@
			//最后弄组合规则
			batchSwitchComponentAttrOnOrder(attrVOS,cboList);
			//3.判断关键属性
			CodeImportResultVO keyResultVO = batchCheckKeyAttrOnOrder(classifyFullInfo, codeClassifyTemplateVO, cboList);
			CodeImportResultVO keyResultVO = batchCheckKeyAttrOnOrder(classifyFullInfo, codeClassifyTemplateVO, cboList,errorMap);
			Set<String> selfRepeatRowIndexList = keyResultVO.getSelfRepeatRowIndexList();
			Set<String> keyAttrRepeatRowIndexList = keyResultVO.getKeyAttrRepeatRowIndexList();
			if(!CollectionUtils.isEmpty(keyAttrRepeatRowIndexList)){
			keyAttrRepeatRowIndexList.stream().forEach(rowIndex->{
			errorMap.put(rowIndex,errorMap.getOrDefault(rowIndex,"") + ";关键属性与系统中的重复" );
			errorMap.put(rowIndex,"关键属性与系统中的重复;" + errorMap.getOrDefault(rowIndex,""));
			});
			}
			//4.校验规则
			@@ -1907,7 +2236,7 @@
			*/
			@Override
			public void batchSyncApplyCode(CodeOrderDTO orderDTO, DataObjectVO dataObjectVO, LinkedList<XMLResultDataObjectDetailDO> resultDataObjectDetailDOs,boolean isCodeOrGroupCode) {
			Map<String,String> errorMap=new HashMap<>();
			Map<String,String> errorMap=new ConcurrentHashMap<>();
			VciBaseUtil.alertNotNull(orderDTO,"编码申请相关的数据",orderDTO.getCodeClassifyOid(),"主题库分类主键");
			CodeClassifyFullInfoBO classifyFullInfo = classifyService.getClassifyFullInfo(orderDTO.getCodeClassifyOid());
			//规则的主键需要去获取
			@@ -1939,7 +2268,8 @@
			&& 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中没有找到");
			String message=unExistAttrVOs.stream().map(CodeClassifyTemplateAttrVO::getName).collect(Collectors.joining(SERIAL_UNIT_SPACE));
			throw new VciBaseException("【" + message + "】这些属性在excel中没有找到");
			}
			List<ClientBusinessObject> cboList = new ArrayList<>();
			String fullPath = getFullPath(classifyFullInfo);
			@@ -1955,20 +2285,33 @@

			//都转换完了。需要批量检查
			//如果出错了，我们依然执行有效的数据，无效的数据写回到excel中

			Map<String,String> errorKeyMap=new HashMap<>();
			//1.分类注入
			batchSwitchClassifyAttrOnOrder(attrVOS,cboList,classifyFullInfo,false);
			//boolean
			reSwitchBooleanAttrOnOrder(attrVOS,cboList);
			// cboList.stream().forEach(cbo->{
			//2.校验规则
			batchCheckVerifyOnOrder(attrVOS, cboList,errorMap);
			//3.校验枚举是否正确
			batchSwitchEnumAttrOnOrder(attrVOS,cboList,errorMap);
			//4.时间格式的验证
			//4.时间的，必须统一为yyyy-MM-dd HH:mm:ss
			batchSwitchDateAttrOnOrder(attrVOS,cboList,errorMap);
			//5.处理参照的情况
			batchSwitchReferAttrOnOrder(attrVOS,cboList,errorMap);
			//6设置默认值
			batchSwitchAttrDefault(attrVOS, cboList);
			//2.判断必输项。。需要全部的属性，如果是必输，但是表单里面不显示的，只能是分类注入或者组合规则
			batchCheckRequiredAttrOnOrder(templateVO,cboList,errorMap);


			/**
			* 关键熟悉错误提示
			*/
			Map<String,String> errorKeyMap=new HashMap<>();


			//最后弄组合规则
			batchSwitchComponentAttrOnOrder(attrVOS,cboList);
			//3.判断关键属性
			CodeImportResultVO keyResultVO = batchCheckKeyAttrOnOrder(classifyFullInfo, templateVO, cboList);
			CodeImportResultVO keyResultVO = batchCheckKeyAttrOnOrder(classifyFullInfo, templateVO, cboList,errorKeyMap);
			Set<String> selfRepeatRowIndexList = keyResultVO.getSelfRepeatRowIndexList();
			Set<String> keyAttrRepeatRowIndexList = keyResultVO.getKeyAttrRepeatRowIndexList();

			Map<String,List<String>>keyAttrOkOidTORepeatOidMap= keyResultVO.getKeyAttrOkOidTORepeatOidMap();
			if(!CollectionUtils.isEmpty(selfRepeatRowIndexList)){
			selfRepeatRowIndexList.stream().forEach(rowIndex->{
			@@ -1998,23 +2341,13 @@
			resultDataObjectDetailDO.setMsg(errorMap.getOrDefault(rowIndex,"") + ";关键属性与系统中的重复" );
			resultDataObjectDetailDOs.add(resultDataObjectDetailDO);
			*/
			errorKeyMap.put(rowIndex,errorMap.getOrDefault(rowIndex,"") + ";关键属性与系统中的重复" );
			Map<String, List<BaseModel>> indexTODataMap=keyResultVO.getIndexTODataMap();
			if(indexTODataMap.containsKey(rowIndex)){
			List<BaseModel> baseModelList= indexTODataMap.get(rowIndex);
			}
			errorKeyMap.put(rowIndex, "关键属性与系统中的重复;" + errorKeyMap.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 = {""};
			@@ -2057,50 +2390,54 @@
			Map<String, List<BaseModel>> indexTodataMap = keyResultVO.getIndexTODataMap();
			cboList.stream().forEach(cbo -> {
			String rowIndex = cbo.getAttributeValue(IMPORT_ROW_INDEX);
			String msg = errorKeyMap.get(rowIndex);
			if (indexTodataMap.containsKey(rowIndex)) {
			String oid = cbo.getOid();
			String sourceOid = oid;
			String code = "";
			String groupCode="";
			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 = StringUtils.isBlank(newCbo.getId())?"":newCbo.getId();
			groupCode=newCbo.getData().getOrDefault("GROUPCODE","");
			String lastmodifier=newCbo.getLastModifier();
			if (lcstatus!=null&&!lcstatus.equals(CodeDefaultLC.RELEASED.getValue())) {
			newCbo.setOid(newOid);
			newCbo.setLastModifier(lastmodifier);
			/*if(isCodeOrGroupCode) {
			newCbo.setId(code);
			}else{
			newCbo.getData().put("groupcode",groupCode);
			}*/
			newCbo.setTs(ts);
			cbo.setLastModifier(cbo.getLastModifier());
			editBoList.add(newCbo);
			}
			String mes = errorKeyMap.get(rowIndex);
			XMLResultDataObjectDetailDO resultDataObjectDetailDO = new XMLResultDataObjectDetailDO();
			if(isCodeOrGroupCode) {
			if(StringUtils.isBlank(groupCode)){
			errorid="1";
			mes+="；申请的编码类型为集团码，等待集团编码赋值";
			//处理关键属性查出多条的话，根据集成调用的当前分类代号取当前分类的码值。
			Map<String/编码/, BaseModel/重复编码数据/> classOidTOBaseModelMap = new HashMap<>();
			newCboList.stream().forEach(baseModel->{
			String codeclsfid=baseModel.getData().get(CODE_CLASSIFY_OID_FIELD.toUpperCase(Locale.ROOT));
			classOidTOBaseModelMap.put(codeclsfid,baseModel);
			});
			String codeclsfid= classifyFullInfo.getCurrentClassifyVO().getOid();
			if(classOidTOBaseModelMap.containsKey(codeclsfid)){
			BaseModel newCbo= classOidTOBaseModelMap.get(codeclsfid);
			String lcstatus =newCbo.getLcStatus();
			String newOid =newCbo.getOid();
			Date ts =newCbo.getTs();
			code = StringUtils.isBlank(newCbo.getId())?"":newCbo.getId();
			if(isCodeOrGroupCode) {
			code=newCbo.getData().getOrDefault("GROUPCODE","");
			if(StringUtils.isBlank(code)){
			errorid="1";
			msg="；申请的编码类型为集团码，等待集团编码赋值";
			}
			}
			resultDataObjectDetailDO.setCode(groupCode);
			String lastmodifier=newCbo.getLastModifier();
			if (lcstatus!=null&&!lcstatus.equals(CodeDefaultLC.RELEASED.getValue())) {
			newCbo.setOid(newOid);
			newCbo.setLastModifier(lastmodifier);
			newCbo.setTs(ts);
			cbo.setLastModifier(cbo.getLastModifier());
			editBoList.add(newCbo);
			}
			}else{
			resultDataObjectDetailDO.setCode(code);
			errorid="205";
			msg+="；编码则属于其他分类。";
			}
			XMLResultDataObjectDetailDO resultDataObjectDetailDO = new XMLResultDataObjectDetailDO();
			resultDataObjectDetailDO.setCode(code);
			resultDataObjectDetailDO.setId(sourceOid);
			resultDataObjectDetailDO.setErrorid(errorid);
			resultDataObjectDetailDO.setMsg(mes);
			resultDataObjectDetailDO.setMsg(msg);

			resultDataObjectDetailDOs.add(resultDataObjectDetailDO);
			}
			@@ -2115,10 +2452,7 @@
			}

			// });
			//设置默认值
			batchSwitchAttrDefault(attrVOS, cboList);
			//最后弄组合规则
			batchSwitchComponentAttrOnOrder(attrVOS,cboList);

			//要把以上的错误的都抛出后，再继续处理时间和组合规则
			List<ClientBusinessObject> needSaveCboList = cboList.stream().filter(cbo -> {
			String rowIndex =cbo.getAttributeValue(IMPORT_ROW_INDEX);
			@@ -2134,7 +2468,7 @@
			needSaveCboList.stream().forEach(clientBusinessObject -> {
			BaseModel baseModel=new BaseModel();
			BeanUtil.convert(clientBusinessObject,baseModel);
			//(VciBaseUtil.objectToMapString(clientBusinessObject));
			//(VciBaseUtil.objectToMapString(clientBusinessObject));
			dataCBOList.add(baseModel);
			allNeedSaveCboList.add(baseModel.getOid());
			});
			@@ -2263,6 +2597,7 @@
			}
			return resultDataObjectDetailDOs;
			}

			/***
			* 集成批量同步更新接口
			* @param codeClassifyVO;
			@@ -2368,6 +2703,7 @@
			String dataStatus=cbo.getLcStatus();
			RowDatas rowData=codeDataMap.get(code);
			String status=rowData.getStatus();
			String lastModifier= rowData.getEditor();
			String operation=rowData.getOperation();
			if (cbo.getTs().compareTo(orderDTO.getTs())==0?false:true) {
			// throw new VciBaseException("数据不是最新的，可能他人已经修改，请刷新后再试");
			@@ -2377,20 +2713,20 @@
			throw new VciBaseException("数据不是{0}的状态，不允许修改", new String[]{CodeDefaultLC.EDITING.getText()});
			}*/
			if(operation.equals("update")) {
			//1. 判断必输项
			checkRequiredAttrOnOrder(templateVO, orderDTO, errorMap);
			//2.先注入，再组合，最后校验
			//1.先注入，再组合，最后校验
			switchClassifyLevelOnOrder(templateVO, classifyFullInfo, orderDTO, errorMap);
			//3.处理组合规则。组合规则不能使用编码的属性，因为编码的生成可能是需要属性的
			//2.处理组合规则。组合规则不能使用编码的属性，因为编码的生成可能是需要属性的
			switchComponentAttrOnOrder(templateVO, orderDTO);
			//4.校验规则
			//3.校验规则
			checkVerifyOnOrder(templateVO, orderDTO, errorMap);
			//5.判断关键属性
			checkKeyAttrOnOrder(classifyFullInfo, templateVO, orderDTO, errorMap);
			//6.校验枚举的内容是否正确
			//4.校验枚举的内容是否正确
			checkEnumOnOrder(templateVO, orderDTO, errorMap);
			//7.处理时间格式，在数据库里面不论是字符串还是日期格式，都使用相同的格式存储
			//5.处理时间格式，在数据库里面不论是字符串还是日期格式，都使用相同的格式存储
			switchDateAttrOnOrder(templateVO, orderDTO);
			//6. 判断必输项
			checkRequiredAttrOnOrder(templateVO, orderDTO, errorMap);
			//7.判断关键属性
			checkKeyAttrOnOrder(classifyFullInfo, templateVO, orderDTO, errorMap);
			//默认的内容不能变，所以只需要拷贝自定义的相关属性即可
			copyValueToCBO(classifyFullInfo, cbo, orderDTO, templateVO, true, errorMap);
			//企业码和集团码的不修改
			@@ -2398,12 +2734,20 @@
			cbo.setName(orderDTO.getName());
			try {
			cbo.setAttributeValueWithNoCheck("description", orderDTO.getDescription());
			cbo.setAttributeValue("name", orderDTO.getName());
			// cbo.setAttributeValue("name", orderDTO.getName());
			// if(finalIsProcess){//在流程中不允许更改
			// errorMap.put(code,errorMap.getOrDefault(code, errorMap.getOrDefault(code,"")+";数据"+code+"在流程中，不允许更改!"));
			// }else{
			Date date=new Date();
			cbo.setLcStatus(status);
			cbo.setAttributeValue("lcstatus",status);
			cbo.setLastModifyTime(date);
			cbo.setLastModifier(lastModifier);
			cbo.setLastModifyTime(date);
			cbo.setAttributeValue("lastmodifier",lastModifier);
			cbo.setAttributeValue("lastmodifytime",new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS").format(date));
			cbo.setTs(date);
			cbo.setAttributeValue("ts",new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS").format(date));
			// }
			} catch (VciBaseException e) {
			e.printStackTrace();
			@@ -2549,6 +2893,7 @@
			});
			}
			}

			/**
			* 转换组合规则的值
			*
			@@ -2595,6 +2940,7 @@
			});
			}
			}

			/**
			* 校验关键属性
			*
			@@ -2623,7 +2969,6 @@
			});

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

			if (!CollectionUtils.isEmpty(conditionMap)) {
			String tableName="";
			R<BtmTypeVO> r = btmTypeClient.getAllAttributeByBtmId(templateVO.getBtmTypeId());
			@@ -2635,11 +2980,12 @@
			}
			}
			if (StringUtils.isBlank(tableName)) {
			String errormsg="根据业务类型为查询到相关业务表";
			String errormsg="根据业务类型未查询到相关业务表";
			errorMap.put(orderDTO.getId(),errorMap.getOrDefault(orderDTO.getId(),"")+errormsg);
			return;
			}
			final String[] sql = {"select count(*) from " + tableName + " t where 1 = 1 "};
			//final String[] sql = {"select count(*) from " + tableName + " t where 1 = 1 "};
			final String[] sql = {"select t.id from " + tableName + " t where 1 = 1 "};
			conditionMap.forEach((key, value) -> {
			if(StringUtils.isBlank(value)\|\|value.equals(QueryOptionConstant.ISNULL)){
			sql[0] += " and " + key + " is null ";
			@@ -2654,17 +3000,24 @@
			} else if (StringUtils.isNotBlank(orderDTO.getCopyFromVersion())) {
			sql[0] += " and t.oid != '" + orderDTO.getCopyFromVersion() + "'";
			}
			// 不需要参与校验的规则oid
			String isParticipateCheckOids = classifyService.selectLeafByParentClassifyOid(classifyFullInfo.getTopClassifyVO().getOid(), classifyFullInfo.getCurrentClassifyVO().getOid());
			if(Func.isNotBlank(isParticipateCheckOids)){
			sql[0] += " and codeclsfid not in("+isParticipateCheckOids+")";
			}
			sql[0] += " and t.lastR = '1' and t.lastV = '1' ";
			if (commonsMapper.queryCountBySql(sql[0]) > 0) {
			List<String> repeatData = commonsMapper.selectList(sql[0]);
			if (!repeatData.isEmpty()) {
			String ruleInfoMsg = keyRuleVO == null ? "" : "查询规则：去除空格--{0},忽略大小写--{1},忽略全半角--{2},忽略全部空格--{3}";
			String[] objs = new String[]{trim ? "是" : "否", ignoreCase ? "是" : "否", ignoreWidth ? "是" : "否", trimAll ? "是" : "否"};
			String defaultValue=";根据您填写的关键属性的内容，结合关键属性查询规则，发现这个数据已经在系统中存在了。请修正!。";
			String defaultValue=";根据您填写的关键属性的内容，结合关键属性查询规则，发现这个数据已经在系统中存在了,数据的编号如下："+repeatData.stream().collect(Collectors.joining(","))+"。请修正!。";
			String errormsg=defaultValue+ MessageFormat.format(ruleInfoMsg, objs);
			errorMap.put(orderDTO.getId(),errorMap.getOrDefault(orderDTO.getId(),"")+errormsg);
			// throw new VciBaseException("根据您填写的关键属性的内容，结合关键属性查询规则，发现这个数据已经在系统中存在了。请修正!。" + ruleInfoMsg, objs);
			}
			}
			}

			/**
			* 校验枚举的内容
			*
			@@ -2688,6 +3041,7 @@
			});
			}
			}

			/**
			* 转换时间的格式
			*
			@@ -2749,10 +3103,10 @@
			// if (lifeCycleVO != null) {
			// cbo.setLcStatus(lifeCycleVO.getStartStatus());
			// } else {
			cbo.setLcStatus(CodeDefaultLC.EDITING.getValue());
			cbo.setLcStatus(CodeDefaultLC.RELEASED.getValue());
			// }
			} else {
			cbo.setLcStatus(CodeDefaultLC.EDITING.getValue());
			cbo.setLcStatus(CodeDefaultLC.RELEASED.getValue());
			}

			}
			@@ -2780,6 +3134,7 @@
			orderDTO.getData().put(attrId, value);
			}
			}

			/**
			* 从编码申请信息对象上获取某个属性的值
			*
			@@ -2799,6 +3154,7 @@
			}
			return value;
			}

			/**
			* 处理分类注入的信息
			*
			@@ -2844,6 +3200,7 @@
			});
			}
			}

			/***
			*
			* @param codeClassifyVO
			@@ -2940,7 +3297,7 @@
			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())){
			if(StringUtils.isNotBlank(secVO.getCodeSecLength())&&VciBaseUtil.getInt(length)>(VciBaseUtil.getInt(secVO.getCodeSecLength())+((secVO.getPrefixCode()+secVO.getSuffixCode()).length()))){
			errorMap.put(rowIndex,errorMap.getOrDefault(rowIndex,"") + ";码段宽度与系统中的编码规则不同" );
			fined = true;
			break;
			@@ -2972,6 +3329,7 @@
			}
			});
			}

			/**
			* excel转换为cbo的对象
			* @param classifyFullInfo 分类的全部信息
			@@ -3084,6 +3442,7 @@
			});

			}

			/**
			* excel转换为cbo的对象
			* @param classifyFullInfo 分类的全部信息
			@@ -3118,7 +3477,7 @@
			Integer userSecret = VciBaseUtil.getCurrentUserSecret();
			cbo.setAttributeValue(SECRET_FIELD,String.valueOf((userSecret==null \|\| userSecret ==0)? UserSecretEnum.NONE.getValue():userSecret));
			}
			cbo.setLcStatus(CodeDefaultLC.EDITING.getValue());
			cbo.setLcStatus(CodeDefaultLC.RELEASED.getValue());
			}else{
			//此时还没有转换路径
			//cbo.setAttributeValue(CODE_FULL_PATH_FILED, childOidPathMap.getOrDefault(rowData.getData().getOrDefault(CODE_CLASSIFY_OID_FIELD,""),fullPath));
			@@ -3133,6 +3492,7 @@
			});

			}

			/**
			* excel转换为cbo的对象
			* @param classifyFullInfo 分类的全部信息
			@@ -3148,9 +3508,9 @@
			String fullPath,boolean newCode){
			rowDataList.stream().forEach(rowData -> {
			ClientBusinessObject cbo=new ClientBusinessObject();
			DefaultAttrAssimtUtil.addDefaultAttrAssimt(cbo, classifyFullInfo.getTopClassifyVO().getBtmTypeId());
			DefaultAttrAssimtUtil.addDefaultAttrAssimt(cbo, classifyFullInfo.getTopClassifyVO().getBtmTypeId());
			rowData.getData().forEach((index,value)->{
			String field = fieldIndexMap.get(index);
			String field = fieldIndexMap.get(index);
			if (StringUtils.isBlank(field)) {
			throw new VciBaseException("第" + (index + 1) + "列的标题在系统中不存在");
			}
			@@ -3175,7 +3535,7 @@
			Integer userSecret = VciBaseUtil.getCurrentUserSecret();
			cbo.setAttributeValue(SECRET_FIELD,String.valueOf((userSecret==null \|\| userSecret ==0)? UserSecretEnum.NONE.getValue():userSecret));
			}
			cbo.setLcStatus(CodeDefaultLC.EDITING.getValue());
			cbo.setLcStatus(CodeDefaultLC.RELEASED.getValue());
			}else{
			//此时还没有转换路径
			//cbo.setAttributeValue(CODE_FULL_PATH_FILED, childOidPathMap.getOrDefault(rowData.getData().getOrDefault(CODE_CLASSIFY_OID_FIELD,""),fullPath));
			@@ -3188,6 +3548,106 @@
			cboList.add(cbo);
			});

			}

			/**
			* excel转换为cbo的对象
			* @param fieldIndexMap 字段的位置
			* @param rowDataList excel里的行数据
			* @param orderDTO 整理的数据
			* @param map 数据的列表
			*/
			private void excelToCboEdit(Map<Integer,String> fieldIndexMap,SheetRowData rowDataList,
			CodeOrderDTO orderDTO,
			Map map){
			rowDataList.getData().forEach((index,value)->{
			String field = fieldIndexMap.get(index);
			if (StringUtils.isBlank(field)) {
			throw new VciBaseException("第" + (index + 1) + "列的标题在系统中不存在");
			}
			map.put(field,value);
			});

			try {
			// for (Map map : cbos) {
			// Object obj = CodeOrderDTO.class.newInstance();
			BeanInfo beanInfo = Introspector.getBeanInfo(orderDTO.getClass());
			PropertyDescriptor[] propertyDescriptors = beanInfo.getPropertyDescriptors();
			for (PropertyDescriptor property : propertyDescriptors) {
			Method setter = property.getWriteMethod();
			if (setter != null) {
			//oracle的时间为TIMESTAMP的，需要进行转换成data，否则将报错
			if (map.get(property.getName().toUpperCase()) instanceof TIMESTAMP) {
			LocalDateTime localDateTime = ((TIMESTAMP) map.get(property.getName().toUpperCase())).toLocalDateTime();
			ZoneId zoneId = ZoneId.systemDefault();
			ZonedDateTime zdt = localDateTime.atZone(zoneId);
			Date date = Date.from(zdt.toInstant());
			setter.invoke(orderDTO, date);
			map.remove(property.getName().toUpperCase());
			} //oracle的数字为BigDecimal的，需要进行转换成Integer，否则将报错
			else if (map.get(property.getName().toUpperCase()) instanceof BigDecimal
			&& ("Integer").equals(setter.getParameterTypes()[0].getSimpleName())) {
			setter.invoke(orderDTO, ((BigDecimal) map.get(property.getName().toUpperCase())).intValue());
			map.remove(property.getName().toUpperCase());
			} else if (map.containsKey(property.getName().toUpperCase())) {
			if(setter.getParameterTypes()[0].getSimpleName().equals("String")){
			setter.invoke(orderDTO, map.get(property.getName().toUpperCase()) == null ? null:String.valueOf(map.get(property.getName().toUpperCase())));
			}else{
			setter.invoke(orderDTO, map.get(property.getName().toUpperCase()));
			}
			map.remove(property.getName().toUpperCase());
			}
			}
			}
			for (Object key : map.keySet()) {
			map.put(key, map.get(key) == null ? null : String.valueOf(map.get(key)));
			}
			} catch (Exception e) {
			throw new VciBaseException("查询失败：" + e.getMessage());
			}



			// Iterator<Map.Entry<String, String>> iterator = cbos.entrySet().iterator();
			//
			// Map.Entry<String, String> entry;
			// while (iterator.hasNext()) {
			// entry = iterator.next();
			//// if (WebUtil.isDefaultField(entry.getKey())) {
			// Object obj = BaseModel.class.newInstance();
			// BeanInfo beanInfo = Introspector.getBeanInfo(obj.getClass());
			// PropertyDescriptor[] propertyDescriptors = beanInfo.getPropertyDescriptors();
			// for (PropertyDescriptor property : propertyDescriptors) {
			// Method setter = property.getWriteMethod();
			// if (setter != null) {
			// //oracle的时间为TIMESTAMP的，需要进行转换成data，否则将报错
			// if (map.get(property.getName().toUpperCase()) instanceof TIMESTAMP) {
			// LocalDateTime localDateTime = ((TIMESTAMP) map.get(property.getName().toUpperCase())).toLocalDateTime();
			// ZoneId zoneId = ZoneId.systemDefault();
			// ZonedDateTime zdt = localDateTime.atZone(zoneId);
			// Date date = Date.from(zdt.toInstant());
			// setter.invoke(obj, date);
			// map.remove(property.getName().toUpperCase());
			// } //oracle的数字为BigDecimal的，需要进行转换成Integer，否则将报错
			// else if (map.get(property.getName().toUpperCase()) instanceof BigDecimal
			// && ("Integer").equals(setter.getParameterTypes()[0].getSimpleName())) {
			// setter.invoke(obj, ((BigDecimal) map.get(property.getName().toUpperCase())).intValue());
			// map.remove(property.getName().toUpperCase());
			// } else if (map.containsKey(property.getName().toUpperCase())) {
			// if(setter.getParameterTypes()[0].getSimpleName().equals("String")){
			// setter.invoke(obj, map.get(property.getName().toUpperCase()) == null ? null:String.valueOf(map.get(property.getName().toUpperCase())));
			// }else{
			// setter.invoke(obj, map.get(property.getName().toUpperCase()));
			// }
			// map.remove(property.getName().toUpperCase());
			// }
			// }
			// }
			// WebUtil.setValueToField(entry.getKey(), orderDTO, entry.getValue());
			// iterator.remove();
			//// }
			// }
			orderDTO.setData(map);
			}

			/**
			@@ -3221,6 +3681,7 @@
			}
			}
			}

			/**
			* 批量转换时间都为指定的格式
			* @param attrVOS 模板属性
			@@ -3446,6 +3907,7 @@
			}

			}

			/**
			* 批量检查企业编码是否存在
			* @param templateVO 模板的显示对象
			@@ -3507,6 +3969,7 @@
			});
			}
			}

			/***
			* 校验分类对应的模板信息
			* @param titleRowData
			@@ -3590,6 +4053,7 @@
			}
			return codeClassifyTemplateVOList ;
			}

			/**
			* 从属性上获取参照的内容
			* @param attrVO 属性的信息
			@@ -3651,6 +4115,7 @@
			}
			return showText;
			}

			/**
			* 处理枚举的显示对象
			* @param attrVOS 模板属性
			@@ -3699,7 +4164,7 @@
			*/
			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())//不能是组合的和分类注入的
			VciBaseUtil.getBoolean(s.getRequireFlag()) && StringUtils.isBlank(s.getComponentRule()) && (StringUtils.isBlank(s.getClassifyInvokeLevel())\|\|s.getClassifyInvokeLevel().equals("none"))//不能是组合的和分类注入的
			).collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t));
			//与MdmEngineServiceImpl里面的checkRequiredAttrOnOrder 逻辑应该相似
			if(!CollectionUtils.isEmpty(requiredAttrMap)) {
			@@ -3707,11 +4172,12 @@
			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);
			errorMap.put(rowIndex,errorMap.getOrDefault(rowIndex,"") + ";校验规则必填项不通过，如果有必填属性为空，则填【/】代替,有校验的属性为" + checkAttr);
			});
			}
			}
			}

			/**
			* 处理分类注入
			* @param attrVOS 模板属性
			@@ -3721,7 +4187,7 @@
			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())
			s -> 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);
			@@ -3741,7 +4207,8 @@
			}
			}
			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());
			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);
			@@ -3757,6 +4224,7 @@
			} else {
			Map<String, String> classifyDataMap = VciBaseUtil.objectToMapString(classifyVO);
			String value = classifyDataMap.getOrDefault(attrVO.getClassifyInvokeAttr(), "");
			log.error("================================当前分类注入的value值为：==========================",value);
			cbo.setAttributeValue(attrId, value);
			}
			} catch (Throwable e) {
			@@ -3773,7 +4241,7 @@
			* @param cboList 批量的数据
			*/
			private CodeImportResultVO batchCheckKeyAttrOnOrder(CodeClassifyFullInfoBO classifyFullInfo, CodeClassifyTemplateVO templateVO,
			List<ClientBusinessObject> cboList) {
			List<ClientBusinessObject> cboList,Map<String,String> errorMap) {
			//与MdmEngineServiceImpl里的checkKeyAttrOnOrder相似
			//先获取关键属性的规则，也利用继承的方式
			CodeKeyAttrRepeatVO keyRuleVO = keyRuleService.getRuleByClassifyFullInfo(classifyFullInfo);
			@@ -3800,7 +4268,9 @@
			//2.判断关键属性在系统里是否重复
			//因为数据量很大，所以得想办法并行
			//SessionInfo sessionInfo = VciBaseUtil.getCurrentUserSessionInfo();
			Map<String,List<BaseModel>> indexTODataMap=new HashMap<>();
			Map<String,List<BaseModel>> indexTODataMap=new ConcurrentHashMap<>();
			// 查询不需要参与关键属性校验的除自己以外的所有分类oid
			final String isParticipateCheckOids = classifyService.selectLeafByParentClassifyOid(classifyFullInfo.getTopClassifyVO().getOid(), classifyFullInfo.getCurrentClassifyVO().getOid());
			List<ClientBusinessObject> repeatDataMap = cboList.parallelStream().filter(cbo -> {
			//每行都得查询.如果其中出现了错误，我们就直接抛出异常，其余的显示
			//VciBaseUtil.setCurrentUserSessionInfo(sessionInfo);
			@@ -3814,22 +4284,30 @@
			engineService.wrapperKeyAttrConditionMap(value, keyRuleVO, attrId, trim, ignoreCase, ignoreWidth, trimAll, conditionMap);
			});
			if (!CollectionUtils.isEmpty(ketAttrMap)) {
			// 添加不参与关键属性校验的分类oid判断
			if(Func.isNotBlank(isParticipateCheckOids)){
			conditionMap.put("t.codeclsfid",QueryOptionConstant.NOTIN+isParticipateCheckOids);
			}
			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<>();
			List<String> repeatData = commonsMapper.selectList(sqlBO.getSqlId());
			if(!repeatData.isEmpty()){
			final 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);
			baseModel.setData(stringStringMap);
			newCboList.add(baseModel);
			});
			// 添加错误值
			String rowIndex = cbo.getAttributeValue(IMPORT_ROW_INDEX);
			errorMap.put(rowIndex, "重复的记录编号为:"+repeatData.stream().collect(Collectors.joining(",")));
			if(!CollectionUtils.isEmpty(newCboList)) {
			indexTODataMap.put(cbo.getAttributeValue(IMPORT_ROW_INDEX), newCboList);
			}
			}
			return isKeyCheck;
			return !repeatData.isEmpty();
			}else{
			return false;
			}
			@@ -3857,7 +4335,7 @@
			if(StringUtils.isBlank(classifyPath)){
			classifyPath = "#current#";
			}
			if ( !pathMap.containsKey(classifyPath)) {
			if (!pathMap.containsKey(classifyPath)) {
			String row_index = cbo.getAttributeValue(IMPORT_ROW_INDEX);
			errorMap.put(row_index,errorMap.getOrDefault(row_index,"") + ";分类路径不存在");
			} else {
			@@ -3940,9 +4418,11 @@
			childOidPathMap.put(childPath.getOid(),thisClassifyPath);
			});
			}
			String path=classifyFullInfo.getCurrentClassifyVO().getId();
			//根据客户选择的分类路径未id，还是name确定路径拼接
			childOidPathMap.put(classifyFullInfo.getCurrentClassifyVO().getOid(),fullPath);
			return childOidPathMap;
			}


			/**
			* 获取导入的内容中关键属性重复的行号
			@@ -3952,7 +4432,7 @@
			* @return 重复的行号
			*/
			private void getSelfRepeatRowIndex(Map<String/属性的编号/, CodeClassifyTemplateAttrVO> ketAttrMap,
			List<ClientBusinessObject> dataList,CodeKeyAttrRepeatVO keyRuleVO,CodeImportResultVO resultVO){
			List<ClientBusinessObject> dataList,CodeKeyAttrRepeatVO keyRuleVO,CodeImportResultVO resultVO){
			Set<String> selfRepeatRowIndexList = new CopyOnWriteArraySet<>();
			Map<String,List<String>> keyAttrOkOidTORepeatOidMap=new HashMap<>();
			boolean trimAll =keyRuleVO ==null?false: VciBaseUtil.getBoolean(keyRuleVO.getIgnoreallspaceflag());
			@@ -3997,7 +4477,7 @@
			List<String>newOidList=new ArrayList<>();
			newOidList.add(oid);
			if(keyAttrOkOidTORepeatOidMap.containsKey(okOid)){
			List<String> oldOidList= keyAttrOkOidTORepeatOidMap.get(okOid);
			List<String> oldOidList = keyAttrOkOidTORepeatOidMap.get(okOid);
			newOidList.addAll(oldOidList);

			}
			@@ -4012,6 +4492,7 @@
			resultVO.setKeyAttrRepeatRowIndexList(selfRepeatRowIndexList);
			resultVO.setKeyAttrOkOidTORepeatOidMap(keyAttrOkOidTORepeatOidMap);
			}

			/**
			* excel的标题上获取字段所在的位置
			* @param titleRowData 标题的内容
			@@ -4126,6 +4607,7 @@
			codeClassifyDatas.addAll(newCodeImprotDataVO);
			log.info("222");
			}

			/***
			* @param titleRowData
			* @param newTemplateVO
			@@ -4171,7 +4653,8 @@
			codeImprotDataVO.setColNames(colNames);
			codeImprotDataVO.getDatas().add(filedValueMap);
			}
			/***

			/**
			* 正确错误数据redis缓存
			* @param uuid
			* @param templateVO
			@@ -4485,4 +4968,305 @@
			mdmInterJtClient.receiveEditApply(oids,btmName);
			}
			}

			/***
			* @param codeClassifyOid
			* @return
			*/
			@Override
			public String exportGroupCodeExcel(String codeClassifyOid) throws ServiceException {
			VciBaseUtil.alertNotNull(codeClassifyOid,"主题库分类的主键");
			CodeClassifyFullInfoBO classifyFullInfo = classifyService.getClassifyFullInfo(codeClassifyOid);
			CodeClassifyVO codeClassifyVO= classifyFullInfo.getCurrentClassifyVO();
			//获取最新的模板
			CodeClassifyTemplateVO templateVO = engineService.getUsedTemplateByClassifyOid(codeClassifyOid);
			LinkedList<String> colName=new LinkedList<>();//列头
			LinkedList<String> fieldList=new LinkedList<>();//列字段

			ExecGroupCodePortDataDTO execGroupCodePortDataDTO=new ExecGroupCodePortDataDTO();
			createExportGroupCodeMapConfig(templateVO,execGroupCodePortDataDTO);//组织数据
			if(!CollectionUtils.isEmpty(execGroupCodePortDataDTO.getCodeAttrMapGroupAttrDTOS())){
			throw new ServiceException("集团属性映射未配置");
			}
			fieldList=execGroupCodePortDataDTO.getFieldList();
			List<Map<String,String>>dataList=new ArrayList<>();
			getDatas(classifyFullInfo,templateVO,fieldList,dataList,null);
			execGroupCodePortDataDTO.setDataList(dataList);//放数据
			execGroupCodePortDataDTO.setSheetName(codeClassifyVO.getName()+"集团码导入模板");
			String tempFolder = LocalFileUtil.getDefaultTempFolder();
			String excelName = tempFolder + File.separator +
			classifyFullInfo.getCurrentClassifyVO().getId() + "_" + classifyFullInfo.getCurrentClassifyVO().getName() + "_集团码导出模板.xls";
			try {
			new File(excelName).createNewFile();
			} catch (Throwable e) {
			throw new VciBaseException(LangBaseUtil.getErrorMsg(e), new String[]{excelName}, e);
			}
			LinkedList<String> finalFieldList = fieldList;
			Map<String, CodeClassifyTemplateAttrVO> attrVOMap = templateVO.getAttributes().stream().filter(s-> finalFieldList.contains(s.getId().toLowerCase(Locale.ROOT))).collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t));
			List<WriteExcelData> excelDataList = new ArrayList<>();
			Workbook workbook = new HSSFWorkbook();
			List<CodeAndGroupCodeAttrMappingDTO> codeAndGroupCodeAttrMappingDTOList= execGroupCodePortDataDTO.getCodeAttrMapGroupAttrDTOS();

			Map<String, CodeAndGroupCodeAttrMappingDTO> jAttrVOMap = codeAndGroupCodeAttrMappingDTOList.stream().filter(s-> finalFieldList.contains(s.getTargetAttrKey().toLowerCase(Locale.ROOT))).collect(Collectors.toMap(s -> s.getTargetAttrKey().toLowerCase(Locale.ROOT), t -> t));

			WriteExcelData codeExcelData = new WriteExcelData(0, 0, "企业编码");
			WriteExcelData groupExcelData = new WriteExcelData(0, 1, "集团码");
			excelDataList.add(codeExcelData);
			excelDataList.add(groupExcelData);
			for (int i = 0; i < fieldList.size(); i++) {
			String attrId=fieldList.get(i);
			if(attrId.equals(CODE_FIELD)\|\|attrId.equals(CODE_GROUP_FIELD)){
			continue;
			}
			if (attrVOMap.containsKey(attrId)) {
			CodeClassifyTemplateAttrVO attrVO = attrVOMap.get(attrId);
			//Object text = attrVO.getName();
			CodeAndGroupCodeAttrMappingDTO codeAttrMappingDTO = jAttrVOMap.get(attrId);
			Object text = codeAttrMappingDTO.getSourceAttrName();
			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};
			dataList.stream().forEach(data -> {
			rowIndex[0]++;
			String id=data.getOrDefault("id", "");
			excelDataList.add(new WriteExcelData(rowIndex[0], 0, id));
			String groupCode=data.getOrDefault("groupcode", "");
			excelDataList.add(new WriteExcelData(rowIndex[0], 1, groupCode));
			List<String> newFieldList = finalFieldList.stream().filter(e -> !e.equals("id") &&!e.equals("groupcode")).collect(Collectors.toList());

			for (int i = 0; i < newFieldList.size(); i++) {
			String attrId = newFieldList.get(i).toLowerCase(Locale.ROOT);
			if(attrId.equals("id")){

			}else if(attrId.equals("groupcode")){

			}else{
			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+2, data.getOrDefault(attrId, "")));
			}
			}
			}
			});
			WriteExcelOption excelOption = new WriteExcelOption();
			excelOption.addSheetDataList(execGroupCodePortDataDTO.getSheetName(),excelDataList);

			//增加模板的信息导入
			LinkedList<WriteExcelData> tempEDList = new LinkedList<>();
			tempEDList.add(new WriteExcelData(0,0,"模板主键"));
			tempEDList.add(new WriteExcelData(0,1,"模板代号"));
			tempEDList.add(new WriteExcelData(0,2,"模板名称"));
			tempEDList.add(new WriteExcelData(1,0,templateVO.getOid()));
			tempEDList.add(new WriteExcelData(1,1,templateVO.getId()));
			tempEDList.add(new WriteExcelData(1,2,templateVO.getName()));
			excelOption.addSheetDataList("模板信息【请勿删除或移动】",tempEDList);
			ExcelUtil.writeDataToFile(excelName, excelOption);
			log.info("文件路径"+excelName);
			return excelName;
			}

			/***
			* 导入集团码
			* @param codeClassifyOid
			* @param file
			* @return
			*/
			public String improtGroupCode(String codeClassifyOid, File file) throws ServiceException {
			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 ServiceException("为了保证系统的稳定性，请一次不要导入超过1万条的数据");
			}
			CodeClassifyFullInfoBO classifyFullInfo = classifyService.getClassifyFullInfo(codeClassifyOid);
			CodeClassifyTemplateVO templateVO = new CodeClassifyTemplateVO();
			//除去默认的属性.还有只有表单显示的字段才导入
			List<CodeClassifyTemplateAttrVO> attrVOS = templateVO.getAttributes().stream().filter(s ->!DEFAULT_SYNC_ATTR_LIST.contains(s.getId()) && VciBaseUtil.getBoolean(s.getFormDisplayFlag())
			).collect(Collectors.toList());
			ExecGroupCodePortDataDTO execGroupCodePortDataDTO=new ExecGroupCodePortDataDTO();
			createExportGroupCodeMapConfig(templateVO,execGroupCodePortDataDTO);//组织数据
			List<CodeAndGroupCodeAttrMappingDTO> codeAttrMapGroupAttrDTOS=execGroupCodePortDataDTO.getCodeAttrMapGroupAttrDTOS();
			if(!CollectionUtils.isEmpty(codeAttrMapGroupAttrDTOS)){
			throw new ServiceException("集团属性映射未配置");
			}
			Map<String, CodeAndGroupCodeAttrMappingDTO> codeSystemObjectMap = codeAttrMapGroupAttrDTOS.stream().filter(codeAttrMappingDTO -> codeAttrMappingDTO != null && StringUtils.isNotBlank(codeAttrMappingDTO.getSourceAttrName())).collect(Collectors.toList()).stream().collect(Collectors.toMap(s -> s.getSourceAttrName(), t -> t));
			SheetDataSet dataSet= sheetDataSetList.get(0);
			List<String> titleRowData = dataSet.getColName();
			Map<Integer/列号/,String/字段的名称/> fieldIndexMap = new HashMap<>();
			getGroupCodeFieldIndexMap(titleRowData,codeAttrMapGroupAttrDTOS,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)){
			String message=unExistAttrVOs.stream().map(CodeClassifyTemplateAttrVO::getName).collect(Collectors.joining(SERIAL_UNIT_SPACE));
			throw new VciBaseException("【" + message + "】这些属性在excel中没有找到");
			}
			List<ClientBusinessObject> cboList = new ArrayList<>();
			List<SheetRowData> rowDataList = dataSet.getRowData();

			getExportGroupCodeDatas(fieldIndexMap,rowDataList,cboList);//构建数据对象
			List<String> codeList= cboList.stream().map(ClientBusinessObject::getId).collect(Collectors.toList());
			List<Map<String,String>>dataList=new ArrayList<>();
			getDatas(classifyFullInfo,templateVO,execGroupCodePortDataDTO.getFieldList(),dataList,codeList);
			//查询系统中存在
			if(!CollectionUtils.isEmpty(dataList)){


			}
			return "";
			}

			/**
			*
			* @param fieldIndexMap
			* @param rowDataList
			* @param cboList
			*/
			private void getExportGroupCodeDatas(Map<Integer,String> fieldIndexMap,List<SheetRowData> rowDataList,List<ClientBusinessObject>cboList){
			rowDataList.stream().forEach(sheetRowData -> {
			sheetRowData.getData().forEach((index,value)->{
			ClientBusinessObject cbo=new ClientBusinessObject();
			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);
			}
			cboList.add(cbo);
			});
			});
			}
			/***
			* 集团导出模板属性映射信息获取
			* @param templateVO
			* @param execGroupCodePortDataDTO
			*/
			private void createExportGroupCodeMapConfig(CodeClassifyTemplateVO templateVO,ExecGroupCodePortDataDTO execGroupCodePortDataDTO){
			String classOid=templateVO.getCodeclassifyoid();
			String templateOid=templateVO.getOid();
			R r=mdmInterJtClient.list_mapping(classOid);
			if(r.isSuccess()){
			List<DockingPreAttrMappingVO>dockingPreAttrMappingVOList= (List<DockingPreAttrMappingVO>) r.getData();
			List<CodeAndGroupCodeAttrMappingDTO> codeAttrMapGroupAttrDTOS=new ArrayList<>();
			LinkedList<String> fieldList=new LinkedList<>();
			LinkedList<String> colNameList=new LinkedList<>();
			dockingPreAttrMappingVOList.stream().forEach(dockingPreAttrMappingVO -> {
			CodeAndGroupCodeAttrMappingDTO codeAndGroupCodeAttrMappingDTO=new CodeAndGroupCodeAttrMappingDTO();
			if(StringUtils.isNotBlank(dockingPreAttrMappingVO.getTargetAttrId())){
			codeAndGroupCodeAttrMappingDTO.setDefaultValue(dockingPreAttrMappingVO.getDefaultValue());
			codeAndGroupCodeAttrMappingDTO.setMetaListId(dockingPreAttrMappingVO.getMetaListId());
			codeAndGroupCodeAttrMappingDTO.setSourceAttrKey(dockingPreAttrMappingVO.getSourceAttrKey());
			codeAndGroupCodeAttrMappingDTO.setSourceAttrName(dockingPreAttrMappingVO.getSourceAttrName());
			codeAndGroupCodeAttrMappingDTO.setTargetAttrId(dockingPreAttrMappingVO.getTargetAttrId());
			codeAndGroupCodeAttrMappingDTO.setTargetAttrKey(dockingPreAttrMappingVO.getTargetAttrKey());
			codeAndGroupCodeAttrMappingDTO.setTargetAttrName(dockingPreAttrMappingVO.getTargetAttrName());
			fieldList.add(dockingPreAttrMappingVO.getTargetAttrKey());
			colNameList.add(dockingPreAttrMappingVO.getSourceAttrName());
			}
			codeAttrMapGroupAttrDTOS.add(codeAndGroupCodeAttrMappingDTO);
			});
			execGroupCodePortDataDTO.setCodeAttrMapGroupAttrDTOS(codeAttrMapGroupAttrDTOS);
			execGroupCodePortDataDTO.setFieldList(fieldList);
			execGroupCodePortDataDTO.setColName(colNameList);
			}
			}

			/***
			* 集团码属性转换
			* @param titleRowData
			* @param codeAttrMapGroupAttrDTOS
			* @param fieldIndexMap
			*/
			private void getGroupCodeFieldIndexMap(List<String> titleRowData,List<CodeAndGroupCodeAttrMappingDTO> codeAttrMapGroupAttrDTOS,Map<Integer/列号/,String/字段的名称/> fieldIndexMap){
			Map<String, CodeAndGroupCodeAttrMappingDTO> codeSystemObjectMap = codeAttrMapGroupAttrDTOS.stream().filter(codeAttrMappingDTO -> codeAttrMappingDTO != null && StringUtils.isNotBlank(codeAttrMappingDTO.getSourceAttrName())).collect(Collectors.toList()).stream().collect(Collectors.toMap(s -> s.getSourceAttrName(), t -> t));
			for (int i = 0; i < titleRowData.size(); i++) {
			String title = titleRowData.get(i);
			CodeAndGroupCodeAttrMappingDTO codeAndGroupCodeAttrMappingDTO =codeSystemObjectMap.get(title.replace(KEY_ATTR_CHAR,"").replace(REQUIRED_CHAR,""));
			String id=codeAndGroupCodeAttrMappingDTO.getTargetAttrKey();
			if(com.alibaba.cloud.commons.lang.StringUtils.isBlank(id) && "集团码".equalsIgnoreCase(title)){
			id = CODE_GROUP_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);
			}
			}


			}
			/***
			* 查询未有集团码的数据
			* @param classifyFullInfo
			* @param templateVO
			* @param selectFieldList
			* @param dataList
			*/
			private void getDatas(CodeClassifyFullInfoBO classifyFullInfo,CodeClassifyTemplateVO templateVO,LinkedList<String> selectFieldList,List<Map<String,String>>dataList,List<String> codeList ){
			//先查询数据
			String btmTypeId = classifyFullInfo.getTopClassifyVO().getBtmTypeId();
			String codeClassifyOid=classifyFullInfo.getCurrentClassifyVO().getOid();
			Map<String, String> conditionMap=new HashMap<>();
			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)) + ")");
			}
			if(!CollectionUtils.isEmpty(codeList)){
			conditionMap.put("id_in",VciBaseUtil.array2String(codeList.toArray(new String[]{})));
			}
			conditionMap.put("codeclsfpath","" + codeClassifyOid + "");
			conditionMap.put("groupcode_null", "null");
			conditionMap.put("lastr", "1");
			conditionMap.put("lastv", "1");

			R<List<BtmTypeVO>> listR = btmTypeClient.selectByIdCollection(Arrays.asList(btmTypeId));
			String tableName = "";
			if(listR.isSuccess() && !listR.getData().isEmpty()){
			tableName = Func.isNotBlank(listR.getData().get(0).getTableName()) ? listR.getData().get(0).getTableName():VciBaseUtil.getTableName(btmTypeId);
			}else{
			tableName = VciBaseUtil.getTableName(btmTypeId);
			}
			PageHelper pageHelper = new PageHelper();
			pageHelper.setLimit(1000000);
			pageHelper.setPage(1);
			pageHelper.addDefaultDesc("createTime");
			DataGrid<Map<String, String>> dataGrid = engineService.queryGrid(btmTypeId, templateVO, conditionMap, pageHelper);
			//转换数据
			if(!CollectionUtils.isEmpty(dataGrid.getData())){
			dataList.addAll(dataGrid.getData());
			}
			//封装查询出来的数据
			engineService.wrapperData(dataList, templateVO, selectFieldList,false);
			//modify by weidy@2022-09-27
			//因为在列表和表单的显示的时候，我们的开关类型页面会处理，但是在导出的时候，我们需要将true和false都替换成中文
			engineService.wrapperBoolean(dataList,templateVO);
			log.info("导出模板的数据条目数:"+dataList.size());
			}
			}