From 8cdc917cd8727ed16e21258f51c0ef4cca51c113 Mon Sep 17 00:00:00 2001
From: wangting <675591594@qq.com>
Date: 星期一, 10 七月 2023 11:02:44 +0800
Subject: [PATCH] Merge remote-tracking branch 'origin/master'

---
 Source/UBCS/ubcs-service/ubcs-code/src/main/java/com/vci/ubcs/code/service/impl/MdmIOServiceImpl.java | 3949 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 files changed, 3,921 insertions(+), 28 deletions(-)

diff --git a/Source/UBCS/ubcs-service/ubcs-code/src/main/java/com/vci/ubcs/code/service/impl/MdmIOServiceImpl.java b/Source/UBCS/ubcs-service/ubcs-code/src/main/java/com/vci/ubcs/code/service/impl/MdmIOServiceImpl.java
index 92eca05..eae24b4 100644
--- a/Source/UBCS/ubcs-service/ubcs-code/src/main/java/com/vci/ubcs/code/service/impl/MdmIOServiceImpl.java
+++ b/Source/UBCS/ubcs-service/ubcs-code/src/main/java/com/vci/ubcs/code/service/impl/MdmIOServiceImpl.java
@@ -1,49 +1,1640 @@
 package com.vci.ubcs.code.service.impl;
 
-import com.alibaba.cloud.commons.lang.StringUtils;
+import com.alibaba.fastjson.JSONObject;
+import com.alibaba.nacos.common.utils.StringUtils;
+import com.baomidou.mybatisplus.core.toolkit.Wrappers;
+import com.vci.ubcs.code.bo.AttributeValue;
 import com.vci.ubcs.code.bo.CodeClassifyFullInfoBO;
+import com.vci.ubcs.code.bo.CodeTemplateAttrSqlBO;
 import com.vci.ubcs.code.dto.CodeOrderDTO;
-import com.vci.ubcs.code.service.ICodeClassifyService;
-import com.vci.ubcs.code.service.MdmEngineService;
-import com.vci.ubcs.code.service.MdmIOService;
-import com.vci.ubcs.code.vo.pagemodel.CodeClassifyTemplateAttrVO;
-import com.vci.ubcs.code.vo.pagemodel.CodeClassifyTemplateVO;
-import com.vci.ubcs.code.vo.pagemodel.CodeClassifyVO;
-import com.vci.ubcs.code.vo.pagemodel.CodeRuleVO;
+import com.vci.ubcs.code.entity.CodeAllCode;
+import com.vci.ubcs.code.entity.CodeClassify;
+import com.vci.ubcs.code.enumpack.CodeDefaultLC;
+import com.vci.ubcs.code.enumpack.CodeLevelTypeEnum;
+import com.vci.ubcs.code.lifecycle.CodeAllCodeLC;
+import com.vci.ubcs.code.mapper.CommonsMapper;
+import com.vci.ubcs.code.service.*;
+import com.vci.ubcs.code.util.ClientBusinessObject;
+import com.vci.ubcs.code.vo.CodeKeyAttrRepeatVO;
+import com.vci.ubcs.code.vo.pagemodel.*;
 import com.vci.ubcs.code.vo.webserviceModel.attrmap.DataObjectVO;
 import com.vci.ubcs.code.vo.webserviceModel.attrmap.RowDatas;
 import com.vci.ubcs.code.vo.webserviceModel.result.xml.XMLResultDataObjectDetailDO;
+import com.vci.ubcs.omd.feign.IBtmTypeClient;
+import com.vci.ubcs.omd.feign.IWebSecretClient;
+import com.vci.ubcs.omd.vo.BtmTypeVO;
+import com.vci.ubcs.starter.bo.WriteExcelData;
 import com.vci.ubcs.starter.exception.VciBaseException;
-import com.vci.ubcs.starter.web.util.VciBaseUtil;
+import com.vci.ubcs.starter.poi.bo.ReadExcelOption;
+import com.vci.ubcs.starter.poi.bo.SheetDataSet;
+import com.vci.ubcs.starter.poi.bo.SheetRowData;
+import com.vci.ubcs.starter.poi.bo.WriteExcelOption;
+import com.vci.ubcs.starter.poi.util.ExcelUtil;
+import com.vci.ubcs.starter.revision.model.BaseModel;
+import com.vci.ubcs.starter.util.DefaultAttrAssimtUtil;
+import com.vci.ubcs.starter.util.LocalFileUtil;
+import com.vci.ubcs.starter.util.MdmBtmTypeConstant;
+import com.vci.ubcs.starter.web.constant.QueryOptionConstant;
+import com.vci.ubcs.starter.web.enumpck.BooleanEnum;
+import com.vci.ubcs.starter.web.enumpck.UserSecretEnum;
+import com.vci.ubcs.starter.web.enumpck.VciFieldTypeEnum;
+import com.vci.ubcs.starter.web.pagemodel.*;
+import com.vci.ubcs.starter.web.toolmodel.DateConverter;
+import com.vci.ubcs.starter.web.util.*;
+import lombok.AllArgsConstructor;
+import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
-import org.springframework.context.annotation.Lazy;
+import org.apache.commons.collections4.map.HashedMap;
+import org.apache.poi.hssf.usermodel.HSSFRichTextString;
+import org.apache.poi.hssf.usermodel.HSSFWorkbook;
+import org.apache.poi.hssf.util.HSSFColor;
+import org.apache.poi.ss.usermodel.Font;
+import org.apache.poi.ss.usermodel.RichTextString;
+import org.apache.poi.ss.usermodel.Workbook;
+import org.springblade.core.cache.utils.CacheUtil;
+import org.springblade.core.redis.cache.BladeRedis;
+import org.springblade.core.tool.api.R;
+import org.springframework.beans.BeanUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Value;
 import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
 import org.springframework.util.CollectionUtils;
-
 import javax.annotation.Resource;
+import java.io.File;
+import java.io.IOException;
+import java.text.MessageFormat;
 import java.util.*;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.CopyOnWriteArrayList;
+import java.util.concurrent.CopyOnWriteArraySet;
 import java.util.stream.Collectors;
 
+import static com.alibaba.druid.util.FnvHash.Constants.LIMIT;
 import static com.vci.ubcs.code.constant.MdmEngineConstant.*;
-import static com.vci.ubcs.starter.poi.util.ExcelUtil.KEY_ATTR_CHAR;
-import static com.vci.ubcs.starter.poi.util.ExcelUtil.REQUIRED_CHAR;
+import static com.vci.ubcs.starter.poi.util.ExcelUtil.*;
 
+@RequiredArgsConstructor
 @Service
 @Slf4j
 public class MdmIOServiceImpl implements MdmIOService {
-	/**
-	 * 鍒嗙被鏈嶅姟灞�
-	 */
-	@Resource
-	@Lazy
-	private ICodeClassifyService classifyService;
+
 
 	/**
-	 * 鍒嗙被鏈嶅姟灞�
+	 * 瀛楁
+	 */
+	public static final String ROW_INDEX = "LAY_TABLE_INDEX";
+
+	/**
+	 * 閿欒淇℃伅鐨勫瓧娈�
+	 */
+	public static final String ERROR_MSG = "errorMsg";
+
+	@Value("${batchadd.exportattr.type:鍩烘湰淇℃伅}")
+	public String BATCHADD_EXCEPORT_ATTR_TYPE;
+
+	@Value("${batchadd.redis.time:6000000}")
+	public int BATCHADD_REDIS_TIME;
+	/**
+	 * 涓婚搴撳垎绫荤殑鏈嶅姟
 	 */
 	@Resource
-	@Lazy
+	private ICodeClassifyService classifyService;
+
+
+	/**
+	 * 閫氱敤鏌ヨ
+	 */
+	@Resource
+	private CommonsMapper commonsMapper;
+	/****
+	 * 鐮佸�兼湇鍔�
+	 */
+	@Resource
+	ICodeAllCodeService codeAllCodeService;
+
+	/**
+	 * 妯℃澘鐨勬湇鍔�
+	 */
+	@Resource
+	private CodeClstemplateServiceImpl templateService;
+
+	/**
+	 * 涓绘暟鎹紩鎿庣殑鏈嶅姟
+	 */
+	@Resource
 	private MdmEngineService engineService;
+	/***
+	 * resdis缂撳瓨鏈嶅姟
+	 */
+	private final BladeRedis bladeRedis;
+	/**
+	 * 鐢熸垚缂栫爜鐨勬湇鍔�
+	 */
+	@Resource
+	private MdmProductCodeService productCodeService;
+	/**
+	 * 鍏抽敭灞炴�х殑閰嶇疆
+	 */
+	@Autowired
+	private ICodeKeyAttrRepeatService keyRuleService;
+
+	/**
+	 * 鍏紡鐨勬湇鍔�
+	 */
+	@Autowired
+	private FormulaServiceImpl formulaService;
+	/**
+	 * 瑙勫垯鐨勬湇鍔�
+	 */
+	@Autowired
+	private ICodeRuleService ruleService;
+	/**
+	 * 涓氬姟绫诲瀷鐨勬湇鍔�
+	 */
+	@Autowired
+	private IBtmTypeClient btmTypeClient;
+	/***
+	 * 瀵嗙骇鏈嶅姟
+	 */
+	@Resource
+	private IWebSecretClient secretService;
+	/**
+	 * 鎵归噺鐢宠锛氶�夊彇閫変腑鍒嗙被涓嬬殑鎵�鏈夋ā鏉垮叧閿睘鎬э紝鐩镐技灞炴�э紝蹇呭～灞炴�э紝鍐欏叆execl涓�
+	 *
+	 * @param codeClassifyOid 鍒嗙被鐨勪富閿�
+	 * @return excel鐨勬枃浠跺湴鍧�
+	 */
+	@Override
+	public  String downloadTopImportExcel(String codeClassifyOid){
+		List<CodeClassifyTemplateVO> templateVOList=new ArrayList<>();
+		VciBaseUtil.alertNotNull("瀵煎嚭妯℃澘","瀵煎嚭鐨勯厤缃�",codeClassifyOid,"涓婚搴撳垎绫荤殑涓婚敭");
+		CodeClassifyVO codeClassifyVO = classifyService.getObjectByOid(codeClassifyOid);
+		templateVOList= templateService.childTemplates(codeClassifyOid);
+		List<CodeClassifyVO>  codeClassifyVOS=classifyService.getIdPathToNamePathByParentId(codeClassifyOid,true);
+		WriteExcelOption eo = new WriteExcelOption();
+		LinkedHashMap<String,CodeClassifyTemplateAttrVO> allFieldToOutNameMap=new LinkedHashMap<>();
+		templateVOList.stream().forEach(templateVO -> {
+			//缁勫悎鏍煎紡鐨勪笉瀵煎叆锛�
+			// 鏋氫妇鐨勬彁渚涘簭鍒楃殑閫夋嫨
+			//鏃堕棿鍏ㄩ儴缁熶竴涓簓yyy-MM-dd HH:mm:ss
+			//鍙傜収鐨勮嚜琛岃緭鍏ュ悕绉�
+			//鍒嗙被娉ㄥ叆鐨勪笉鐢紝閮芥槸瀵煎叆鍚庤嚜鍔ㄥ鐞嗙殑
+			//缂栫爜锛岀姸鎬佺瓑瀛楁涓嶅鍏�
+			List<CodeClassifyTemplateAttrVO> templateAttrVOS = templateVO.getAttributes().stream().filter(s ->
+				!DEFAULT_ATTR_LIST.contains(s.getId())
+					&& StringUtils.isBlank(s.getComponentRule())
+					&& StringUtils.isBlank(s.getClassifyInvokeAttr())
+					&& (VciBaseUtil.getBoolean(s.getFormDisplayFlag()))
+			).collect(Collectors.toList());
+			if(CollectionUtils.isEmpty(templateAttrVOS)){
+				throw new VciBaseException("妯℃澘娌℃湁閰嶇疆浠讳綍銆愯〃鍗曟樉绀恒�戜负銆愭槸銆戠殑灞炴��");
+			}
+			templateAttrVOS.stream().forEach(codetemplateAttr ->{
+				String field=codetemplateAttr.getId();
+				String name=codetemplateAttr.getName();
+				CodeClassifyTemplateAttrVO codeBaseAttributeDTO=new CodeClassifyTemplateAttrVO();
+				boolean res=(StringUtils.isNotBlank(codetemplateAttr.getAttributeGroup())&& codetemplateAttr.getAttributeGroup().equals(BATCHADD_EXCEPORT_ATTR_TYPE))//鍩烘湰灞炴�у瓧娈垫樉绀�
+					||(StringUtils.isNotBlank(codetemplateAttr.getKeyAttrFlag())&&Boolean.parseBoolean(codetemplateAttr.getKeyAttrFlag()))//鍏抽敭灞炴�х殑瀛樺叆
+					||(StringUtils.isNotBlank(codetemplateAttr.getSameRepeatAttrFlag())&&Boolean.parseBoolean(codetemplateAttr.getSameRepeatAttrFlag())) //鐩镐技灞炴�х殑瀛樺叆
+					||(StringUtils.isNotBlank(codetemplateAttr.getRequireFlag())&&Boolean.parseBoolean(codetemplateAttr.getRequireFlag()));
+				if(allFieldToOutNameMap.containsKey(name)){//濡傛灉瀛樺湪鐨勮瘽鍒欓渶瑕佹牴鎹叿浣撶殑鍘昏祴鍊�
+					codeBaseAttributeDTO=  allFieldToOutNameMap.get(name);
+					if(StringUtils.isNotBlank(codetemplateAttr.getKeyAttrFlag())&&Boolean.parseBoolean(codetemplateAttr.getKeyAttrFlag())){
+						codeBaseAttributeDTO.setKeyAttrFlag(codetemplateAttr.getKeyAttrFlag());//灞炴�у叧閿睘鎬�
+					}
+					if(StringUtils.isNotBlank(codetemplateAttr.getRequireFlag())&&Boolean.parseBoolean(codetemplateAttr.getRequireFlag())){
+						codeBaseAttributeDTO.setRequireFlag(codetemplateAttr.getRequireFlag());//灞炴�у繀濉」
+					}
+					if(StringUtils.isNotBlank(codetemplateAttr.getSameRepeatAttrFlag())&&Boolean.parseBoolean(codetemplateAttr.getSameRepeatAttrFlag())){
+						codeBaseAttributeDTO.setSameRepeatAttrFlag(codetemplateAttr.getSameRepeatAttrFlag());//灞炴�х浉浼煎睘鎬�
+					}
+				}else if(res){
+					allFieldToOutNameMap.put(name,codetemplateAttr);
+				}
+			});
+		});
+		//鏁寸悊濂芥墍鏈夋ā鏉块渶瑕佸啓鍏xecl鐨勫睘鎬т俊鎭�
+		Workbook workbook = new HSSFWorkbook();
+		LinkedList<WriteExcelData> excelDataList = new LinkedList<>();
+		if(!CollectionUtils.isEmpty(allFieldToOutNameMap)){
+			excelDataList.add(new WriteExcelData(0,0,"鍒嗙被璺緞"));
+			final int[] index = {0};
+			allFieldToOutNameMap.values().stream().forEach(attrVO -> {
+				Object text = attrVO.getName();
+				text = exportKeyAndRequired(workbook,attrVO,text);
+				int colIndex = 1 + index[0]++;
+				WriteExcelData excelData = new WriteExcelData(0, colIndex, text);
+				if(StringUtils.isNotBlank(attrVO.getCodeDateFormat())
+					|| VciFieldTypeEnum.VTDateTime.name().equalsIgnoreCase(attrVO.getAttributeDataType())
+					|| VciFieldTypeEnum.VTDate.name().equalsIgnoreCase(attrVO.getAttributeDataType())
+					||VciFieldTypeEnum.VTTime.name().equalsIgnoreCase(attrVO.getAttributeDataType())){
+					excelData.setDateFormat(VciDateUtil.DateTimeFormat);
+				}
+				if(text instanceof RichTextString){
+					excelData.setFontColor(String.valueOf(HSSFColor.HSSFColorPredefined.RED.getIndex()));
+				}
+				excelDataList.add(excelData);
+				if(StringUtils.isNotBlank(attrVO.getEnumString()) || StringUtils.isNotBlank(attrVO.getEnumId())){
+					//娣诲姞鏁版嵁鏈夋晥鎬�
+					List<String> enumValueList = new ArrayList<>();
+					enumValueList.add("");
+					List<KeyValue> valueList = engineService.listComboboxItems(attrVO);
+					if(!CollectionUtils.isEmpty(valueList)){
+						valueList.stream().forEach(kv->{
+							enumValueList.add(kv.getValue());
+						});
+					}
+					//榛樿鍔�1涓囨潯
+					WriteExcelData ed = new WriteExcelData(1,colIndex,"");
+					ed.setRowTo(100);
+					ed.setColTo(colIndex);
+					ed.setValidation(true);
+					ed.setValidationDataList(enumValueList);
+					ed.setValidationErrorMsg("璇峰湪搴忓垪涓�夋嫨姝ｇ‘鐨勫��");
+					excelDataList.add(ed);
+				}
+				if(VciFieldTypeEnum.VTBoolean.name().equalsIgnoreCase(attrVO.getAttributeDataType())){
+					List<String> booleanList = new ArrayList<>();
+					booleanList.add("鏄�");
+					booleanList.add("鍚�");
+					//榛樿鍔�1涓囨潯
+					WriteExcelData ed = new WriteExcelData(1,colIndex,"");
+					ed.setRowTo(100);
+					ed.setColTo(colIndex);
+					ed.setValidation(true);
+					ed.setValidationDataList(booleanList);
+					ed.setValidationErrorMsg("璇峰湪搴忓垪涓�夋嫨姝ｇ‘鐨勫��");
+					excelDataList.add(ed);
+				}
+			});
+			eo.addSheetDataList(codeClassifyVO.getName()+"瀵煎叆妯℃澘",excelDataList);
+		}
+		LinkedList<WriteExcelData> classPathList = new LinkedList<>();
+		classPathList.add(new WriteExcelData(0,0,"鍒嗙被灞傜骇"));
+
+		WriteExcelData idPathWriteExcelTitle=new WriteExcelData(0,1,"鍒嗙被ID璺緞");
+		idPathWriteExcelTitle.setWidth(20);
+		idPathWriteExcelTitle.setCenter(false);
+		classPathList.add(idPathWriteExcelTitle);
+		WriteExcelData namePathWriteExcelTitle=new WriteExcelData(0,2,"鍒嗙被鍚嶇О璺緞");
+		namePathWriteExcelTitle.setWidth(20);
+		namePathWriteExcelTitle.setCenter(false);
+		classPathList.add(namePathWriteExcelTitle);
+
+
+		final int[] rowIndex = {1};
+		codeClassifyVOS.stream().forEach(codeClassifyVO1 -> {
+			classPathList.add(new WriteExcelData(rowIndex[0],0,codeClassifyVO1.getDataLevel()));
+
+			String idPath=codeClassifyVO1.getIdPath().startsWith("#")?codeClassifyVO1.getIdPath().substring(1):codeClassifyVO1.getIdPath();
+			WriteExcelData idPathWriteExcelData=new WriteExcelData(rowIndex[0],1,idPath);
+			idPathWriteExcelData.setWidth(30);
+			idPathWriteExcelData.setCenter(false);
+			classPathList.add(idPathWriteExcelData);
+
+			String namePath=codeClassifyVO1.getNamePath().startsWith("#")?codeClassifyVO1.getNamePath().substring(1):codeClassifyVO1.getNamePath();
+			WriteExcelData  namePathWriteExcelData=  new WriteExcelData(rowIndex[0],2,namePath);
+			namePathWriteExcelData.setWidth(40);
+			namePathWriteExcelData.setCenter(false);
+			classPathList.add(namePathWriteExcelData);
+			rowIndex[0]++;
+		});
+
+		WriteExcelData  excelData=new WriteExcelData();
+		excelData.setMerged(true);
+		excelData.setRow(1);
+		excelData.setRowTo(2);
+		excelData.setCol(4);
+		excelData.setColTo(9);
+		excelData.setCenter(false);
+		excelData.setReadOnly(true);
+		excelData.setObj("瀵煎叆鏁版嵁鏃讹紝鍒嗙被璺緞蹇呴』濉啓鍙跺瓙鑺傜偣璺緞\n(閫夋嫨鍙跺瓙鑺傜偣瀵煎叆鍒欎笉闇�瑕佸～鍐欏垎绫昏矾寰�)");
+		excelData.setFontColor(String.valueOf(HSSFColor.HSSFColorPredefined.RED.getIndex()));
+		classPathList.add(excelData);
+
+		eo.addSheetDataList(codeClassifyVO.getName()+"鍒嗙被瀵圭収琛�",classPathList);
+
+		String excelName = LocalFileUtil.getDefaultTempFolder() + File.separator + codeClassifyVO.getName() + "_瀵煎叆妯℃澘.xls";
+		// eo.addSheetDataList(templateVOList.size()+"妯℃澘淇℃伅銆愯鍕垮垹闄ゆ垨绉诲姩銆�",tempEDList);
+		ExcelUtil.writeDataToFile(excelName,eo);
+		return excelName;
+	}
+
+	/**
+	 * 鐢熸垚瀵煎叆鐨勬枃浠�
+	 *
+	 * @param codeClassifyOid 鍒嗙被鐨勪富閿�
+	 * @param isHistory 鏄惁鍘嗗彶鏁版嵁瀵煎叆
+	 * @return excel鐨勬枃浠跺湴鍧�
+	 */
+	@Override
+	public String createImportExcel(String codeClassifyOid, boolean isHistory) {
+		List<CodeClassifyTemplateVO> templateVOList=new ArrayList<>();
+
+		VciBaseUtil.alertNotNull("瀵煎嚭妯℃澘","瀵煎嚭鐨勯厤缃�",codeClassifyOid,"涓婚搴撳垎绫荤殑涓婚敭");
+
+		CodeClassifyVO codeClassifyVO = classifyService.getObjectByOid(codeClassifyOid);
+
+		if(isHistory){
+			templateVOList= templateService.childTemplates(codeClassifyOid);
+		}else{
+			//鎵炬ā鏉�
+			CodeClassifyTemplateVO templateVO = engineService.getUsedTemplateByClassifyOid(codeClassifyOid);
+			templateVOList.add(templateVO);
+		}
+
+		WriteExcelOption eo = new WriteExcelOption();
+		eo.setAppend(true);
+		//澧炲姞妯℃澘鐨勪俊鎭鍏�
+		LinkedList<WriteExcelData> tempEDList = new LinkedList<>();
+		tempEDList.add(new WriteExcelData(0,0,"妯℃澘涓婚敭"));
+		tempEDList.add(new WriteExcelData(0,1,"妯℃澘浠ｅ彿"));
+		tempEDList.add(new WriteExcelData(0,2,"妯℃澘鍚嶇О"));
+		for(int j=0;j<templateVOList.size();j++){
+			CodeClassifyTemplateVO  templateVO=templateVOList.get(j);
+			CodeClassifyTemplateVO codeClassifyTemplateVO = new CodeClassifyTemplateVO();
+			BeanUtils.copyProperties(templateVO,codeClassifyTemplateVO);
+			//缁勫悎鏍煎紡鐨勪笉瀵煎叆锛�
+			// 鏋氫妇鐨勬彁渚涘簭鍒楃殑閫夋嫨
+			//鏃堕棿鍏ㄩ儴缁熶竴涓簓yyy-MM-dd HH:mm:ss
+			//鍙傜収鐨勮嚜琛岃緭鍏ュ悕绉�
+			//鍒嗙被娉ㄥ叆鐨勪笉鐢紝閮芥槸瀵煎叆鍚庤嚜鍔ㄥ鐞嗙殑
+			//缂栫爜锛岀姸鎬佺瓑瀛楁涓嶅鍏�
+			List<CodeClassifyTemplateAttrVO> templateAttrVOS = codeClassifyTemplateVO.getAttributes().stream().filter(s ->
+				!DEFAULT_ATTR_LIST.contains(s.getId())
+					&& StringUtils.isBlank(s.getComponentRule())
+					&& StringUtils.isBlank(s.getClassifyInvokeAttr())
+					&& (isHistory || VciBaseUtil.getBoolean(s.getFormDisplayFlag()))
+			).collect(Collectors.toList());
+
+			if(CollectionUtils.isEmpty(templateAttrVOS)){
+				throw new VciBaseException("妯℃澘娌℃湁閰嶇疆浠讳綍銆愯〃鍗曟樉绀恒�戜负銆愭槸銆戠殑灞炴��");
+			}
+			List<CodeClassifyTemplateAttrVO> idAttrVOList = codeClassifyTemplateVO.getAttributes().stream().filter(s -> s.getId().equalsIgnoreCase(CODE_FIELD)).collect(Collectors.toList());
+			LinkedList<WriteExcelData> excelDataList = new LinkedList<>();
+			Workbook workbook = new HSSFWorkbook();
+			if(isHistory){
+				excelDataList.add(new WriteExcelData(0,0,"鍒嗙被璺緞"));
+				excelDataList.add(new WriteExcelData(0,1,"鐮佹瀹藉害"));
+				excelDataList.add(new WriteExcelData(0,2,!CollectionUtils.isEmpty(idAttrVOList)?idAttrVOList.get(0).getName():"浼佷笟缂栫爜"));
+			}
+			for (int i = 0; i < templateAttrVOS.size(); i++) {
+				CodeClassifyTemplateAttrVO attrVO = templateAttrVOS.get(i);
+
+				Object text = attrVO.getName();
+				text = exportKeyAndRequired(workbook,attrVO,text);
+				int colIndex = (isHistory?3:0) + i;
+				WriteExcelData excelData = new WriteExcelData(0, colIndex, text);
+				if(StringUtils.isNotBlank(attrVO.getCodeDateFormat())
+					|| VciFieldTypeEnum.VTDateTime.name().equalsIgnoreCase(attrVO.getAttributeDataType())
+					|| VciFieldTypeEnum.VTDate.name().equalsIgnoreCase(attrVO.getAttributeDataType())
+					||VciFieldTypeEnum.VTTime.name().equalsIgnoreCase(attrVO.getAttributeDataType())){
+					excelData.setDateFormat(VciDateUtil.DateTimeFormat);
+				}
+				if(text instanceof RichTextString){
+					excelData.setFontColor(String.valueOf(HSSFColor.HSSFColorPredefined.RED.getIndex()));
+				}
+				excelDataList.add(excelData);
+				if(StringUtils.isNotBlank(attrVO.getEnumString()) || StringUtils.isNotBlank(attrVO.getEnumId())){
+					//娣诲姞鏁版嵁鏈夋晥鎬�
+					List<String> enumValueList = new ArrayList<>();
+					enumValueList.add("");
+					List<KeyValue> valueList = engineService.listComboboxItems(attrVO);
+					if(!CollectionUtils.isEmpty(valueList)){
+						valueList.stream().forEach(kv->{
+							enumValueList.add(kv.getValue());
+						});
+					}
+					//榛樿鍔�1涓囨潯
+					WriteExcelData ed = new WriteExcelData(1,colIndex,"");
+					ed.setRowTo(100);
+					ed.setColTo(colIndex);
+					ed.setValidation(true);
+					ed.setValidationDataList(enumValueList);
+					ed.setValidationErrorMsg("璇峰湪搴忓垪涓�夋嫨姝ｇ‘鐨勫��");
+					excelDataList.add(ed);
+				}
+				if(VciFieldTypeEnum.VTBoolean.name().equalsIgnoreCase(attrVO.getAttributeDataType())){
+					List<String> booleanList = new ArrayList<>();
+
+					booleanList.add("鏄�");
+					booleanList.add("鍚�");
+					//榛樿鍔�1涓囨潯
+					WriteExcelData ed = new WriteExcelData(1,colIndex,"");
+					ed.setRowTo(100);
+					ed.setColTo(colIndex);
+					ed.setValidation(true);
+					ed.setValidationDataList(booleanList);
+					ed.setValidationErrorMsg("璇峰湪搴忓垪涓�夋嫨姝ｇ‘鐨勫��");
+					excelDataList.add(ed);
+				}
+			}
+			eo.addSheetDataList(j+templateVO.getName(),excelDataList);
+			tempEDList.add(new WriteExcelData(j+1,0,templateVO.getOid()));
+			tempEDList.add(new WriteExcelData(j+1,1,templateVO.getId()));
+			tempEDList.add(new WriteExcelData(j+1,2,templateVO.getName()));
+		}
+		String excelName = LocalFileUtil.getDefaultTempFolder() + File.separator + codeClassifyVO.getName() + (isHistory?"_鍘嗗彶鏁版嵁瀵煎叆妯℃澘.xls": "_瀵煎叆妯℃澘.xls");
+		eo.addSheetDataList(templateVOList.size()+"妯℃澘淇℃伅銆愯鍕垮垹闄ゆ垨绉诲姩銆�",tempEDList);
+		ExcelUtil.writeDataToFile(excelName,eo);
+		return excelName;
+	}
+
+	/**
+	 * 瀵煎嚭鐨勬椂鍊欏皝瑁呭繀杈撳拰鍏抽敭灞炴��
+	 * @param attrVO 灞炴�х殑鏄剧ず瀵硅薄
+	 * @param text 鍗曞厓鏍肩殑鍊�
+	 */
+	private Object exportKeyAndRequired(Workbook workbook,CodeClassifyTemplateAttrVO attrVO,Object text){
+		//蹇呰緭鍔�*锛屽叧閿睘鎬т负钃濊壊
+		if (VciBaseUtil.getBoolean(attrVO.getRequireFlag()) || VciBaseUtil.getBoolean(attrVO.getKeyAttrFlag())) {
+			String value = text.toString();
+			if(VciBaseUtil.getBoolean(attrVO.getRequireFlag())) {
+				value += REQUIRED_CHAR;
+			}
+			if(VciBaseUtil.getBoolean(attrVO.getKeyAttrFlag())){
+				value += KEY_ATTR_CHAR;
+			}
+			RichTextString ts = new HSSFRichTextString(value);
+			if(VciBaseUtil.getBoolean(attrVO.getRequireFlag())){
+				Font font =  workbook.createFont();
+				font.setColor(HSSFColor.HSSFColorPredefined.RED.getIndex());
+				ts.applyFont(font);
+			}
+
+			if(VciBaseUtil.getBoolean(attrVO.getKeyAttrFlag())){
+				Font font =  workbook.createFont();
+				font.setColor(HSSFColor.HSSFColorPredefined.BLUE.getIndex());
+				ts.applyFont(font);
+			}
+			return ts;
+		}
+		return text;
+	}
+
+
+	/**
+	 * 鎵归噺鐢宠缂栫爜鏁版嵁
+	 *
+	 * @param orderDTO 缂栫爜鐢宠淇℃伅锛屽繀椤诲寘鍚垎绫讳富閿拰鐮佹鐨勪俊鎭�
+	 * @param file     excel鏂囦欢鐨勪俊鎭�
+	 * @return  鏈夐敊璇俊鎭殑excel鐨勬枃浠�
+	 */
+	@Override
+	public CodeImProtRusultVO batchImportCode(CodeOrderDTO orderDTO, File file) {
+		VciBaseUtil.alertNotNull(orderDTO,"缂栫爜鐢宠鐩稿叧鐨勬暟鎹�",orderDTO.getCodeClassifyOid(),"涓婚搴撳垎绫讳富閿�");
+		ReadExcelOption reo = new ReadExcelOption();
+		reo.setReadAllSheet(true);
+		List<SheetDataSet> sheetDataSetList = ExcelUtil.readDataObjectFromExcel(file,null,reo);
+		if(CollectionUtils.isEmpty(sheetDataSetList) || CollectionUtils.isEmpty(sheetDataSetList.get(0).getRowData())
+			||sheetDataSetList.get(0).getRowData().size()<1){
+			throw new VciBaseException("娌℃湁璇诲彇鍒颁换浣曠殑鏁版嵁");
+		}
+		if(sheetDataSetList.size()>LIMIT+1){
+			throw new VciBaseException("涓轰簡淇濊瘉绯荤粺鐨勭ǔ瀹氭�э紝璇蜂竴娆′笉瑕佸鍏ヨ秴杩�1涓囨潯鐨勬暟鎹�");
+		}
+		//鍏堟壘鍒版瘡涓�琛岀殑鏍囬锛岀劧鍚庢牴鎹爣棰樻潵鑾峰彇瀵瑰簲鐨勫睘鎬�
+		SheetDataSet dataSet = sheetDataSetList.get(0);
+		//鎵剧涓�琛岋紝涓轰簡鎵炬爣棰�
+		CodeClassifyTemplateVO templateVO = engineService.getUsedTemplateByClassifyOid(orderDTO.getCodeClassifyOid());
+
+		//鏍￠獙妯℃澘鏄笉鏄渶鏂扮殑
+		checkTemplateSync(sheetDataSetList,templateVO,0);
+		//鍏堜笉鐢ㄧ灞炴�ф槸鍚﹂兘瀛樺湪锛屽厛杞崲涓�涓嬫暟鎹�
+		Map<String,String> errorMap = new HashMap<>();
+		String redisUUid=batchImportCodes(orderDTO,templateVO,dataSet,errorMap,true);
+		CodeImProtRusultVO codeImProtRusultVO = new CodeImProtRusultVO();
+		List<String> needRowIndexList = new ArrayList<>();
+		String filePath = returnErrorToExcel(dataSet.getRowData(), errorMap, needRowIndexList, dataSet.getColName());
+		if(StringUtils.isNotBlank(filePath)) {
+			codeImProtRusultVO.setFilePath(filePath);
+		}
+		if(StringUtils.isNotBlank(redisUUid)){
+			codeImProtRusultVO.setRedisUuid(redisUUid);
+		}
+//		return null;
+		return codeImProtRusultVO;
+	}
+
+
+	/***
+	 * 浠庨《灞傛壒閲忕敵璇峰鍏ユ柟娉�
+	 * @param codeClassifyOid 鍒嗙被鐨勪富閿�
+	 * @param classifyAttr 鍒嗙被璺緞浣跨敤鐨勫睘鎬�
+	 * @param file excel鏂囦欢鐨勪俊鎭�
+	 * @return
+	 */
+	@Override
+	public CodeImProtRusultVO batchTopImportCode(String codeClassifyOid, String classifyAttr, File file) {
+		VciBaseUtil.alertNotNull(codeClassifyOid,"鍒嗙被鐨勪富閿�");
+		ReadExcelOption reo = new ReadExcelOption();
+		reo.setReadAllSheet(true);
+		List<SheetDataSet> sheetDataSetList = ExcelUtil.readDataObjectFromExcel(file,null,reo);
+		if(CollectionUtils.isEmpty(sheetDataSetList) || CollectionUtils.isEmpty(sheetDataSetList.get(0).getRowData())
+			||sheetDataSetList.get(0).getRowData().size()<1){
+			throw new VciBaseException("娌℃湁璇诲彇鍒颁换浣曠殑鏁版嵁");
+		}
+		if(sheetDataSetList.size()>LIMIT+1){
+			throw new VciBaseException("涓轰簡淇濊瘉绯荤粺鐨勭ǔ瀹氭�э紝璇蜂竴娆′笉瑕佸鍏ヨ秴杩�1涓囨潯鐨勬暟鎹�");
+		}
+		//鍏堟壘鍒版瘡涓�琛岀殑鏍囬锛岀劧鍚庢牴鎹爣棰樻潵鑾峰彇瀵瑰簲鐨勫睘鎬�
+		SheetDataSet dataSet = sheetDataSetList.get(0);
+		CodeClassifyFullInfoBO classifyFullInfo = classifyService.getClassifyFullInfo(codeClassifyOid);
+		//鑾峰彇褰撳墠妯℃澘
+		CodeClassifyTemplateVO selectCodeClassifyTemplateVO =engineService.getUsedTemplateByClassifyOid(codeClassifyOid);
+		Map<String,List<ColumnVO>> templateColumnVOMap=new HashMap<>();
+		createTemplate(selectCodeClassifyTemplateVO,templateColumnVOMap);
+
+		List<CodeClassifyVO> childClassifyVOs = classifyService.listChildrenClassify(codeClassifyOid, true, classifyAttr, true);
+		Map<String/**璺緞**/, CodeClassifyVO> pathMap = Optional.ofNullable(childClassifyVOs).orElseGet(() -> new ArrayList<>()).stream().collect(Collectors.toMap(s -> s.getPath().startsWith("#") ? s.getPath().substring(1) : s.getPath(), t -> t));
+		pathMap.put("#current#", classifyFullInfo.getCurrentClassifyVO());
+		List<String> titleRowData = dataSet.getColName();
+		Map<String, String> errorMap = new ConcurrentHashMap<>();
+		//棣栧厛灏嗘暟鎹互妯℃澘鐨勫舰寮忓垎寮�
+		LinkedHashMap<String,List<CodeImprotDataVO>> codeclassifyDataMap=new LinkedHashMap<>();
+		List<CodeImprotDataVO> codeClassifyDatas=new ArrayList<>();
+		createExeclClassData(dataSet,pathMap,errorMap,codeClassifyDatas);
+
+		//鏍规嵁妯℃澘灏嗘暟鎹暣鍚堝湪涓�璧凤紝鍘绘牎楠�
+		Map<String/**妯℃澘oid**/, List<CodeImprotDataVO>/**鏁版嵁瀵硅薄**/> templateDatasMap =codeClassifyDatas.stream().collect(Collectors.toMap(CodeImprotDataVO::getTemplateOid,s->{
+			List<CodeImprotDataVO> l=new ArrayList<>();
+			l.add(s);
+			return l;
+		},(List<CodeImprotDataVO> s1,List<CodeImprotDataVO> s2)->{
+			s1.addAll(s2);
+			return s1;
+		}));
+		String uuid=VciBaseUtil.getPk();
+		List<CodeImportTemplateVO> codeImportTemplateVOS=new ArrayList<>();
+		Map<String,CodeImportTemplateVO> codeRuleMap=new HashMap<>();
+
+		//鐩镐技鏁版嵁
+		// Map<String,String>wpResembleMap=new HashMap<>();
+		// List<CodeImprotDataVO> wpCodeImprotDataVOList=new ArrayList<>();
+		//鎸夌収妯℃澘鍘绘暣鐞嗘暟鎹�
+		templateDatasMap.keySet().stream().forEach(templateVOOid->{
+			List<CodeImprotDataVO> codeImprotDataVOS= templateDatasMap.get(templateVOOid);
+			CodeClassifyTemplateVO templateVO= templateService.getObjectHasAttrByOid(templateVOOid);
+
+			//闄ゅ幓榛樿鐨勫睘鎬�.杩樻湁鍙湁琛ㄥ崟鏄剧ず鐨勫瓧娈垫墠瀵煎叆
+			List<CodeClassifyTemplateAttrVO> attrVOS = templateVO.getAttributes().stream().filter(s ->
+				!DEFAULT_ATTR_LIST.contains(s.getId()) && VciBaseUtil.getBoolean(s.getFormDisplayFlag())
+			).collect(Collectors.toList());
+
+			Map<String/**妯℃澘灞炴�у瓧娈祇id**/, String /**妯℃澘灞炴�у閮ㄥ悕绉�**/> fieldNameMap =attrVOS.stream().collect(Collectors.toMap(CodeClassifyTemplateAttrVO::getId,s->s.getName()));
+
+			List<ClientBusinessObject> allCboList=new ArrayList<>();
+			codeImprotDataVOS.stream().forEach(codeImprotDataVO -> {
+				List<ColumnVO>columnVOList =new ArrayList();
+				String templateOid=selectCodeClassifyTemplateVO.getOid();
+				if(templateColumnVOMap.containsKey(templateOid)){
+					columnVOList= columnVOList=templateColumnVOMap.get(templateOid);
+				}else{
+					createTemplate(templateVO,templateColumnVOMap);
+					columnVOList= columnVOList=templateColumnVOMap.get(templateOid);
+				}
+				String codeRuleOid=codeImprotDataVO.getCodeRuleOid();
+				if(!codeRuleMap.containsKey(codeRuleOid)){
+					CodeImportTemplateVO codeImportTemplateVO=new CodeImportTemplateVO();
+					codeImportTemplateVO.setRoot(false);
+					codeImportTemplateVO.setCodeClassifyOid(codeImprotDataVO.getCodeClassifyOid());
+					codeImportTemplateVO.setCodeRuleOid(codeImprotDataVO.getCodeRuleOid());
+					codeImportTemplateVO.setCodeTemplateOid (codeImprotDataVO.getTemplateOid());
+					codeImportTemplateVO.setCodeClassifyVO( codeImprotDataVO.getCodeClassifyVO());
+					codeImportTemplateVO.setCodeClassifyTemplateVO( codeImprotDataVO.getCodeClassifyTemplateVO());
+					codeImportTemplateVO.setCodeRuleVO(codeImprotDataVO.getCodeRuleVO());
+					List<String> colNames=codeImprotDataVO.getColNames();
+					codeImportTemplateVO.setCloNamesList(columnVOList);
+					codeImportTemplateVOS.add(codeImportTemplateVO);
+					codeRuleMap.put(codeRuleOid,codeImportTemplateVO);
+				}
+				List<ClientBusinessObject> cboList=new ArrayList<>();
+				excelToCbo(classifyFullInfo,codeImprotDataVO,cboList,true);
+				allCboList.addAll(cboList);
+				//寰�閫夋嫨鐨勮妭鐐归噷闈㈠姞鏁版嵁
+				// CodeImprotDataVO wpcodeImprotDataVO=new CodeImprotDataVO();
+				//   BeanUtilForVCI.copyPropertiesIgnoreCase(codeImprotDataVO,wpcodeImprotDataVO);
+               /* wpcodeImprotDataVO.setCodeClassifyOid(codeClassifyOid);
+                wpcodeImprotDataVO.setCodeClassifyVO(classifyFullInfo.getCurrentClassifyVO());
+                wpcodeImprotDataVO.setCodeClassifyTemplateVO(selectCodeClassifyTemplateVO);
+                wpcodeImprotDataVO.setCodeRuleOid(classifyFullInfo.getCurrentClassifyVO().getCoderuleoid());*/
+				// wpCodeImprotDataVOList.add(wpcodeImprotDataVO);//寰�鐗╁搧瀵硅薄閲屾坊鍔�
+
+			});
+
+
+			//閮借浆鎹㈠畬浜嗐�傞渶瑕佹壒閲忔鏌�
+			//濡傛灉鍑洪敊浜嗭紝鎴戜滑渚濈劧鎵ц鏈夋晥鐨勬暟鎹紝鏃犳晥鐨勬暟鎹啓鍥炲埌excel涓�
+			//2.鍒ゆ柇蹇呰緭椤广�傘�傞渶瑕佸叏閮ㄧ殑灞炴�э紝濡傛灉鏄繀杈擄紝浣嗘槸琛ㄥ崟閲岄潰涓嶆樉绀虹殑锛屽彧鑳芥槸鍒嗙被娉ㄥ叆鎴栬�呯粍鍚堣鍒�
+			batchCheckRequiredAttrOnOrder(templateVO,allCboList,errorMap);
+			//3.鍒ゆ柇鍏抽敭灞炴��
+			CodeImportResultVO keyResultVO = batchCheckKeyAttrOnOrder(classifyFullInfo, templateVO, allCboList);
+			Set<String> selfRepeatRowIndexList = keyResultVO.getSelfRepeatRowIndexList();
+			Set<String> keyAttrRepeatRowIndexList = keyResultVO.getKeyAttrRepeatRowIndexList();
+			if(!CollectionUtils.isEmpty(selfRepeatRowIndexList)){
+				selfRepeatRowIndexList.stream().forEach(rowIndex->{
+					errorMap.put(rowIndex,errorMap.getOrDefault(rowIndex,"") + ";鍦ㄥ綋鍓嶅鐞嗙殑鏁版嵁鏂囦欢涓叧閿睘鎬ч噸澶�" );
+				});
+			}
+			if(!CollectionUtils.isEmpty(keyAttrRepeatRowIndexList)){
+				keyAttrRepeatRowIndexList.stream().forEach(rowIndex->{
+					errorMap.put(rowIndex,errorMap.getOrDefault(rowIndex,"") + ";鍏抽敭灞炴�т笌绯荤粺涓殑閲嶅" );
+				});
+			}
+			//鍒嗙被娉ㄥ叆
+			// batchSwitchClassifyAttrOnOrder(attrVOS,allCboList,classifyFullInfo,false);
+			//boolean
+			reSwitchBooleanAttrOnOrder(attrVOS,allCboList);
+			//4.鏍￠獙瑙勫垯
+			batchCheckVerifyOnOrder(attrVOS, allCboList,errorMap);
+			//鏄惁闇�瑕佹牎楠屾灇涓�/鍙傜収
+			//5.鏍￠獙鏋氫妇鏄惁姝ｇ‘
+			batchSwitchEnumAttrOnOrder(attrVOS, allCboList, errorMap);
+			//7.澶勭悊鍙傜収鐨勬儏鍐�
+			batchSwitchReferAttrOnOrder(attrVOS,allCboList,errorMap);
+
+			//6.鏃堕棿鏍煎紡鐨勯獙璇�
+			//6.鏃堕棿鐨勶紝蹇呴』缁熶竴涓簓yyy-MM-dd HH:mm:ss
+			batchSwitchDateAttrOnOrder(attrVOS,allCboList,errorMap);
+			//璁剧疆榛樿鍊�
+			batchSwitchAttrDefault(attrVOS, allCboList);
+			//鏈�鍚庡紕缁勫悎瑙勫垯
+			batchSwitchComponentAttrOnOrder(attrVOS,allCboList);
+
+
+			Map<String, ClientBusinessObject> rowIndexCboMap = allCboList.stream().filter(cbo -> cbo != null).collect(Collectors.toList()).stream().collect(Collectors.toMap(s -> s.getAttributeValue((IMPORT_ROW_INDEX)), t -> t));
+
+
+			List<ClientBusinessObject> needSaveCboList = allCboList.stream().filter(cbo -> {
+				String rowIndex = cbo.getAttributeValue(IMPORT_ROW_INDEX);
+				return !errorMap.containsKey(rowIndex);
+			}).collect(Collectors.toList());
+			//鐩镐技鏍￠獙
+			Map<String,String>resembleMap=new HashMap<>();
+			List<DataResembleVO> dataResembleVOS=new ArrayList<>();
+			String btmtypeid= classifyFullInfo.getTopClassifyVO().getBtmtypeid();
+			bathcResembleQuery(codeClassifyOid,templateVO,needSaveCboList,resembleMap,btmtypeid,dataResembleVOS);
+			if(resembleMap.size()>0) {
+				if(!CollectionUtils.isEmpty(dataResembleVOS)) {
+					bladeRedis.set(uuid + "-resemble-data", dataResembleVOS);
+					bladeRedis.expire(uuid + "-resemble-data",BATCHADD_REDIS_TIME);//redis杩囨湡鏃堕棿
+					// createRedisDatas(uuid + "-resemble", codeImprotDataVOS, resembleMap, false);
+					//  wpResembleMap.putAll(resembleMap);
+				}
+			}
+			//鎺掗櫎閿欒鐨勶紝鍓╀笅姝ｇ‘鐨�
+			Map<String,String> newErrorMap=new HashMap<>();
+			newErrorMap.putAll(resembleMap);
+			newErrorMap.putAll(errorMap);
+			needSaveCboList = allCboList.stream().filter(cbo -> {
+				String rowIndex = cbo.getAttributeValue(IMPORT_ROW_INDEX);
+				return !newErrorMap.containsKey(rowIndex);
+			}).collect(Collectors.toList());
+			if(newErrorMap.size()>0) {
+				createRedisDatas(uuid + "-resemble",codeImprotDataVOS, newErrorMap,false);
+			}
+			createRedisDatas(uuid + "-ok",codeImprotDataVOS, newErrorMap,true);
+
+		});
+		//寰�鐗╁搧鑺傜偣涓婂姞妯℃澘
+
+
+
+		List<String> needRowIndexList=new ArrayList<>();
+		CodeImProtRusultVO codeImProtRusultVO = new CodeImProtRusultVO();
+		if(errorMap.size()>0) {
+			String filePath = returnErrorToExcel(dataSet.getRowData(), errorMap, needRowIndexList, dataSet.getColName());
+			if (StringUtils.isNotBlank(filePath)) {
+				codeImProtRusultVO.setFilePath(filePath);
+			}
+		}
+		if(StringUtils.isNotBlank(uuid)){
+			//灏嗘墍鏈夌殑鍒嗙被瀛樺叆缂撳瓨涔嬩腑
+			codeImProtRusultVO.setRedisUuid(uuid);
+			/**  List<ColumnVO>columnVOList=new ArrayList<>();
+			 CodeImportTemplateVO wpCodeImportTemplateVO=new CodeImportTemplateVO();
+			 wpCodeImportTemplateVO.setRoot(true);
+			 wpCodeImportTemplateVO.setCodeClassifyTemplateVO(selectCodeClassifyTemplateVO);
+			 wpCodeImportTemplateVO.setCodeClassifyVO(classifyFullInfo.getCurrentClassifyVO());
+			 String templateOid=selectCodeClassifyTemplateVO.getOid();
+			 if(templateColumnVOMap.containsKey(templateOid)){
+			 columnVOList= columnVOList=templateColumnVOMap.get(templateOid);
+			 }else{
+			 createTemplate(selectCodeClassifyTemplateVO,templateColumnVOMap);
+			 columnVOList= columnVOList=templateColumnVOMap.get(templateOid);
+			 }
+			 wpCodeImportTemplateVO.setCloNamesList(columnVOList);
+			 codeImportTemplateVOS.add(wpCodeImportTemplateVO);
+
+			 if(wpResembleMap.size()>0){
+			 //  redisService.setCacheList(uuid + "-resemble-data", wpDataResembleVOList);
+			 createRedisDatas(uuid + "-resemble",selectCodeClassifyTemplateVO, wpCodeImprotDataVOList, wpResembleMap, false,codeClassifyOid);
+			 }
+			 //鎺掗櫎閿欒鐨勶紝鍓╀笅姝ｇ‘鐨�
+			 Map<String,String> newErrorMap=new HashMap<>();
+			 newErrorMap.putAll(wpResembleMap);
+			 newErrorMap.putAll(errorMap);
+			 List<CodeImprotDataVO>  needSaveCboList = wpCodeImprotDataVOList.stream().filter(cbo -> {
+			 String rowIndex = cbo.getRowIndex();
+			 return !newErrorMap.containsKey(rowIndex);
+			 }).collect(Collectors.toList());
+			 createRedisDatas(uuid + "-ok",selectCodeClassifyTemplateVO,wpCodeImprotDataVOList, newErrorMap,true,codeClassifyOid);****/
+			if(codeImportTemplateVOS.size()>0){
+				bladeRedis.set(uuid + "-class",codeImportTemplateVOS);
+				bladeRedis.expire(uuid + "-class",BATCHADD_REDIS_TIME);
+			}
+		}
+		return codeImProtRusultVO;
+	}
+
+	/**
+	 * 瀵煎叆鍘嗗彶鏁版嵁
+	 *
+	 * @param codeClassifyOid 鍒嗙被鐨勪富閿�
+	 * @param classifyAttr 鍒嗙被璺緞浣跨敤鐨勫睘鎬�
+	 * @param file            excel鏂囦欢鐨勪俊鎭�
+	 * @return 鏈夐敊璇俊鎭殑excel
+	 */
+	@Override
+	public CodeImProtRusultVO batchImportHistoryData(String codeClassifyOid, String classifyAttr,File file) throws  Throwable{
+		VciBaseUtil.alertNotNull(codeClassifyOid,"鍒嗙被鐨勪富閿�");
+		ReadExcelOption reo = new ReadExcelOption();
+		reo.setReadAllSheet(true);
+		List<SheetDataSet> sheetDataSetList = ExcelUtil.readDataObjectFromExcel(file,null,reo);
+		if (sheetDataSetList.size() > LIMIT + 1) {
+			throw new VciBaseException("涓轰簡淇濊瘉绯荤粺鐨勭ǔ瀹氭�э紝璇蜂竴娆′笉瑕佸鍏ヨ秴杩�1涓囨潯鐨勬暟鎹�");
+		}
+		Map<String,List<WriteExcelData>> shetNameMap=new HashMap<>();
+		//鐩镐技椤圭洰鏌ラ噸
+		String uuid=VciBaseUtil.getPk();
+		boolean isCreateUUid=false;
+		boolean isExport=false;
+		for(int i=0;i<sheetDataSetList.size()-1;i++) {
+			if (CollectionUtils.isEmpty(sheetDataSetList) || CollectionUtils.isEmpty(sheetDataSetList.get(i).getRowData())
+				|| sheetDataSetList.get(i).getRowData().size() < 1) {
+				continue;
+			}
+			//鍘嗗彶瀵煎叆鐨勬椂鍊欎笉澶勭悊缂栫爜
+			//----閫昏緫鍐呭----
+			//1. 鍒嗙被鐨勮矾寰勫彲浠ュ湪椤甸潰涓婇�夋嫨鏄垎绫荤紪鍙疯繕鏄垎绫荤殑鍚嶇О
+			//2. 鍒嗙被鐨勮矾寰勶紝蹇呴』鏄綋鍓嶅鍏ラ�夋嫨鐨勫垎绫荤殑鑺傜偣锛屼互鍙婂叾涓嬬骇鑺傜偣
+			//3. 閫氳繃鏁版嵁瑕佸鍏ョ殑鍒嗙被鍘绘煡鎵惧搴旂殑缂栫爜瑙勫垯
+			//4. 鏁版嵁瀛樺偍鍜屾壒閲忕敵璇蜂竴鏍凤紝
+			//5. 闇�瑕佸崟鐙鐞嗕紒涓氱紪鐮佺殑鍐呭锛�
+			//     5.1 浼佷笟缂栫爜鍦ㄥ綋鍓峞xcel閲屼笉鑳介噸澶�
+			//     5.2 浼佷笟缂栫爜鍦ㄧ郴缁熶腑涓嶈兘閲嶅锛堝彲浠ユ槸宸茬粡鍥炴敹鐨勶級
+			//     5.3 浼佷笟缂栫爜鐨勯暱搴︼紝鍜岀紪鐮佽鍒欑殑闀垮害瑕佸搴斾笂
+			//     5.4 鑾峰彇娴佹按鐮佹鐨勫�硷紝鍘婚櫎濉厖鐨勫瓧绗︼紝鐪嬫祦姘村彿鏄灏戯紝鐒跺悗灏嗘祦姘村彿鍜岀幇鍦ㄧ殑鏈�澶ф祦姘村彿鍒ゆ柇锛屽皬浜庡氨鐩存帴褰曞叆锛屽ぇ浜庡垯淇敼鏈�澶ф祦姘村彿
+			//     5.5 瀛樺偍浼佷笟缂栫爜鍒癮llcode涓�
+
+			//鏌ヨ鍒嗙被鍜屾ā鏉�
+			CodeClassifyFullInfoBO classifyFullInfo = classifyService.getClassifyFullInfo(codeClassifyOid);
+
+			//鍏堟壘鍒版瘡涓�琛岀殑鏍囬锛岀劧鍚庢牴鎹爣棰樻潵鑾峰彇瀵瑰簲鐨勫睘鎬�
+			SheetDataSet dataSet = sheetDataSetList.get(i);
+			List<SheetRowData> rowDataList = dataSet.getRowData();
+
+			//鎵剧涓�琛岋紝涓轰簡鎵炬爣棰�
+			CodeClassifyTemplateVO templateVO = new CodeClassifyTemplateVO();
+			/**  if (!templateService.checkChildHasSameTemplate(classifyFullInfo.getCurrentClassifyVO().getOid())) {
+			 throw new VciBaseException("褰撳墠鐨勫垎绫讳互鍙婁笅绾у垎绫荤殑妯℃澘涓嶇浉鍚�");
+			 }***/
+			//閮借浆鎹㈠畬浜嗐�傞渶瑕佹壒閲忔鏌�
+			//鎵炬墍鏈夌殑鍒嗙被璺緞,闇�瑕佹牎楠岃矾寰勬槸鍚︽纭紝鏄惁閮藉湪褰撳墠鐨勫垎绫荤殑涓嬬骇
+			List<CodeClassifyVO> childClassifyVOs = classifyService.listChildrenClassify(codeClassifyOid, true, classifyAttr, true);
+			Map<String/**璺緞**/, CodeClassifyVO> pathMap = Optional.ofNullable(childClassifyVOs).orElseGet(() -> new ArrayList<>()).stream().collect(Collectors.toMap(s -> s.getPath().startsWith("#") ? s.getPath().substring(1) : s.getPath(), t -> t));
+			List<String> titleRowData = dataSet.getColName();
+			Map<String, String> errorMap = new ConcurrentHashMap<>();
+			pathMap.put("#current#",classifyFullInfo.getCurrentClassifyVO());
+
+			try {
+				List<CodeClassifyTemplateVO> templateVOList= checkSamesTemplate(titleRowData,sheetDataSetList,i,pathMap,errorMap);
+				templateVO= templateVOList.get(0);
+			}catch (Throwable e){
+				throw  new VciBaseException(e.getMessage());
+			}
+
+			List<SheetRowData> needowDataList = rowDataList.stream().filter(cbo -> {
+				String rowIndex = cbo.getRowIndex();
+				return !errorMap.containsKey(rowIndex);
+			}).collect(Collectors.toList());
+
+			//checkTemplateSync(sheetDataSetList, templateVO,i);
+			//杩欓噷涓嶉櫎鍘婚粯璁ょ殑灞炴��
+			List<CodeClassifyTemplateAttrVO> attrVOS = templateVO.getAttributes();
+			Map<Integer/**鍒楀彿**/, String/**瀛楁鐨勫悕绉�**/> fieldIndexMap = new HashMap<>();
+
+			Map<String/**涓枃鍚嶇О**/, String/**鑻辨枃鍚嶇О**/> attrNameIdMap = attrVOS.stream().collect(Collectors.toMap(s -> s.getName(), t -> t.getId()));
+			String idFieldName = attrVOS.stream().filter(s -> VciQueryWrapperForDO.ID_FIELD.equalsIgnoreCase(s.getId())).findFirst().orElseGet(() -> new CodeClassifyTemplateAttrVO()).getName();
+			getFieldIndexMap(titleRowData, attrNameIdMap, fieldIndexMap);
+			//鍏堜笉鐢ㄧ灞炴�ф槸鍚﹂兘瀛樺湪锛屽厛杞崲涓�涓嬫暟鎹�
+			List<ClientBusinessObject> cboList = new ArrayList<>();
+			String fullPath = getFullPath(classifyFullInfo);
+			//鎴戜滑闇�瑕佽幏鍙栧埌鎵�鏈夌殑涓嬬骇鍒嗙被鐨刼id鐨勮矾寰勶紝鍥犱负鍚庨潰闇�瑕�
+			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());
+
+			//鍒ゆ柇缂栧彿鍦╡xcel閲屾湰韬氨閲嶅鐨�
+			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, "缂栧彿鍦ㄥ綋鍓峞xcel涓噸澶�;");
+				});
+			}
+			//鎴戜滑闇�瑕佸垽鏂繖浜涘垎绫荤殑妯℃澘鏄笉鏄竴鏍风殑锛屽彧闇�瑕佹牎楠岋紝涓嶇敤鑾峰彇
+			//妫�鏌ュ垎绫荤殑璺緞
+			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, "") + ";鍦ㄥ綋鍓峞xcel鏂囦欢涓叧閿睘鎬ч噸澶�");
+				});
+			}
+			if (!CollectionUtils.isEmpty(keyAttrRepeatRowIndexList)) {
+				keyAttrRepeatRowIndexList.stream().forEach(rowIndex -> {
+					errorMap.put(rowIndex, errorMap.getOrDefault(rowIndex, "") + ";鍏抽敭灞炴�т笌绯荤粺涓殑閲嶅");
+				});
+			}
+			//4.鏍￠獙瑙勫垯
+			batchCheckVerifyOnOrder(attrVOS, cboList, errorMap);
+
+			//6.鏃堕棿鐨勶紝蹇呴』缁熶竴涓簓yyy-MM-dd HH:mm:ss
+			batchSwitchDateAttrOnOrder(attrVOS, cboList, errorMap);
+			if (CollectionUtils.isEmpty(ruleOidMap.values())) {
+				throw new VciBaseException("瀵煎叆鐨勬暟鎹墍閫夋嫨鐨勫垎绫婚兘娌℃湁璁剧疆缂栫爜瑙勫垯");
+			}
+			Map<String, CodeRuleVO> ruleVOMap = ruleService.listCodeRuleByIds(ruleOidMap.values(), true).stream().collect(Collectors.toMap(s -> s.getOid(), t -> t));
+			//鏍￠獙缂栫爜瑙勫垯鍜岀爜娈垫槸鍚︽纭�
+			Map<String, List<String>> ruleRowIndexMap = new ConcurrentHashMap<>();
+			checkSecLengthInHistory(cboList, classifyVOMap, ruleVOMap, ruleOidMap, errorMap, ruleRowIndexMap);
+			ruleRowIndexMap.keySet().parallelStream().forEach(ruleOid -> {
+				List<String> rowIndexList = ruleRowIndexMap.get(ruleOid);
+				List<ClientBusinessObject> thisCbos = cboList.stream().filter(cbo -> rowIndexList.contains(cbo.getAttributeValue(IMPORT_ROW_INDEX)) && !errorMap.containsKey(cbo.getAttributeValue(IMPORT_ROW_INDEX))).collect(Collectors.toList());
+//鎴戜滑闇�瑕佸厛鏌ヨ涓�涓嬶紝鍐呭鏄惁宸茬粡瀛樺湪
+				if(!CollectionUtils.isEmpty(thisCbos)){
+					List<String> existIds = new ArrayList<>();
+					VciBaseUtil.switchCollectionForOracleIn(thisCbos).stream().forEach(cbos -> {
+						List<CodeAllCode> codeAllCodeList= codeAllCodeService.selectByWrapper(Wrappers.<CodeAllCode>query().lambda().eq(CodeAllCode::getCodeRuleOid, ruleOid)
+							.notIn(CodeAllCode::getId,cbos.stream().map(s -> s.getId()).collect(Collectors.toSet()).toArray(new String[0]))
+							.notIn(CodeAllCode::getLcStatus,CodeAllCodeLC.TASK_BACK.getValue() + "','" + CodeAllCodeLC.OBSOLETED.getValue())
+						);
+						existIds.addAll(Optional.ofNullable(codeAllCodeList).orElseGet(() -> new ArrayList<>()).stream().map(s -> {
+							String id = s.getId();
+							if (StringUtils.isBlank(id)) {
+								id = s.getId();
+							}
+							return id;
+						}).collect(Collectors.toList()));
+					});
+					List<String> existIdCbos = thisCbos.stream().filter(s -> {
+						String id = s.getId();
+						if (StringUtils.isBlank(id)) {
+							id = s.getAttributeValue("id");
+						}
+						return existIds.contains(id);
+					}).map(s -> s.getAttributeValue(IMPORT_ROW_INDEX)).collect(Collectors.toList());
+					if (!CollectionUtils.isEmpty(existIdCbos)) {
+						thisCbos = thisCbos.stream().filter(s -> {
+							String id = s.getId();
+							if (StringUtils.isBlank(id)) {
+								id = s.getAttributeValue("id");
+							}
+							return !existIdCbos.contains(id);
+						}).collect(Collectors.toList());
+						existIdCbos.stream().forEach(rowIndex -> {
+							errorMap.put(rowIndex, errorMap.getOrDefault(rowIndex, "") + ";銆�" + idFieldName + "銆戝湪绯荤粺涓凡缁忚鍗犵敤");
+						});
+					}
+				}
+			});
+
+			Map<String, ClientBusinessObject> rowIndexCboMap = cboList.stream().filter(cbo -> cbo != null).collect(Collectors.toList()).stream().collect(Collectors.toMap(s -> s.getAttributeValue((IMPORT_ROW_INDEX)), t -> t));
+			if (errorMap.size() > 0) {
+				isExport=true;
+				createRedisDatas(uuid + "-error", templateVO, rowIndexCboMap, dataSet, fieldIndexMap, errorMap, false);
+			}
+			createWriteExcelData(rowDataList, errorMap, new ArrayList<>(), titleRowData, shetNameMap, templateVO);
+			List<ClientBusinessObject> needSaveCboList = cboList.stream().filter(cbo -> {
+				String rowIndex = cbo.getAttributeValue(IMPORT_ROW_INDEX);
+				return !errorMap.containsKey(rowIndex);
+			}).collect(Collectors.toList());
+			//鐩镐技鏍￠獙
+			Map<String, String> resembleMap = new HashMap<>();
+			List<DataResembleVO> dataResembleVOS = new ArrayList<>();
+			String btmtypeid = classifyFullInfo.getTopClassifyVO().getBtmtypeid();
+			bathcResembleQuery(templateVO.getCodeclassifyoid(), templateVO, needSaveCboList, resembleMap, btmtypeid, dataResembleVOS);
+			if (resembleMap.size() > 0) {
+				if (!CollectionUtils.isEmpty(dataResembleVOS)) {
+					bladeRedis.set(uuid + "-resemble-data", dataResembleVOS);
+					createRedisDatas(uuid + "-resemble", templateVO, rowIndexCboMap, dataSet, fieldIndexMap, resembleMap, false);
+				}
+			}
+			//鐢熸垚class缂撳瓨
+			Map<String, String> rowIndexClsOidMap = cboList.stream().filter(cbo -> cbo != null).collect(Collectors.toList()).stream().collect(Collectors.toMap(s -> s.getAttributeValue((IMPORT_ROW_INDEX)), t -> t.getAttributeValue(CODE_CLASSIFY_OID_FIELD)));
+			createRedisByCodeClassify(uuid + "-class",templateVO,dataSet,fieldIndexMap,true);
+			//鑾峰彇缂栫爜锛屾煡璇㈠湪绯荤粺涓槸鍚﹁鍏朵粬鐨勫紩鐢ㄤ簡
+			//鎺掗櫎閿欒鐨勶紝鍓╀笅姝ｇ‘鐨�
+			Map<String, String> newErrorMap = new HashMap<>();
+			newErrorMap.putAll(resembleMap);
+			newErrorMap.putAll(errorMap);
+			//瑕佹妸浠ヤ笂鐨勯敊璇殑閮芥姏鍑哄悗锛屽啀缁х画澶勭悊鏃堕棿鍜岀粍鍚堣鍒�
+			needSaveCboList = cboList.stream().filter(cbo -> {
+				String rowIndex = cbo.getAttributeValue(IMPORT_ROW_INDEX);
+				return !newErrorMap.containsKey(rowIndex);
+			}).collect(Collectors.toList());
+			if((errorMap.size()>0&&needSaveCboList.size()>0)||resembleMap.size()>0){
+				isCreateUUid=true;
+			}
+
+			List<String> needRowIndexList = needSaveCboList.stream().filter(s -> errorMap.containsKey(s.getAttributeValue(IMPORT_ROW_INDEX))).map(s -> s.getAttributeValue(IMPORT_ROW_INDEX)).collect(Collectors.toList());
+			if (isExport||newErrorMap.size() > 0) {
+				createRedisDatas(uuid + "-ok", templateVO, rowIndexCboMap, dataSet, fieldIndexMap, newErrorMap, true);
+			} else {
+				List<BaseModel> dataCBOIdList=new ArrayList<>();
+				//SessionInfo sessionInfo = VciBaseUtil.getCurrentUserSessionInfo();
+				List<ClientBusinessObject> finalNeedSaveCboList = needSaveCboList;
+				CodeClassifyTemplateVO finalTemplateVO = templateVO;
+				ruleRowIndexMap.keySet().parallelStream().forEach(ruleOid -> {
+					//VciBaseUtil.setCurrentUserSessionInfo(sessionInfo);
+					List<String> rowIndexList = ruleRowIndexMap.get(ruleOid);
+					List<ClientBusinessObject> thisCbos = finalNeedSaveCboList.stream().filter(cbo -> rowIndexList.contains(cbo.getAttributeValue(IMPORT_ROW_INDEX)) && !errorMap.containsKey(cbo.getAttributeValue(IMPORT_ROW_INDEX))).collect(Collectors.toList());
+					List<BaseModel> dataCBOList=new ArrayList<>();
+					thisCbos.stream().forEach(clientBusinessObject -> {
+						BaseModel baseModel=new BaseModel();
+						BeanUtil.convert(clientBusinessObject,baseModel);
+						//baseModel.setData(VciBaseUtil.objectToMapString(clientBusinessObject));
+						dataCBOList.add(baseModel);
+						dataCBOIdList.add(baseModel);
+					});
+
+					if (!CollectionUtils.isEmpty(thisCbos)) {
+						try {
+							productCodeService.productCodeAndSaveData(classifyFullInfo, finalTemplateVO, ruleVOMap.get(ruleOid), null, dataCBOList);
+						} catch (Throwable e) {
+							log.error("鎵归噺浜х敓缂栫爜鐨勬椂鍊欏嚭閿欎簡", e);
+							thisCbos.stream().forEach(cbo -> {
+								String rowIndex = cbo.getAttributeValue(IMPORT_ROW_INDEX);
+								errorMap.put(rowIndex, errorMap.getOrDefault(rowIndex, "") + ";绯荤粺閿欒锛屽瓨鍌ㄦ暟鎹殑鏃跺�欏嚭閿欎簡");
+							});
+
+						}
+					}
+				});
+				if (errorMap.size() > 0) {
+					isExport = true;
+				}
+				createWriteExcelData(rowDataList, errorMap, new ArrayList<>(), titleRowData, shetNameMap, finalTemplateVO);
+				engineService.batchSaveSelectChar(templateVO, dataCBOIdList);
+			}
+		}
+		String excelFileName="";
+		if(isExport&&!CollectionUtils.isEmpty(shetNameMap)) {
+			excelFileName = LocalFileUtil.getDefaultTempFolder() + File.separator + "閿欒淇℃伅.xls";
+			WriteExcelOption eo = new WriteExcelOption();
+			shetNameMap.forEach((shetName, errorDataList) -> {
+				eo.addSheetDataList(shetName, errorDataList);
+			});
+			try {
+				new File(excelFileName).createNewFile();
+			} catch (IOException e) {
+				throw new VciBaseException(LangBaseUtil.getErrorMsg(e));
+			}
+			ExcelUtil.writeDataToFile(excelFileName, eo);
+		}
+		CodeImProtRusultVO codeImProtRusultVO=new CodeImProtRusultVO();
+		if(StringUtils.isNotBlank(excelFileName)) {
+			codeImProtRusultVO.setFilePath(excelFileName);
+			codeImProtRusultVO.setFileOid("");
+		}
+		if(isCreateUUid){
+			codeImProtRusultVO.setRedisUuid(uuid);
+		}
+
+		return codeImProtRusultVO;
+	}
+	/*private void converBaseModels(List<ClientBusinessObject> clientBusinessObjects,List<BaseModel>dataCBOList){
+		clientBusinessObjects.stream().forEach(clientBusinessObject -> {
+			BaseModel baseModel=new BaseModel();
+			BeanUtil.convert(clientBusinessObject,baseModel);
+			Map<String,String> dataMap=new HashMap<>();
+			clientBusinessObject.getHisAttrValList()
+			baseModel.setData(VciBaseUtil.objectToMapString(baseModel));
+
+			AttributeValue[] newAttributeValue= 	clientBusinessObject.getNewAttrValList();
+			dataCBOList.add(baseModel);
+		});
+
+	}*/
+	/***
+	 * 浠巈xecl閲屾瀯寤哄璞�
+	 * @param rowDataList
+	 * @param errorMap
+	 * @param needRowIndexList
+	 * @param titleRowData
+	 * @param shetNameMap
+	 * @param templateVO
+	 */
+	private void createWriteExcelData(Collection<SheetRowData> rowDataList, Map<String,String> errorMap,
+									  List<String> needRowIndexList, List<String> titleRowData, Map<String,List<WriteExcelData>> shetNameMap, CodeClassifyTemplateVO templateVO){
+		List<WriteExcelData> errorDataList=new ArrayList<>();
+		Map<String, SheetRowData> rowIndexDataMap = rowDataList.stream().filter(s -> !needRowIndexList.contains(s.getRowIndex())).collect(Collectors.toMap(s -> s.getRowIndex(), t -> t));
+		errorDataList.add(new WriteExcelData(0,0,"閿欒淇℃伅"));
+		for (int i = 0; i < titleRowData.size(); i++) {
+			//閿欒淇℃伅鍦ㄦ渶鍚�
+			errorDataList.add(new WriteExcelData(0,i+1,titleRowData.get(i)));
+		}
+		Integer[] newRowIndex = new Integer[]{1};
+		errorMap.forEach((index,error)->{
+			//閿欒淇℃伅鍏ㄩ儴缁勫悎鍒颁竴璧�
+			SheetRowData rowData = rowIndexDataMap.getOrDefault(index, null);
+			if(rowData!=null){
+				errorDataList.add(new WriteExcelData(newRowIndex[0],0,error));
+				rowData.getData().forEach((colIndex,value)->{
+					errorDataList.add(new WriteExcelData(newRowIndex[0],colIndex+1,value));
+				});
+				newRowIndex[0]++;
+			}
+		});
+
+		shetNameMap.put(templateVO.getName(),errorDataList);
+	}
+
+	/***
+	 *
+	 * @param currentTemplateVO
+	 * @param templateColumnVOMap
+	 */
+
+	private void createTemplate(CodeClassifyTemplateVO currentTemplateVO,Map<String,List<ColumnVO>>templateColumnVOMap){
+
+		List<CodeClassifyTemplateAttrVO> templateAttrVOS = currentTemplateVO.getAttributes().stream().filter(s ->
+			!DEFAULT_ATTR_LIST.contains(s.getId())
+				&& StringUtils.isBlank(s.getComponentRule())
+				&& StringUtils.isBlank(s.getClassifyInvokeAttr())
+				&& (VciBaseUtil.getBoolean(s.getFormDisplayFlag()))
+		).collect(Collectors.toList());
+		if(CollectionUtils.isEmpty(templateAttrVOS)){
+			throw new VciBaseException("妯℃澘娌℃湁閰嶇疆浠讳綍銆愯〃鍗曟樉绀恒�戜负銆愭槸銆戠殑灞炴��");
+		}
+		List<ColumnVO> columnVOList=new ArrayList<>();
+
+		ColumnVO errorMsgColumnVO=new ColumnVO();
+		errorMsgColumnVO.setTitle("閿欒淇℃伅");
+		errorMsgColumnVO.setField("errorMsg");
+		columnVOList.add(errorMsgColumnVO);
+
+
+
+		ColumnVO pathColumnVO=new ColumnVO();
+		pathColumnVO.setTitle("鍒嗙被璺緞");
+		pathColumnVO.setField("codeclsfid");
+		columnVOList.add(pathColumnVO);
+		templateAttrVOS.stream().forEach(codetemplateAttr ->{
+			String field=codetemplateAttr.getId();
+			String name=codetemplateAttr.getName();
+			ColumnVO columnVO=new ColumnVO();
+			columnVO.setTitle(name);
+			columnVO.setField(field);
+			columnVO.setWidth(codetemplateAttr.getAttrTableWidth()==0?columnVO.getWidth():codetemplateAttr.getAttrTableWidth());
+			columnVOList.add(columnVO);
+		});
+
+		templateColumnVOMap.put(currentTemplateVO.getOid(),columnVOList);
+		log.info("妯℃澘"+currentTemplateVO.getName()+"瀵瑰簲鐨勫睘鎬�"+columnVOList.size());
+	}
+
+	/**
+	 * 閿欒淇℃伅杩斿洖excel
+	 * @param rowDataList 鎵�鏈夌殑瀵煎叆鏁版嵁
+	 * @param errorMap 閿欒鐨勪俊鎭�
+	 * @param needRowIndexList 闇�瑕佸啓鍏ョ殑鏁版嵁鐨勮鍙�
+	 * @param titleRowData 鏍囬琛�
+	 *
+	 * @return 閿欒鐨別xcel鏂囦欢锛屾病鏈夐敊璇細杩斿洖绌�
+	 */
+	private String returnErrorToExcel(Collection<SheetRowData> rowDataList,
+									  Map<String,String> errorMap,
+									  List<String> needRowIndexList,List<String> titleRowData){
+		if(CollectionUtils.isEmpty(errorMap)){
+			return "";
+		}
+		Map<String, SheetRowData> rowIndexDataMap = rowDataList.stream().filter(s -> !needRowIndexList.contains(s.getRowIndex())).collect(Collectors.toMap(s -> s.getRowIndex(), t -> t));
+		List<WriteExcelData> errorDataList = new ArrayList<>();
+		errorDataList.add(new WriteExcelData(0,0,"閿欒淇℃伅"));
+		for (int i = 0; i < titleRowData.size(); i++) {
+			//閿欒淇℃伅鍦ㄦ渶鍚�
+			errorDataList.add(new WriteExcelData(0,i+1,titleRowData.get(i)));
+		}
+		Integer[] newRowIndex = new Integer[]{1};
+		errorMap.forEach((index,error)->{
+			//閿欒淇℃伅鍏ㄩ儴缁勫悎鍒颁竴璧�
+			SheetRowData rowData = rowIndexDataMap.getOrDefault(index, null);
+			if(rowData!=null){
+				errorDataList.add(new WriteExcelData(newRowIndex[0],0,error));
+				rowData.getData().forEach((colIndex,value)->{
+					errorDataList.add(new WriteExcelData(newRowIndex[0],colIndex+1,value));
+				});
+				newRowIndex[0]++;
+			}
+		});
+		String excelFileName = LocalFileUtil.getDefaultTempFolder() + File.separator + "閿欒淇℃伅.xls";
+		WriteExcelOption eo = new WriteExcelOption(errorDataList);
+		try {
+			new File(excelFileName).createNewFile();
+		} catch (IOException e) {
+			throw new VciBaseException(LangBaseUtil.getErrorMsg(e));
+		}
+		ExcelUtil.writeDataToFile(excelFileName,eo);
+		return excelFileName;
+	}
+
+	/**
+	 * 鏍￠獙妯℃澘鏄惁涓哄悓姝ョ殑
+	 * @param sheetDataSetList excel閲岀殑鍐呭
+	 * @param templateVO 妯℃澘鐨勪俊鎭�
+	 */
+	private void checkTemplateSync(List<SheetDataSet> sheetDataSetList,CodeClassifyTemplateVO templateVO,int i){
+		String templateOidInExcel = "";
+		String templateName="";
+		if(!CollectionUtils.isEmpty(sheetDataSetList)
+			&& sheetDataSetList.size()>1 && !CollectionUtils.isEmpty(sheetDataSetList.get(sheetDataSetList.size()-1).getColName())){
+			List<SheetRowData>  rowData=  sheetDataSetList.get(sheetDataSetList.size()-1).getRowData();
+			templateName=rowData.get(i).getData().get(2);
+			templateOidInExcel=rowData.get(i).getData().get(0);
+			//templateOidInExcel = sheetDataSetList.get(sheetDataSetList.size()-1).getColName().get(sheetDataSetList.size()-i);
+		}
+       /* if(!CollectionUtils.isEmpty(sheetDataSetList)
+                && sheetDataSetList.size()>1 && !CollectionUtils.isEmpty(sheetDataSetList.get(sheetDataSetList.size()-1).getColName())){
+            List<SheetRowData>  rowData=  sheetDataSetList.get(sheetDataSetList.size()-1).getRowData();
+            templateOidInExcel=rowData.get(i).getData().get(0);
+           //templateOidInExcel = sheetDataSetList.get(sheetDataSetList.size()-1).getColName().get(sheetDataSetList.size()-i);
+        }*/
+		if(StringUtils.isBlank(templateOidInExcel) || !templateOidInExcel.equalsIgnoreCase(templateVO.getOid())){
+			throw new VciBaseException("妯℃澘銆�"+templateName+"銆戜腑鐨勬暟鎹幏鍙栫殑妯＄増淇℃伅涓庡綋鍓嶆ā鏉夸笉鍖归厤锛岃纭繚excel鏂囦欢閲屾湁銆愭ā鏉夸俊鎭�-璇峰嬁绉诲姩鎴栧垹闄ゃ�戠殑宸ヤ綔琛紝涓旂‘淇濇瘡娆″鍏ラ兘鏄厛涓嬭浇鐨勫鍏ユā鏉垮悗娣诲姞鐨勬暟鎹�");
+		}
+
+	}
+
+
+	/***
+	 * 鎵归噺澶勭悊鐢宠鏁版嵁
+	 * @param orderDTO
+	 * @param templateVO
+	 * @param dataSet
+	 * @return
+	 */
+	private String batchImportCodes(CodeOrderDTO orderDTO,CodeClassifyTemplateVO templateVO,SheetDataSet dataSet,Map<String,String> errorMap,boolean isEnumType){
+		List<String> codeList=new ArrayList<>();
+		CodeClassifyFullInfoBO classifyFullInfo = classifyService.getClassifyFullInfo(orderDTO.getCodeClassifyOid());
+		//瑙勫垯鐨勪富閿渶瑕佸幓鑾峰彇
+		CodeRuleVO ruleVO = engineService.getCodeRuleByClassifyFullInfo(classifyFullInfo);
+		//1.鍒ゆ柇瑙勫垯涓櫎浜嗘祦姘寸爜娈碉紝鏄惁鏈夊叾浠栫爜娈�
+		engineService.checkSecValueOnOrder(ruleVO,orderDTO);
+		List<SheetRowData> rowDataList = dataSet.getRowData();
+
+		//闄ゅ幓榛樿鐨勫睘鎬�.杩樻湁鍙湁琛ㄥ崟鏄剧ず鐨勫瓧娈垫墠瀵煎叆
+		List<CodeClassifyTemplateAttrVO> attrVOS = templateVO.getAttributes().stream().filter(s ->
+			!DEFAULT_ATTR_LIST.contains(s.getId()) && VciBaseUtil.getBoolean(s.getFormDisplayFlag())
+		).collect(Collectors.toList());
+		Map<Integer/**鍒楀彿**/,String/**瀛楁鐨勫悕绉�**/> fieldIndexMap = new HashMap<>();
+		List<String> titleRowData = dataSet.getColName();
+		Map<String/**涓枃鍚嶇О**/, String/**鑻辨枃鍚嶇О**/> attrNameIdMap = attrVOS.stream().collect(Collectors.toMap(s -> s.getName(), t -> t.getId().toLowerCase(Locale.ROOT),(o1, o2)->o2));
+		getFieldIndexMap(titleRowData,attrNameIdMap,fieldIndexMap);
+
+		//闇�瑕佸垽鏂槸鍚︽墍鏈夌殑灞炴�ч兘鍦ㄦā鏉夸笂浜�
+		List<CodeClassifyTemplateAttrVO> unExistAttrVOs = attrVOS.stream().filter(s -> !fieldIndexMap.containsValue(s.getId().toLowerCase(Locale.ROOT))
+			&& StringUtils.isBlank(s.getComponentRule()) && StringUtils.isBlank(s.getClassifyInvokeAttr())//缁勫悎瑙勫垯鍜屽垎绫绘敞鍏ョ‘瀹炴病缁欑敤鎴峰鍑哄幓
+		).collect(Collectors.toList());
+		if(!CollectionUtils.isEmpty(unExistAttrVOs)){
+			throw new VciBaseException("銆�" + unExistAttrVOs.stream().map(CodeClassifyTemplateAttrVO::getName) + "銆戣繖浜涘睘鎬у湪鍒楄〃涓病鏈夋壘鍒�");
+		}
+		List<ClientBusinessObject> cboList = new ArrayList<>();
+		String fullPath = getFullPath(classifyFullInfo);
+		excelToCbo(classifyFullInfo,fieldIndexMap,rowDataList,templateVO,cboList,fullPath,true);
+
+		//閮借浆鎹㈠畬浜嗐�傞渶瑕佹壒閲忔鏌�
+		//濡傛灉鍑洪敊浜嗭紝鎴戜滑渚濈劧鎵ц鏈夋晥鐨勬暟鎹紝鏃犳晥鐨勬暟鎹啓鍥炲埌excel涓�
+		//2.鍒ゆ柇蹇呰緭椤广�傘�傞渶瑕佸叏閮ㄧ殑灞炴�э紝濡傛灉鏄繀杈擄紝浣嗘槸琛ㄥ崟閲岄潰涓嶆樉绀虹殑锛屽彧鑳芥槸鍒嗙被娉ㄥ叆鎴栬�呯粍鍚堣鍒�
+		batchCheckRequiredAttrOnOrder(templateVO,cboList,errorMap);
+		//3.鍒ゆ柇鍏抽敭灞炴��
+		CodeImportResultVO keyResultVO = batchCheckKeyAttrOnOrder(classifyFullInfo, templateVO, cboList);
+		Set<String> selfRepeatRowIndexList = keyResultVO.getSelfRepeatRowIndexList();
+		Set<String> keyAttrRepeatRowIndexList = keyResultVO.getKeyAttrRepeatRowIndexList();
+		if(!CollectionUtils.isEmpty(selfRepeatRowIndexList)){
+			selfRepeatRowIndexList.stream().forEach(rowIndex->{
+				errorMap.put(rowIndex,errorMap.getOrDefault(rowIndex,"") + ";鍦ㄥ綋鍓嶅鐞嗙殑鏁版嵁鏂囦欢涓叧閿睘鎬ч噸澶�" );
+			});
+		}
+		if(!CollectionUtils.isEmpty(keyAttrRepeatRowIndexList)){
+			keyAttrRepeatRowIndexList.stream().forEach(rowIndex->{
+				errorMap.put(rowIndex,errorMap.getOrDefault(rowIndex,"") + ";鍏抽敭灞炴�т笌绯荤粺涓殑閲嶅" );
+			});
+		}
+		//鍒嗙被娉ㄥ叆
+		batchSwitchClassifyAttrOnOrder(attrVOS,cboList,classifyFullInfo,false);
+		//boolean
+		reSwitchBooleanAttrOnOrder(attrVOS,cboList);
+		//4.鏍￠獙瑙勫垯
+		batchCheckVerifyOnOrder(attrVOS, cboList,errorMap);
+		if(isEnumType) {//鏄惁闇�瑕佹牎楠屾灇涓�/鍙傜収
+			//5.鏍￠獙鏋氫妇鏄惁姝ｇ‘
+			batchSwitchEnumAttrOnOrder(attrVOS, cboList, errorMap);
+			//7.澶勭悊鍙傜収鐨勬儏鍐�
+			batchSwitchReferAttrOnOrder(attrVOS,cboList,errorMap);
+		}
+		//6.鏃堕棿鏍煎紡鐨勯獙璇�
+		//6.鏃堕棿鐨勶紝蹇呴』缁熶竴涓簓yyy-MM-dd HH:mm:ss
+		batchSwitchDateAttrOnOrder(attrVOS,cboList,errorMap);
+		//鏈�鍚庡紕缁勫悎瑙勫垯
+		batchSwitchComponentAttrOnOrder(attrVOS,cboList);
+		String uuid=VciBaseUtil.getPk();
+		Map<String, ClientBusinessObject> rowIndexCboMap = cboList.stream().filter(cbo -> cbo != null).collect(Collectors.toList()).stream().collect(Collectors.toMap(s -> s.getAttributeValue((IMPORT_ROW_INDEX)), t -> t));
+
+		if(errorMap.size()>0) {
+			createRedisDatas(uuid + "-error",templateVO, rowIndexCboMap, dataSet, fieldIndexMap, errorMap,false);
+		}
+		boolean isCreateUUid=false;
+		List<ClientBusinessObject> needSaveCboList = cboList.stream().filter(cbo -> {
+			String rowIndex = cbo.getAttributeValue(IMPORT_ROW_INDEX);
+			return !errorMap.containsKey(rowIndex);
+		}).collect(Collectors.toList());
+		//鐩镐技鏍￠獙
+		Map<String,String>resembleMap=new HashMap<>();
+		List<DataResembleVO> dataResembleVOS=new ArrayList<>();
+		String btmtypeid= classifyFullInfo.getTopClassifyVO().getBtmtypeid();
+		bathcResembleQuery(orderDTO.getCodeClassifyOid(),templateVO,needSaveCboList,resembleMap,btmtypeid,dataResembleVOS);
+		if(resembleMap.size()>0) {
+			isCreateUUid=true;
+			if(!CollectionUtils.isEmpty(dataResembleVOS)) {
+				bladeRedis.set(uuid + "-resemble-data", dataResembleVOS);
+				createRedisDatas(uuid + "-resemble",templateVO, rowIndexCboMap, dataSet, fieldIndexMap, resembleMap, false);
+			}
+		}
+		//鎺掗櫎閿欒鐨勶紝鍓╀笅姝ｇ‘鐨�
+		Map<String,String> newErrorMap=new HashMap<>();
+		newErrorMap.putAll(resembleMap);
+		newErrorMap.putAll(errorMap);
+		needSaveCboList = cboList.stream().filter(cbo -> {
+			String rowIndex = cbo.getAttributeValue(IMPORT_ROW_INDEX);
+			return !newErrorMap.containsKey(rowIndex);
+		}).collect(Collectors.toList());
+		if((errorMap.size()>0&&needSaveCboList.size()>0)||resembleMap.size()>0){
+			isCreateUUid=true;
+		}
+		createRedisByCodeClassify(uuid + "-class",templateVO,dataSet,fieldIndexMap,false);
+		if(newErrorMap.size()>0) {
+			createRedisDatas(uuid + "-ok",templateVO, rowIndexCboMap, dataSet, fieldIndexMap, newErrorMap,true);
+		}else {
+			uuid="";
+
+			//瑕佹妸浠ヤ笂鐨勯敊璇殑閮芥姏鍑哄悗锛屽啀缁х画澶勭悊鏃堕棿鍜岀粍鍚堣鍒�
+			needSaveCboList = cboList.stream().filter(cbo -> {
+				String rowIndex = cbo.getAttributeValue(IMPORT_ROW_INDEX);
+				return !newErrorMap.containsKey(rowIndex);
+			}).collect(Collectors.toList());
+
+			if (!CollectionUtils.isEmpty(needSaveCboList)) {
+				//9.鎴戜滑澶勭悊涓氬姟鏁版嵁
+				//鐢熸垚缂栫爜鐨勫唴瀹�
+				List<String> dataCBOIdList=new ArrayList<>();
+				List<BaseModel> dataCBOList=new ArrayList<>();
+				cboList.stream().forEach(clientBusinessObject -> {
+					BaseModel baseModel=new BaseModel();
+					BeanUtil.convert(clientBusinessObject,baseModel);
+					//baseModel.setData(VciBaseUtil.objectToMapString(clientBusinessObject));
+					dataCBOList.add(baseModel);
+					dataCBOIdList.add(baseModel.getOid());
+				});
+				try {
+					codeList = productCodeService.productCodeAndSaveData(classifyFullInfo,templateVO,ruleVO, orderDTO.getSecDTOList(),dataCBOList);
+					//濡傛灉鏄紪鐮佺敓鎴愬け璐ワ紝鍒欑洿鎺ュ氨澶辫触浜嗭紝鍏朵粬鐨勫垽鏂嚭鏉ユ湁閿欒鐨勬垜浠兘缁熶竴杩斿洖鍒癳xcel閲岄潰
+					engineService.batchSaveSelectChar(templateVO, dataCBOList);
+				} catch (Exception e) {
+					e.printStackTrace();
+					log.error("鎵逛簡鐢宠鏃跺け璐�");
+				}
+			}
+		}
+		if(!isCreateUUid){
+			return uuid="";
+		}
+		return uuid;
+	}
+
+	@Override
+	public List<CodeImportTemplateVO> gridclassifys(String redisOid) {
+		List<CodeImportTemplateVO> codeImportTemplateVOs=new ArrayList<>();
+		VciBaseUtil.alertNotNull(redisOid,"鍒嗙被",redisOid,"鍒嗙被缂撳瓨涓婚敭");
+		List<CodeImportTemplateVO> redisServiceCacheObjects=bladeRedis.get(redisOid);
+		if(redisServiceCacheObjects!=null){
+			codeImportTemplateVOs=  redisServiceCacheObjects;
+		}
+		return codeImportTemplateVOs;
+	}
+
+	/***
+	 * 浠庣紦瀛橀噷鑾峰彇鍒伴渶瑕佸鍏ョ殑鐩稿叧鏁版嵁
+	 * @param codeClssifyOid
+	 * @param redisOid
+	 * @return
+	 */
+	@Override
+	public DataGrid<Map<String, String>> gridDatas(String codeClssifyOid, String redisOid) {
+		VciBaseUtil.alertNotNull(redisOid,"瀵煎叆鐩镐技鏁版嵁",redisOid,"鏁版嵁缂撳瓨涓婚敭");
+		List<CodeImprotDataVO> codeImprotDataVOs = bladeRedis.get(redisOid+"-"+codeClssifyOid);
+//		redisService.getCacheList(redisOid+"-"+codeClssifyOid);
+		CodeImprotDataVO codeImprotDataVO=new CodeImprotDataVO();
+		if(!CollectionUtils.isEmpty(codeImprotDataVOs)){
+			if(StringUtils.isNotBlank(codeClssifyOid)){
+				Map<String/**鍒嗙被鍚嶇О**/, CodeImprotDataVO/**鑻辨枃鍚嶇О**/> codeClassifyDatasMap = codeImprotDataVOs.stream().collect(Collectors.toMap(s -> s.getCodeClassifyOid(), t -> t,(o1, o2)->o2));
+				if(codeClassifyDatasMap.containsKey(codeClssifyOid)){
+					codeImprotDataVO= codeClassifyDatasMap.get(codeClssifyOid);
+				}else{
+					codeImprotDataVO=  codeImprotDataVOs.get(0);
+				}
+			}
+		}
+		DataGrid<Map<String, String>> dataGrid = new DataGrid<>();
+		List<Map<String, String>> dataList = new ArrayList<>();
+		if(codeImprotDataVO!=null){
+			dataList= codeImprotDataVO.getDatas();
+		}
+		dataGrid.setData(dataList);
+		if (!CollectionUtils.isEmpty(dataList)) {
+			dataGrid.setTotal(dataList.size());
+		}
+		return dataGrid;
+	}
+
+	/**
+	 *
+	 * @param oid
+	 * @param redisOid
+	 * @return
+	 */
+	@Override
+	public DataGrid<Map<String,String>> gridRowResemble(String oid,String redisOid){
+		VciBaseUtil.alertNotNull(redisOid,"瀵煎叆鐩镐技鏁版嵁",redisOid,"鏁版嵁缂撳瓨涓婚敭");
+		List<DataResembleVO> codeImprotDataVOs = bladeRedis.get(redisOid);;
+		DataGrid<Map<String, String>> dataGrid = new DataGrid<>();
+		List<Map<String, String>> dataList = new ArrayList<>();
+
+		if(!CollectionUtils.isEmpty(codeImprotDataVOs)){
+			Map<String/**鍒嗙被鍚嶇О**/, DataResembleVO/**鏁版嵁瀵硅薄**/> rowResembleDataMap = codeImprotDataVOs.stream().collect(Collectors.toMap(s -> s.getOid(), t -> t,(o1, o2)->o2));
+			if(rowResembleDataMap.containsKey(oid)){
+				DataResembleVO dataResembleVO=  rowResembleDataMap.get(oid);
+				dataList= dataResembleVO.getDataList();
+			}
+		}
+
+		dataGrid.setData(dataList);
+		if (!CollectionUtils.isEmpty(dataList)) {
+			dataGrid.setTotal(dataList.size());
+		}
+		return dataGrid;
+	}
+
+	@Override
+	public R batchImportData(List<CodeImprotSaveDatVO> codeImprotSaveDatVOList, String classifyAttr, boolean isImprot) {
+
+		boolean success=true;
+		codeImprotSaveDatVOList.stream().forEach(codeImprotSaveDatVO -> {
+			List<SheetRowData> rowDataList = new ArrayList<>();
+			List<ClientBusinessObject>cboList=new ArrayList<>();
+			List<String> colList=codeImprotSaveDatVO.getClos();
+			CodeOrderDTO orderDTO= codeImprotSaveDatVO.getOrderDTO();
+			List<Map<String, String>> dataList= codeImprotSaveDatVO.getDataList();
+			Map<Integer, String> fieldIndexMap = new HashMap();
+			for (int i=0;i<dataList.size();i++){
+				SheetRowData sheetRowData=new SheetRowData();
+				Map<String,String> dataMap= dataList.get(i);
+				Map<Integer, String> data = new HashMap();
+				final int[] colIndex = {0};
+				Map<Integer, String> finalFieldIndexMap = new HashMap<>();
+				dataMap.forEach((field, value)->{
+					if(!ROW_INDEX.equalsIgnoreCase(field) && !ERROR_MSG.equalsIgnoreCase(field)){
+						data.put(colIndex[0],value);
+						finalFieldIndexMap.put(colIndex[0]++,field);
+					}
+				});
+				fieldIndexMap=finalFieldIndexMap;
+				sheetRowData.setData(data);
+				sheetRowData.setRowIndex(i+"");
+				rowDataList.add(sheetRowData);
+			}
+			CodeClassifyFullInfoBO classifyFullInfo = classifyService.getClassifyFullInfo(orderDTO.getCodeClassifyOid());
+			log.info("鍒嗙被锛�"+classifyFullInfo.getCurrentClassifyVO().getName()+"鏁版嵁:"+codeImprotSaveDatVO.getDataList().size());
+
+			// CodeClassifyTemplateVO codeClassifyTemplateVO=   engineService.getUsedTemplateByClassifyOid(orderDTO.getCodeClassifyOid());
+			CodeClassifyTemplateVO codeClassifyTemplateVO=  templateService.getObjectHasAttrByOid(orderDTO.getTemplateOid());
+			//瑙勫垯鐨勪富閿渶瑕佸幓鑾峰彇
+			CodeRuleVO ruleVO = engineService.getCodeRuleByClassifyFullInfo(classifyFullInfo);
+			//闄ゅ幓榛樿鐨勫睘鎬�.杩樻湁鍙湁琛ㄥ崟鏄剧ず鐨勫瓧娈垫墠瀵煎叆
+			List<CodeClassifyTemplateAttrVO> attrVOS = codeClassifyTemplateVO.getAttributes().stream().filter(s ->
+				!DEFAULT_ATTR_LIST.contains(s.getId()) && VciBaseUtil.getBoolean(s.getFormDisplayFlag())
+			).collect(Collectors.toList());
+			String fullPath = getFullPath(classifyFullInfo);
+			excelToCbo(classifyFullInfo,fieldIndexMap,rowDataList, codeClassifyTemplateVO,cboList,fullPath,!isImprot);
+			Map<String,String> errorMap=new HashMap<>();
+			Map<String/**璺緞**/, CodeClassifyVO> pathMap=new HashMap<>() ;
+			//鏍￠獙缂栫爜瑙勫垯鍜岀爜娈垫槸鍚︽纭�
+			Map<String, List<String>> ruleRowIndexMap = new ConcurrentHashMap<>();
+			Map<String, CodeRuleVO> ruleVOMap =new ConcurrentHashMap<>();
+			if(isImprot) {
+				Map<String/**涓婚敭**/, String/**璺緞**/> childOidPathMap = getChildClassifyPathMap(classifyFullInfo, fullPath);
+				//閮借浆鎹㈠畬浜嗐�傞渶瑕佹壒閲忔鏌�
+				//鎵炬墍鏈夌殑鍒嗙被璺緞,闇�瑕佹牎楠岃矾寰勬槸鍚︽纭紝鏄惁閮藉湪褰撳墠鐨勫垎绫荤殑涓嬬骇
+				List<CodeClassifyVO> childClassifyVOs = classifyService.listChildrenClassify(orderDTO.getCodeClassifyOid(), true, classifyAttr, true);
+				pathMap = Optional.ofNullable(childClassifyVOs).orElseGet(() -> new ArrayList<>()).stream().collect(Collectors.toMap(s -> s.getPath().startsWith("#") ? s.getPath().substring(1) : s.getPath(), t -> t));
+				Map<String/**涓婚敭**/, CodeClassifyVO> classifyVOMap = Optional.ofNullable(childClassifyVOs).orElseGet(() -> new ArrayList<>()).stream().collect(Collectors.toMap(s -> s.getOid(), t -> t));
+				classifyVOMap.put(classifyFullInfo.getCurrentClassifyVO().getOid(), classifyFullInfo.getCurrentClassifyVO());
+				pathMap.put("#current#", classifyFullInfo.getCurrentClassifyVO());
+				//鎴戜滑闇�瑕佸垽鏂繖浜涘垎绫荤殑妯℃澘鏄笉鏄竴鏍风殑锛屽彧闇�瑕佹牎楠岋紝涓嶇敤鑾峰彇
+				//妫�鏌ュ垎绫荤殑璺緞
+				checkClassifyPathInHistory(cboList, errorMap, pathMap, childOidPathMap);
+				//妫�鏌ヨ鍒�
+				Map<String/**鍒嗙被涓婚敭**/, String/**瑙勫垯涓婚敭**/> ruleOidMap = new ConcurrentHashMap<String, String>();
+				List<String> unExistRuleClassifyOidList = new CopyOnWriteArrayList<>();
+				checkRuleOidInHistory(classifyVOMap, ruleOidMap, unExistRuleClassifyOidList);
+				ruleVOMap = ruleService.listCodeRuleByIds(ruleOidMap.values(), true).stream().collect(Collectors.toMap(s -> s.getOid(), t -> t));
+
+				checkSecLengthInHistory(cboList, classifyVOMap, ruleVOMap, ruleOidMap, errorMap, ruleRowIndexMap);
+			}
+
+			//鍒嗙被娉ㄥ叆
+			batchSwitchClassifyAttrOnOrder(attrVOS,cboList,classifyFullInfo,isImprot);
+			//boolean
+			reSwitchBooleanAttrOnOrder(attrVOS,cboList);
+			//4.鏍￠獙瑙勫垯
+			batchCheckVerifyOnOrder(attrVOS, cboList,errorMap);
+			//5.鏍￠獙鏋氫妇鏄惁姝ｇ‘
+			batchSwitchEnumAttrOnOrder(attrVOS, cboList, errorMap);
+			//7.澶勭悊鍙傜収鐨勬儏鍐�
+			batchSwitchReferAttrOnOrder(attrVOS,cboList,errorMap);
+			//6.鏃堕棿鏍煎紡鐨勯獙璇�
+			//6.鏃堕棿鐨勶紝蹇呴』缁熶竴涓簓yyy-MM-dd HH:mm:ss
+			batchSwitchDateAttrOnOrder(attrVOS,cboList,errorMap);
+			//璁剧疆榛樿鍊�
+			batchSwitchAttrDefault(attrVOS, cboList);
+			//鏈�鍚庡紕缁勫悎瑙勫垯
+			batchSwitchComponentAttrOnOrder(attrVOS,cboList);
+			//3.鍒ゆ柇鍏抽敭灞炴��
+			CodeImportResultVO keyResultVO = batchCheckKeyAttrOnOrder(classifyFullInfo, codeClassifyTemplateVO, cboList);
+			Set<String> selfRepeatRowIndexList = keyResultVO.getSelfRepeatRowIndexList();
+			Set<String> keyAttrRepeatRowIndexList = keyResultVO.getKeyAttrRepeatRowIndexList();
+			if(!CollectionUtils.isEmpty(keyAttrRepeatRowIndexList)){
+				keyAttrRepeatRowIndexList.stream().forEach(rowIndex->{
+					errorMap.put(rowIndex,errorMap.getOrDefault(rowIndex,"") + ";鍏抽敭灞炴�т笌绯荤粺涓殑閲嶅" );
+				});
+			}
+			//4.鏍￠獙瑙勫垯
+			batchCheckVerifyOnOrder(attrVOS, cboList,errorMap);
+
+			if(isImprot){
+				List<ClientBusinessObject> needSaveCboList = cboList.stream().filter(cbo -> {
+					String rowIndex = cbo.getAttributeValue(IMPORT_ROW_INDEX);
+					return !errorMap.containsKey(rowIndex);
+				}).collect(Collectors.toList());
+				List<ClientBusinessObject> finalNeedSaveCboList = needSaveCboList;
+				Map<String, CodeRuleVO> finalRuleVOMap = ruleVOMap;
+				ruleRowIndexMap.keySet().parallelStream().forEach(ruleOid -> {
+					List <BaseModel>dataCBOList=new CopyOnWriteArrayList<>();
+					List<String> rowIndexList = ruleRowIndexMap.get(ruleOid);
+					List<ClientBusinessObject> thisCbos = needSaveCboList.stream().filter(cbo -> rowIndexList.contains(cbo.getAttributeValue(IMPORT_ROW_INDEX)) && !errorMap.containsKey(cbo.getAttributeValue(IMPORT_ROW_INDEX))).collect(Collectors.toList());
+					if (!CollectionUtils.isEmpty(thisCbos)) {
+						thisCbos.stream().forEach(clientBusinessObject -> {
+							BaseModel baseModel = new BaseModel();
+							BeanUtil.convert(clientBusinessObject, baseModel);
+							dataCBOList.add(baseModel);
+						});
+						try {
+							productCodeService.productCodeAndSaveData(classifyFullInfo, codeClassifyTemplateVO, finalRuleVOMap.get(ruleOid), null, dataCBOList);
+						} catch (Throwable e) {
+							//success=false;
+							log.error("鎵归噺浜х敓缂栫爜鐨勬椂鍊欏嚭閿欎簡", e);
+							thisCbos.stream().forEach(cbo -> {
+								String rowIndex = cbo.getAttributeValue(IMPORT_ROW_INDEX);
+								errorMap.put(rowIndex, errorMap.getOrDefault(rowIndex, "") + ";绯荤粺閿欒锛屽瓨鍌ㄦ暟鎹殑鏃跺�欏嚭閿欎簡");
+							});
+						}
+					}
+					engineService.batchSaveSelectChar(codeClassifyTemplateVO, dataCBOList);
+				});
+			}else {
+				List<BaseModel> dataCBOList=new ArrayList<>();
+				List<ClientBusinessObject> needSaveCboList = cboList.stream().filter(cbo -> {
+					String rowIndex = cbo.getAttributeValue(IMPORT_ROW_INDEX);
+					return !errorMap.containsKey(rowIndex);
+				}).collect(Collectors.toList());
+				log.info("鍒嗙被锛�" + classifyFullInfo.getCurrentClassifyVO().getName() + "鏁版嵁:" + needSaveCboList.size());
+				if (!CollectionUtils.isEmpty(needSaveCboList)) {
+					needSaveCboList.stream().forEach(clientBusinessObject -> {
+						BaseModel baseModel = new BaseModel();
+						BeanUtil.convert(clientBusinessObject, baseModel);
+						dataCBOList.add(baseModel);
+					});
+					try {
+						productCodeService.productCodeAndSaveData(classifyFullInfo, codeClassifyTemplateVO, ruleVO, orderDTO.getSecDTOList(), dataCBOList);
+					} catch (Exception e) {
+						e.printStackTrace();
+					}
+					//濡傛灉鏄紪鐮佺敓鎴愬け璐ワ紝鍒欑洿鎺ュ氨澶辫触浜嗭紝鍏朵粬鐨勫垽鏂嚭鏉ユ湁閿欒鐨勬垜浠兘缁熶竴杩斿洖鍒癳xcel閲岄潰
+					engineService.batchSaveSelectChar(codeClassifyTemplateVO, dataCBOList);
+				}
+			}
+		});
+		return  R.success(isImprot?"鎵归噺鍘嗗彶瀵煎叆鎴愬姛":"鎵归噺鐢宠鎴愬姛");
+	}
+
+	/***
+	 *鏍规嵁鏁版嵁oid浠庣紦瀛樹腑绉婚櫎鏁版嵁
+	 * @param redisOid redisid
+	 * @param codeClssifyOid 瀛樺偍瑙勫垯鐨刼id
+	 * @param dataOids  鎵�闇�鍒犻櫎鐨勬暟鎹�
+	 * @return
+	 */
+	@Override
+	public R deleteDatas(String redisOid,String codeClssifyOid,String dataOids) {
+		VciBaseUtil.alertNotNull(redisOid, "鏁版嵁鍒犻櫎", redisOid, "鏁版嵁缂撳瓨涓婚敭");
+		VciBaseUtil.alertNotNull(codeClssifyOid, "鏁版嵁鍒犻櫎", codeClssifyOid, "缂栫爜瑙勫垯缂撳瓨涓婚敭");
+		VciBaseUtil.alertNotNull(dataOids, "鏁版嵁鍒犻櫎", dataOids, "鎵�闇�鍒犻櫎鐨勬暟鎹富閿�");
+		try {
+			List<CodeImprotDataVO> codeImprotDataVOs = bladeRedis.lRange(redisOid + "-" + codeClssifyOid,0,-1);
+			List<String> dataOidList = new ArrayList<>();
+			codeImprotDataVOs.stream().forEach(codeImprotDataVO -> {
+				List<Map<String, String>> newDataList = new ArrayList<>();
+				List<Map<String, String>> dataList = codeImprotDataVO.getDatas();
+				dataList.stream().forEach(dataMap -> {
+					String oid = dataMap.get("oid");
+					if (!dataOidList.contains(oid)) {
+						newDataList.add(dataMap);
+					}
+
+				});
+				codeImprotDataVO.setDatas(newDataList);
+
+			});
+			//閲嶆柊缂撳瓨
+			bladeRedis.del(redisOid + "-" + codeClssifyOid);
+			bladeRedis.set(redisOid + "-" + codeClssifyOid, codeImprotDataVOs);
+			bladeRedis.expire(redisOid + "-" + codeClssifyOid, BATCHADD_REDIS_TIME);
+			return R.success("鍒犻櫎缂撳瓨鏁版嵁鎴愬姛");
+		}catch (Throwable e){
+			return R.fail("鍒犻櫎缂撳瓨鏁版嵁澶辫触!");
+		}
+	}
 
 	/**
 	 * 闆嗘垚鎵归噺鐢宠鏁版嵁
@@ -83,12 +1674,12 @@
 
 		//闇�瑕佸垽鏂槸鍚︽墍鏈夌殑灞炴�ч兘鍦ㄦā鏉夸笂浜�
 		List<CodeClassifyTemplateAttrVO> unExistAttrVOs = attrVOS.stream().filter(s -> !fieldIndexMap.containsValue(s.getId().toLowerCase(Locale.ROOT))
-			&& StringUtils.isBlank(s.getComponentRule()) && StringUtils.isBlank(s.getClassifyInvokeAttr())//缁勫悎瑙勫垯鍜屽垎绫绘敞鍏ョ‘瀹炴病缁欑敤鎴峰鍑哄幓
+			&& com.alibaba.cloud.commons.lang.StringUtils.isBlank(s.getComponentRule()) && com.alibaba.cloud.commons.lang.StringUtils.isBlank(s.getClassifyInvokeAttr())//缁勫悎瑙勫垯鍜屽垎绫绘敞鍏ョ‘瀹炴病缁欑敤鎴峰鍑哄幓
 		).collect(Collectors.toList());
 		if(!CollectionUtils.isEmpty(unExistAttrVOs)){
 			throw new VciBaseException("銆�" + unExistAttrVOs.stream().map(CodeClassifyTemplateAttrVO::getName) + "銆戣繖浜涘睘鎬у湪excel涓病鏈夋壘鍒�");
 		}
-
+		List<ClientBusinessObject> cboList = new ArrayList<>();
 		String fullPath = getFullPath(classifyFullInfo);
 
 		// List<CodeClassifyProcessTempVO> codeClassifyProcessTempVOS=codeClassifyProcessTempService.listProcessTemplate(templateVO.getOid(),"code_cls_flow_use_order");
@@ -97,19 +1688,803 @@
 		/** if(!CollectionUtils.isEmpty(codeClassifyProcessTempVOS)){
 		 isProcess=true;
 		 }***/
-		//List<ClientBusinessObject> cboList = new ArrayList<>();
-		//Map<String,String> codeOidToSystemOidMap=new HashMap<>();//瀛樺偍缂栫爜鏁版嵁鍜岄泦鎴愮郴缁熸暟鎹畂id瀵圭収鏄犲皠
-		//excelToCbo(classifyFullInfo,titleRowData,fieldIndexMap,rowDataList,templateVO,cboList,fullPath,isProcess,"create",errorMap,codeOidToSystemOidMap);
+		Map<String,String> codeOidToSystemOidMap=new HashMap<>();//瀛樺偍缂栫爜鏁版嵁鍜岄泦鎴愮郴缁熸暟鎹畂id瀵圭収鏄犲皠
+		excelToCbo(classifyFullInfo,titleRowData,fieldIndexMap,rowDataList,templateVO,cboList,fullPath,isProcess,"create",errorMap,codeOidToSystemOidMap);
 
 		//閮借浆鎹㈠畬浜嗐�傞渶瑕佹壒閲忔鏌�
 		//濡傛灉鍑洪敊浜嗭紝鎴戜滑渚濈劧鎵ц鏈夋晥鐨勬暟鎹紝鏃犳晥鐨勬暟鎹啓鍥炲埌excel涓�
 		//2.鍒ゆ柇蹇呰緭椤广�傘�傞渶瑕佸叏閮ㄧ殑灞炴�э紝濡傛灉鏄繀杈擄紝浣嗘槸琛ㄥ崟閲岄潰涓嶆樉绀虹殑锛屽彧鑳芥槸鍒嗙被娉ㄥ叆鎴栬�呯粍鍚堣鍒�
+		batchCheckRequiredAttrOnOrder(templateVO,cboList,errorMap);
+
+
+		/**
+		 * 鍏抽敭鐔熸倝閿欒鎻愮ず
+		 */
+		Map<String,String> errorKeyMap=new HashMap<>();
+
+
+		//3.鍒ゆ柇鍏抽敭灞炴��
+		CodeImportResultVO keyResultVO = batchCheckKeyAttrOnOrder(classifyFullInfo, templateVO, cboList);
+		Set<String> selfRepeatRowIndexList = keyResultVO.getSelfRepeatRowIndexList();
+		Set<String> keyAttrRepeatRowIndexList = keyResultVO.getKeyAttrRepeatRowIndexList();
+		if(!CollectionUtils.isEmpty(selfRepeatRowIndexList)){
+			selfRepeatRowIndexList.stream().forEach(rowIndex->{
+               /* //浼犲叆鏁版嵁涔嬮棿鍏抽敭灞炴�х殑鏍￠獙
+                RowDatas rowData= rowDataMap.get(rowIndex);
+                XMLResultDataObjectDetailDO resultDataObjectDetailDO=new XMLResultDataObjectDetailDO();
+                resultDataObjectDetailDO.setCode("");
+                resultDataObjectDetailDO.setId(rowData.getOid());
+                resultDataObjectDetailDO.setErrorid("1");
+                resultDataObjectDetailDO.setMsg(errorMap.getOrDefault(rowIndex,"") + ";鍏抽敭灞炴�ч噸澶�");
+                resultDataObjectDetailDOs.add(resultDataObjectDetailDO);
+                */
+				errorKeyMap.put(rowIndex,errorMap.getOrDefault(rowIndex,"") + ";浼犲叆鐨勬暟鎹腑鍏抽敭灞炴�ч噸澶�");
+			});
+		}
+		/****
+		 * 鍏抽敭灞炴�т笌绯荤粺涓噸澶嶇殑鍒ゆ柇
+		 */
+		if(!CollectionUtils.isEmpty(keyAttrRepeatRowIndexList)){
+			keyAttrRepeatRowIndexList.stream().forEach(rowIndex->{
+				//浼犲叆鏁版嵁涔嬮棿鍏抽敭灞炴�х殑鏍￠獙
+               /* RowDatas rowData= rowDataMap.get(rowIndex);
+                XMLResultDataObjectDetailDO resultDataObjectDetailDO=new XMLResultDataObjectDetailDO();
+                resultDataObjectDetailDO.setCode("");
+                resultDataObjectDetailDO.setId(rowData.getOid());
+                resultDataObjectDetailDO.setErrorid("1");
+                resultDataObjectDetailDO.setMsg(errorMap.getOrDefault(rowIndex,"") + ";鍏抽敭灞炴�т笌绯荤粺涓殑閲嶅" );
+                resultDataObjectDetailDOs.add(resultDataObjectDetailDO);
+                */
+				errorKeyMap.put(rowIndex,errorMap.getOrDefault(rowIndex,"") + ";鍏抽敭灞炴�т笌绯荤粺涓殑閲嶅" );
+			});
+		}
+		//鍒嗙被娉ㄥ叆
+		batchSwitchClassifyAttrOnOrder(attrVOS,cboList,classifyFullInfo,false);
+		//boolean
+		reSwitchBooleanAttrOnOrder(attrVOS,cboList);
+		// cboList.stream().forEach(cbo->{
+		//4.鏍￠獙瑙勫垯
+		batchCheckVerifyOnOrder(attrVOS, cboList,errorMap);
+		//5.鏍￠獙鏋氫妇鏄惁姝ｇ‘
+		batchSwitchEnumAttrOnOrder(attrVOS,cboList,errorMap);
+		//6.鏃堕棿鏍煎紡鐨勯獙璇�
+		//6.鏃堕棿鐨勶紝蹇呴』缁熶竴涓簓yyy-MM-dd HH:mm:ss
+		batchSwitchDateAttrOnOrder(attrVOS,cboList,errorMap);
+		//7.澶勭悊鍙傜収鐨勬儏鍐�
+		batchSwitchReferAttrOnOrder(attrVOS,cboList,errorMap);
+		//鏍￠獙灞炴�ф槸鍚︽纭敊璇俊鎭�
+		if(errorMap.size()>0){
+			String[] newMsg = {""};
+			cboList.stream().forEach(cbo -> {
+				String rowIndex =cbo.getAttributeValue(IMPORT_ROW_INDEX);
+				if(errorMap.containsKey(rowIndex)){
+					String oid=cbo.getOid();
+					String sourceOid=oid;
+					if(codeOidToSystemOidMap.containsKey(oid)){
+						sourceOid=codeOidToSystemOidMap.get(oid);
+					}
+					String code="";
+					String errorid="103";
+					String mes=errorMap.get(rowIndex);
+					XMLResultDataObjectDetailDO resultDataObjectDetailDO=new XMLResultDataObjectDetailDO();
+					resultDataObjectDetailDO.setCode(code);
+					resultDataObjectDetailDO.setId(sourceOid);
+					resultDataObjectDetailDO.setErrorid(errorid);
+					resultDataObjectDetailDO.setMsg(mes);
+					resultDataObjectDetailDOs.add(resultDataObjectDetailDO);
+				}
+			});
+
+		}
+
+		Map<String,String> newKeyMap=new HashedMap();
+		if(errorKeyMap.size()>0 ) {
+			errorKeyMap.keySet().forEach(key->{
+				if(!errorMap.containsKey(key)){
+					newKeyMap.put(key,errorKeyMap.get(key));
+				}
+			});
+			if(newKeyMap.size()>0) {
+				List<BaseModel> editBoList = new ArrayList<>();
+				Map<String, List<BaseModel>> indexTodataMap = keyResultVO.getIndexTODataMap();
+				cboList.stream().forEach(cbo -> {
+					String rowIndex = cbo.getAttributeValue(IMPORT_ROW_INDEX);
+					if (indexTodataMap.containsKey(rowIndex)) {
+						String oid = cbo.getOid();
+						String sourceOid = oid;
+						String code = "";
+						String errorid = "201";
+						if(codeOidToSystemOidMap.containsKey(oid)){
+							sourceOid=codeOidToSystemOidMap.get(oid);
+						}
+						List<BaseModel> newCboList = indexTodataMap.get(rowIndex);
+						if (!CollectionUtils.isEmpty(newCboList)) {
+							BaseModel newCbo= newCboList.get(0);
+							String lcstatus =newCbo.getLcStatus();
+							String newOid =newCbo.getOid();
+							Date ts =newCbo.getTs();
+							code=newCbo.getId();
+							String lastmodifier=newCbo.getLastModifier();
+							if (!lcstatus.equals(CodeDefaultLC.RELEASED.getValue())) {
+								newCbo.setOid(newOid);
+								newCbo.setLastModifier(lastmodifier);
+								newCbo.setId(code);
+								newCbo.setTs(ts);
+								cbo.setLastModifier(cbo.getLastModifier());
+								editBoList.add(newCbo);
+							}
+							String mes = errorKeyMap.get(rowIndex);
+							XMLResultDataObjectDetailDO resultDataObjectDetailDO = new XMLResultDataObjectDetailDO();
+							resultDataObjectDetailDO.setCode(code);
+							resultDataObjectDetailDO.setId(sourceOid);
+							resultDataObjectDetailDO.setErrorid(errorid);
+							resultDataObjectDetailDO.setMsg(mes);
+							resultDataObjectDetailDOs.add(resultDataObjectDetailDO);
+						}
+					}
+				});
+				//鍏抽敭鐔熸倝鏇存敼
+				if (!CollectionUtils.isEmpty(editBoList)) {
+					engineService.updateBatchByBaseModel(classifyFullInfo.getTopClassifyVO().getBtmtypeid(),editBoList);//淇濆瓨鏁版嵁
+				}
+				errorMap.putAll(errorKeyMap);
+			}
+		}
+
+		//  });
+		//璁剧疆榛樿鍊�
+		batchSwitchAttrDefault(attrVOS, cboList);
+		//鏈�鍚庡紕缁勫悎瑙勫垯
+		batchSwitchComponentAttrOnOrder(attrVOS,cboList);
+		//瑕佹妸浠ヤ笂鐨勯敊璇殑閮芥姏鍑哄悗锛屽啀缁х画澶勭悊鏃堕棿鍜岀粍鍚堣鍒�
+		List<ClientBusinessObject> needSaveCboList = cboList.stream().filter(cbo -> {
+			String rowIndex =cbo.getAttributeValue(IMPORT_ROW_INDEX);
+			return !errorMap.containsKey(rowIndex);
+		}).collect(Collectors.toList());
+		List<String> needRowIndexList = new ArrayList<>();
+		if(!CollectionUtils.isEmpty(needSaveCboList)) {
+			//9.鎴戜滑澶勭悊涓氬姟鏁版嵁
+			//鐢熸垚缂栫爜鐨勫唴瀹�
+
+			List<String>allNeedSaveCboList=new ArrayList<>();
+			List<BaseModel> dataCBOList=new ArrayList<>();
+			needSaveCboList.stream().forEach(clientBusinessObject -> {
+				BaseModel baseModel=new BaseModel();
+				BeanUtil.convert(clientBusinessObject,baseModel);
+			//(VciBaseUtil.objectToMapString(clientBusinessObject));
+				dataCBOList.add(baseModel);
+				allNeedSaveCboList.add(baseModel.getOid());
+			});
+			try {
+				productCodeService.productCodeAndSaveData(classifyFullInfo, templateVO, ruleVO, orderDTO.getSecDTOList(), dataCBOList);
+				//濡傛灉鏄紪鐮佺敓鎴愬け璐ワ紝鍒欑洿鎺ュ氨澶辫触浜嗭紝鍏朵粬鐨勫垽鏂嚭鏉ユ湁閿欒鐨勬垜浠兘缁熶竴杩斿洖鍒癳xcel閲岄潰
+				engineService.batchSaveSelectChar(templateVO, dataCBOList);
+				// if(!isProcess){
+				needSaveCboList.stream().forEach(needSaveCbo->{
+					XMLResultDataObjectDetailDO resultDataObjectDetailDO=new XMLResultDataObjectDetailDO();
+					resultDataObjectDetailDO.setCode(needSaveCbo.getId());
+					String oid=needSaveCbo.getOid();
+					String sourceOid=oid;
+					if(codeOidToSystemOidMap.containsKey(oid)){
+						sourceOid=codeOidToSystemOidMap.get(oid);
+					}
+					resultDataObjectDetailDO.setId(sourceOid);
+					resultDataObjectDetailDO.setErrorid("0");
+					resultDataObjectDetailDO.setMsg("鐢宠缂栫爜鎴愬姛");
+					resultDataObjectDetailDOs.add(resultDataObjectDetailDO);
+				});
+               /* }else{
+                    needSaveCboList.stream().forEach(needSaveCbo->{
+                        XMLResultDataObjectDetailDO resultDataObjectDetailDO=new XMLResultDataObjectDetailDO();
+                       // resultDataObjectDetailDO.setCode(needSaveCbo.getId());//涓嶇敤杩斿洖缂栫爜
+                        String oid=needSaveCbo.getOid();
+                        String sourceOid=oid;
+                        if(codeOidToSystemOidMap.containsKey(oid)){
+                            sourceOid=codeOidToSystemOidMap.get(oid);
+                        }
+                        resultDataObjectDetailDO.setId(sourceOid);
+                        resultDataObjectDetailDO.setErrorid("204");
+                        resultDataObjectDetailDO.setMsg("鐢宠缂栫爜鎴愬姛锛岀瓑寰呯紪鐮佺郴缁熷彂甯冿紒");
+                        resultDataObjectDetailDOs.add(resultDataObjectDetailDO);
+                    });
+
+                }*/
+			}catch (Throwable e){
+				e.printStackTrace();
+				needSaveCboList.stream().forEach(needSaveCbo->{
+					XMLResultDataObjectDetailDO resultDataObjectDetailDO=new XMLResultDataObjectDetailDO();
+					resultDataObjectDetailDO.setCode("");
+					String oid=needSaveCbo.getOid();
+					String sourceOid=oid;
+					if(codeOidToSystemOidMap.containsKey(oid)){
+						sourceOid=codeOidToSystemOidMap.get(oid);
+					}
+					resultDataObjectDetailDO.setId(sourceOid);
+					resultDataObjectDetailDO.setErrorid("1");
+					resultDataObjectDetailDO.setMsg("淇濆瓨鍑虹幇闂:"+e.getMessage());
+					resultDataObjectDetailDOs.add(resultDataObjectDetailDO);
+				});
+
+			}
+		}
 
 	}
-
+	/***
+	 * 闆嗘垚鎵归噺鍚屾鏇存柊鎺ュ彛
+	 * @param codeClassifyVO;
+	 * @param dataObjectVO 鏁版嵁淇℃伅
+	 * @param resultDataObjectDetailDOs 閿欒淇℃伅
+	 */
+	@Transactional(rollbackFor = VciBaseException.class)
 	@Override
 	public void batchSyncEditDatas(CodeClassifyVO codeClassifyVO, DataObjectVO dataObjectVO, LinkedList<XMLResultDataObjectDetailDO> resultDataObjectDetailDOs) {
+		String errorid="";
+		String msg="";
+		//鏌ヨ鍒嗙被鍜屾ā鏉�
+		//鍏堟壘鍒版瘡涓�琛岀殑鏍囬锛岀劧鍚庢牴鎹爣棰樻潵鑾峰彇瀵瑰簲鐨勫睘鎬�
+		List<RowDatas> rowDataList = dataObjectVO.getRowData();
+		Map<String, RowDatas> rowDataMap = new LinkedHashMap<>();
+		Map<String, RowDatas> codeDataMap = new LinkedHashMap<>();
+		rowDataList.stream().forEach(rowData -> {
+			rowDataMap.put(rowData.getRowIndex(), rowData);
+			codeDataMap.put(rowData.getCode(), rowData);
+		});
+		//鎵剧涓�琛岋紝涓轰簡鎵炬爣棰�
+		CodeClassifyTemplateVO templateVO = engineService.getUsedTemplateByClassifyOid(codeClassifyVO.getOid());
+		// 搴旇閮芥槸涓�涓垎绫讳笅鐨勪笟鍔℃暟鎹紝鎵剧涓�鏉＄殑灏辫
+		CodeClassifyFullInfoBO classifyFullInfo = classifyService.getClassifyFullInfo(codeClassifyVO.getOid());
+		//鏍￠獙妯℃澘鏄笉鏄渶鏂扮殑
+		//checkTemplateSync(sheetDataSetList,templateVO);
+		//闄ゅ幓榛樿鐨勫睘鎬�.杩樻湁鍙湁琛ㄥ崟鏄剧ず鐨勫瓧娈垫墠瀵煎叆
+		List<CodeClassifyTemplateAttrVO> attrVOS = templateVO.getAttributes().stream().filter(s -> !DEFAULT_SYNC_ATTR_LIST.contains(s.getId()) && VciBaseUtil.getBoolean(s.getFormDisplayFlag())
+		).collect(Collectors.toList());
+		Map<Integer/**鍒楀彿**/, String/**瀛楁鐨勫悕绉�**/> fieldIndexMap = new HashMap<>();
+		List<String> titleRowData = dataObjectVO.getColName();
+		Map<String/**涓枃鍚嶇О**/, String/**鑻辨枃鍚嶇О**/> attrNameIdMap = attrVOS.stream().collect(Collectors.toMap(s -> s.getName(), t -> t.getId().toLowerCase(Locale.ROOT), (o1, o2) -> o2));
+		getFieldIndexMap(titleRowData, attrNameIdMap, fieldIndexMap);
+		Map<String, String> cboOidMap = new HashMap<>();
+		cboOidMap.put("id", QueryOptionConstant.IN + "(" + VciBaseUtil.toInSql(codeDataMap.keySet().toArray(new String[0])) + ")");
+		String tableName ="";
+		try {
+			R<BtmTypeVO> r = btmTypeClient.getAllAttributeByBtmId(templateVO.getBtmTypeId());
+			if(r.getCode()!=200) {
+				throw new Throwable(r.getMsg());
+			}
+			BtmTypeVO btmTypeVO = r.getData();
+			if (btmTypeVO == null) {
+				throw new Throwable("鏍规嵁涓氬姟绫诲瀷鏈煡璇㈠埌涓氬姟绫诲瀷瀵硅薄锛�");
+			}
+			tableName = btmTypeVO.getTableName();
+			if (StringUtils.isBlank(tableName)) {
+				throw new Throwable("鏍规嵁涓氬姟绫诲瀷鏈煡璇㈠埌涓氬姟绫诲瀷鐩稿叧鑱旂殑琛�");
+			}
+		}catch (Throwable e){
+			log.error("鏌ヨ涓氬姟瀵硅薄琛�"+e);
+			XMLResultDataObjectDetailDO xmlResultDataObjectDetailDO=new XMLResultDataObjectDetailDO();
+			xmlResultDataObjectDetailDO.setErrorid("103");
+			xmlResultDataObjectDetailDO.setMsg("鏌ヨ涓氬姟瀵硅薄琛�"+e);
+			xmlResultDataObjectDetailDO.setId("");
+			xmlResultDataObjectDetailDO.setCode("");
+			resultDataObjectDetailDOs.add(xmlResultDataObjectDetailDO);
+			return;
+		}
 
+		StringBuffer sb=new StringBuffer();
+		sb.append(" select * from ");
+		sb.append(tableName);
+		sb.append(" where 1=1 ");
+		sb.append(" id in (");
+		sb.append(VciBaseUtil.toInSql(codeDataMap.keySet().toArray(new String[0])));
+		sb.append(")");
+		List<Map<String,String>> dataMapList=commonsMapper.queryByOnlySqlForMap(sb.toString());
+		List<ClientBusinessObject> cboList=	ChangeMapTOClientBusinessObjects(dataMapList);
+		Map<String, ClientBusinessObject> codeSystemObjectMap = cboList.stream().filter(systeDataObject -> systeDataObject != null && StringUtils.isNotBlank(systeDataObject.getId())).collect(Collectors.toList()).stream().collect(Collectors.toMap(s -> s.getId(), t -> t));
+		Map<String, String> errorMap = new HashMap<>();
+		List<CodeOrderDTO> codeOrderDTOList = new ArrayList<>();
+		this.getCodeOrderDTOs(codeClassifyVO, templateVO, codeDataMap, codeSystemObjectMap, codeOrderDTOList, errorMap);
+		// List<CodeClassifyProcessTempVO> codeClassifyProcessTempVOS=codeClassifyProcessTempService.listProcessTemplate(templateVO.getOid(),"code_cls_flow_use_order");
+		boolean isProcess=false;
+		/**  if(!CollectionUtils.isEmpty(codeClassifyProcessTempVOS)){
+		 isProcess=true;
+		 }**/
+
+		Map<String, CodeOrderDTO> orderDTOMap = codeOrderDTOList.stream().filter(orderDTO -> orderDTO != null && StringUtils.isNotBlank(orderDTO.getId())).collect(Collectors.toList()).stream().collect(Collectors.toMap(s -> s.getId(), t -> t));
+		List<BaseModel> updateList = new ArrayList<>();
+		List<CodeAllCode> codeAllCodeList = new ArrayList<>();
+		List<String> deleteList = new ArrayList<>();
+
+		CodeClassifyTemplateVO firstTemplateVO = templateService.getObjectHasAttrByOid(orderDTOMap.values().stream().findFirst().get().getTemplateOid());
+		Map<String, ClientBusinessObject> cboMap = cboList.stream().filter(cbo -> cbo != null).collect(Collectors.toList()).stream().collect(Collectors.toMap(s -> s.getId(), t -> t));
+		//  boolean finalIsProcess = isProcess;
+		orderDTOMap.keySet().stream().forEach(code -> {
+			CodeOrderDTO orderDTO = orderDTOMap.get(code);
+			ClientBusinessObject cbo = cboMap.get(code);
+			String dataStatus=cbo.getLcStatus();
+			RowDatas rowData=codeDataMap.get(code);
+			String status=rowData.getStatus();
+			String operation=rowData.getOperation();
+			if (cbo.getTs().compareTo(orderDTO.getTs())==0?true:false) {
+				// throw new VciBaseException("鏁版嵁涓嶆槸鏈�鏂扮殑锛屽彲鑳戒粬浜哄凡缁忎慨鏀癸紝璇峰埛鏂板悗鍐嶈瘯");
+				errorMap.put(orderDTO.getId(),errorMap.getOrDefault(orderDTO.getId(),"")+";鏁版嵁涓嶆槸鏈�鏂扮殑锛屽彲鑳戒粬浜哄凡缁忎慨鏀癸紝璇峰埛鏂板悗鍐嶈瘯");
+			}
+           /* if (!CodeDefaultLC.EDITING.getValue().equalsIgnoreCase(cbo.getLcStatus()) && !orderDTO.isEditInProcess()) {
+                throw new VciBaseException("鏁版嵁涓嶆槸{0}鐨勭姸鎬侊紝涓嶅厑璁镐慨鏀�", new String[]{CodeDefaultLC.EDITING.getText()});
+            }*/
+			if(operation.equals("update")) {
+				//1. 鍒ゆ柇蹇呰緭椤�
+				checkRequiredAttrOnOrder(templateVO, orderDTO, errorMap);
+				//2.鍏堟敞鍏ワ紝鍐嶇粍鍚堬紝鏈�鍚庢牎楠�
+				switchClassifyLevelOnOrder(templateVO, classifyFullInfo, orderDTO, errorMap);
+				//3.澶勭悊缁勫悎瑙勫垯銆傜粍鍚堣鍒欎笉鑳戒娇鐢ㄧ紪鐮佺殑灞炴�э紝鍥犱负缂栫爜鐨勭敓鎴愬彲鑳芥槸闇�瑕佸睘鎬х殑
+				switchComponentAttrOnOrder(templateVO, orderDTO);
+				//4.鏍￠獙瑙勫垯
+				checkVerifyOnOrder(templateVO, orderDTO, errorMap);
+				//5.鍒ゆ柇鍏抽敭灞炴��
+				checkKeyAttrOnOrder(classifyFullInfo, templateVO, orderDTO, errorMap);
+				//6.鏍￠獙鏋氫妇鐨勫唴瀹规槸鍚︽纭�
+				checkEnumOnOrder(templateVO, orderDTO, errorMap);
+				//7.澶勭悊鏃堕棿鏍煎紡锛屽湪鏁版嵁搴撻噷闈笉璁烘槸瀛楃涓茶繕鏄棩鏈熸牸寮忥紝閮戒娇鐢ㄧ浉鍚岀殑鏍煎紡瀛樺偍
+				switchDateAttrOnOrder(templateVO, orderDTO);
+				//榛樿鐨勫唴瀹逛笉鑳藉彉锛屾墍浠ュ彧闇�瑕佹嫹璐濊嚜瀹氫箟鐨勭浉鍏冲睘鎬у嵆鍙�
+				copyValueToCBO(classifyFullInfo, cbo, orderDTO, templateVO, true, errorMap);
+				//浼佷笟鐮佸拰闆嗗洟鐮佺殑涓嶄慨鏀�
+				cbo.setDescription(StringUtils.isBlank(orderDTO.getDescription())?"":orderDTO.getDescription());
+				cbo.setName(orderDTO.getName());
+				try {
+					cbo.setAttributeValueWithNoCheck("description", orderDTO.getDescription());
+					cbo.setAttributeValue("name", orderDTO.getName());
+					//  if(finalIsProcess){//鍦ㄦ祦绋嬩腑涓嶅厑璁告洿鏀�
+					//     errorMap.put(code,errorMap.getOrDefault(code, errorMap.getOrDefault(code,"")+";鏁版嵁"+code+"鍦ㄦ祦绋嬩腑锛屼笉鍏佽鏇存敼!"));
+					//  }else{
+					cbo.setLcStatus(status);
+					cbo.setAttributeValue("lcstatus",status);
+					//  }
+				} catch (VciBaseException e) {
+					e.printStackTrace();
+				}
+
+				List<CodeAllCode>newCodeAllCodeList= codeAllCodeService.selectByWrapper(Wrappers.<CodeAllCode>query().lambda().eq(CodeAllCode::getCreateCodeOid, cbo.getOid()));
+				if (!CollectionUtils.isEmpty(newCodeAllCodeList)) {
+					CodeAllCode codeCbo = codeAllCodeList.get(0);
+					log.info("codeCbos code:" + codeCbo.getId());
+					codeCbo.setLcStatus(status);
+					codeAllCodeList.add(codeCbo);
+				}
+
+				BaseModel baseModel=new BaseModel();
+				BeanUtil.convert(cbo,baseModel);
+				//baseModel.setData(VciBaseUtil.objectToMapString(cbo));
+				updateList.add(baseModel);
+			}else if(operation.equals("delete")){//濡傛灉鍦ㄦ祦绋嬩腑涓嶅厑璁稿垹闄わ紝涓嶅湪娴佺▼涓姸鎬佷负鍙戝竷鎴栬�呭仠鐢ㄧ殑鏁版嵁涓嶅厑璁稿垹闄わ紝灏嗗叾鏇存敼涓哄仠鐢紝鍏朵粬鐨勬儏鍐电洿鎺ュ垹闄�
+				//  if(finalIsProcess){
+				//    errorMap.put(code,errorMap.getOrDefault(code, errorMap.getOrDefault(code,"")+";鏁版嵁"+code+"鍦ㄦ祦绋嬩腑锛屼笉鍏佽鍒犻櫎!"));
+				//}else {
+				try {
+					log.info("oid:" + cbo.getOid());
+					List<CodeAllCode>newCodeAllCodeList= codeAllCodeService.selectByWrapper(Wrappers.<CodeAllCode>query().lambda().eq(CodeAllCode::getCreateCodeOid, cbo.getOid()));
+					log.info("codeCbos size:" + newCodeAllCodeList.size());
+					if (!CollectionUtils.isEmpty(newCodeAllCodeList)) {
+						CodeAllCode codeCbo = codeAllCodeList.get(0);
+						log.info("codeCbos code:" + codeCbo.getId());
+						codeCbo.setLcStatus(CodeDefaultLC.TASK_BACK.getValue());
+						codeAllCodeList.add(codeCbo);
+					}
+					deleteList.add(cbo.getOid());
+				}catch (VciBaseException e) {
+					e.printStackTrace();
+				}
+				// }
+			}else if(operation.equals("editstatus")){
+				try {
+					//  if (finalIsProcess) {
+					//      errorMap.put(code, errorMap.getOrDefault(code, errorMap.getOrDefault(code, "") + ";鏁版嵁" + code + "鍦ㄦ祦绋嬩腑锛屼笉鍏佽鏇存敼鐘舵��!"));
+					//   } else {
+					cbo.setLcStatus(status);
+					cbo.setAttributeValue("lcstatus", status);
+
+					//  }
+
+					List<CodeAllCode>newCodeAllCodeList= codeAllCodeService.selectByWrapper(Wrappers.<CodeAllCode>query().lambda().eq(CodeAllCode::getCreateCodeOid, cbo.getOid()));
+					if (!CollectionUtils.isEmpty(newCodeAllCodeList)) {
+						CodeAllCode codeCbo = codeAllCodeList.get(0);
+						log.info("codeCbos code:" + codeCbo.getId());
+						codeCbo.setLcStatus(status);
+						codeAllCodeList.add(codeCbo);
+					}
+
+					BaseModel baseModel=new BaseModel();
+					BeanUtil.convert(cbo,baseModel);
+					//baseModel.setData(VciBaseUtil.objectToMapString(cbo));
+					updateList.add(baseModel);
+				}catch (VciBaseException e) {
+					e.printStackTrace();
+				}
+			}
+		});
+		/**
+		 * 閿欒淇℃伅杈撳嚭
+		 */
+		if(errorMap.size()>0){
+			errorMap.keySet().forEach(code->{
+				if(codeDataMap.containsKey(code)){
+					RowDatas rowDatas=  codeDataMap.get(code);
+					String dataMsg=errorMap.get(code);
+					String oid=rowDatas.getOid();
+					XMLResultDataObjectDetailDO xmlResultDataObjectDetailDO=new XMLResultDataObjectDetailDO();
+					xmlResultDataObjectDetailDO.setErrorid("103");
+					xmlResultDataObjectDetailDO.setMsg(dataMsg);
+					xmlResultDataObjectDetailDO.setId(oid);
+					xmlResultDataObjectDetailDO.setCode(code);
+					resultDataObjectDetailDOs.add(xmlResultDataObjectDetailDO);
+				}
+			});
+		}else {
+			//瀛樺偍鏁版嵁
+			try {
+				engineService.updateBatchByBaseModel(classifyFullInfo.getTopClassifyVO().getBtmtypeid(),updateList);
+				codeAllCodeService.saveBatch(codeAllCodeList);
+				if(deleteList.size()>0) {
+					commonsMapper.deleteByTaleAndOid(tableName, VciBaseUtil.array2String(deleteList.toArray(new String[]{})));
+				}
+				errorid="0";
+				msg="鏇存柊/鐘舵�佹洿鏀�/鍒犻櫎鎴愬姛锛�";
+			}catch (Throwable e){
+				errorid="1";
+				msg="淇濆瓨澶辫触锛�"+e;
+			}finally {
+				String finalMsg = msg;
+				String finalErrorid = errorid;
+				cboList.stream().forEach(cbo->{
+					String code =cbo.getId();
+					if(codeDataMap.containsKey(code)) {
+						RowDatas rowDatas=codeDataMap.get(code);
+						String oid=rowDatas.getOid();
+						XMLResultDataObjectDetailDO xmlResultDataObjectDetailDO = new XMLResultDataObjectDetailDO();
+						xmlResultDataObjectDetailDO.setErrorid(finalErrorid);
+						xmlResultDataObjectDetailDO.setMsg(finalMsg);
+						xmlResultDataObjectDetailDO.setId(oid);
+						xmlResultDataObjectDetailDO.setCode(code);
+						resultDataObjectDetailDOs.add(xmlResultDataObjectDetailDO);
+					}
+				});
+
+			}
+		}
+	}
+	/**
+	 * 鏍￠獙灞炴�ф槸鍚︿负蹇呰緭
+	 *
+	 * @param templateVO 妯℃澘鐨勬樉绀哄璞★紝闇�瑕佸寘鍚ā鏉垮睘鎬�
+	 * @param orderDTO   缂栫爜鐢宠鐨勪俊鎭�
+	 */
+	private void checkRequiredAttrOnOrder(CodeClassifyTemplateVO templateVO, CodeOrderDTO orderDTO,Map<String,String> errorMap) {
+		Map<String, CodeClassifyTemplateAttrVO> requiredAttrMap = templateVO.getAttributes().stream().filter(
+				s -> VciBaseUtil.getBoolean(s.getRequireFlag()) && StringUtils.isBlank(s.getComponentRule())
+					&& StringUtils.isBlank(s.getClassifyInvokeAttr()))
+			.collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t));
+		if (!CollectionUtils.isEmpty(requiredAttrMap)) {
+			requiredAttrMap.forEach((attrId, attrVO) -> {
+				//鍙湁浼佷笟缂栫爜锛岀姸鎬侊紝澶囨敞锛屾ā鏉夸富閿紝鍒嗙被涓婚敭杩欏嚑涓槸鍥哄畾鐨勶紝鍏朵綑閮芥槸鑷閰嶇疆鐨�
+				if (StringUtils.isBlank(getValueFromOrderDTO(orderDTO, attrId))) {
+					errorMap.put(orderDTO.getId(),errorMap.getOrDefault(orderDTO.getId(),"") + ";灞炴�с�恵"+attrVO.getName()+"}銆戝繀椤昏杈撳叆(閫夋嫨)鍐呭" );
+					//  throw new VciBaseException("灞炴�с�恵0}銆戝繀椤昏杈撳叆(閫夋嫨)鍐呭", new String[]{attrVO.getName()});
+				}
+			});
+		}
+	}
+	/**
+	 * 杞崲缁勫悎瑙勫垯鐨勫��
+	 *
+	 * @param templateVO 妯℃澘鐨勬樉绀哄璞★紝闇�瑕佸寘鍚ā鏉垮睘鎬�
+	 * @param orderDTO   缂栫爜鐢宠鐨勪俊鎭�
+	 */
+	private void switchComponentAttrOnOrder(CodeClassifyTemplateVO templateVO, CodeOrderDTO orderDTO) {
+		Map<String, CodeClassifyTemplateAttrVO> compAttrVOMap = templateVO.getAttributes().stream().filter(s -> StringUtils.isNotBlank(s.getComponentRule())).collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t));
+		if (!CollectionUtils.isEmpty(compAttrVOMap)) {
+			Map<String, String> dataMap = WebUtil.objectToMapString(orderDTO);
+
+			Map<String, String> dataLowMap = new HashMap<>();
+			if (!CollectionUtils.isEmpty(dataMap)) {
+				dataMap.forEach((key, value) -> {
+					dataLowMap.put(key.toLowerCase(Locale.ROOT), value);
+				});
+			}
+			dataLowMap.putAll(orderDTO.getData());
+			compAttrVOMap.forEach((attrId, attrVO) -> {
+				dataLowMap.put(attrId, formulaService.getValueByFormula(dataLowMap, attrVO.getComponentRule()));
+			});
+			dataLowMap.forEach((key, value) -> {
+				setValueToOrderDTO(orderDTO, key, value);
+			});
+		}
+	}
+
+	/**
+	 * 鏍￠獙姝ｅ垯琛ㄨ揪寮忔槸鍚︽纭�
+	 *
+	 * @param templateVO 妯℃澘鐨勪俊鎭紝蹇呴』鍖呭惈灞炴�х殑鍐呭
+	 * @param orderDTO   缂栫爜鐢宠鐨勭浉鍏崇殑淇℃伅
+	 */
+	private void checkVerifyOnOrder(CodeClassifyTemplateVO templateVO, CodeOrderDTO orderDTO,Map<String,String> errorMap) {
+		Map<String, CodeClassifyTemplateAttrVO> verifyAttrVOMap = templateVO.getAttributes().stream().filter(s -> StringUtils.isNotBlank(s.getVerifyRule())).collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t));
+		if (!CollectionUtils.isEmpty(verifyAttrVOMap)) {
+			verifyAttrVOMap.forEach((attrId, attrVO) -> {
+				String value = getValueFromOrderDTO(orderDTO, attrId);
+				if (StringUtils.isNotBlank(value) && !value.matches(attrVO.getVerifyRule())) {
+					errorMap.put(orderDTO.getId(),errorMap.getOrDefault(orderDTO.getId(),"")+";灞炴�"+attrVO.getName()+"]鐨勫�间笉绗﹀悎鏍￠獙瑙勫垯鐨勮姹�");
+					//鏍￠獙姝ｅ垯琛ㄨ揪寮�
+					// throw new VciBaseException("灞炴�{0}]鐨勫�间笉绗﹀悎鏍￠獙瑙勫垯鐨勮姹�", new String[]{attrVO.getName()});
+				}
+			});
+		}
+	}
+	/**
+	 * 鏍￠獙鍏抽敭灞炴��
+	 *
+	 * @param classifyFullInfo 鍒嗙被鐨勫叏閮ㄤ俊鎭�
+	 * @param templateVO       妯℃澘鐨勫唴瀹癸紝蹇呴』鍖呭惈妯℃澘灞炴��
+	 * @param orderDTO         缂栫爜鐢宠鐨勭浉鍏崇殑淇℃伅
+	 */
+	private void checkKeyAttrOnOrder(CodeClassifyFullInfoBO classifyFullInfo, CodeClassifyTemplateVO templateVO, CodeOrderDTO orderDTO,Map<String,String> errorMap) {
+		//鍏堣幏鍙栧叧閿睘鎬х殑瑙勫垯锛屼篃鍒╃敤缁ф壙鐨勬柟寮�
+		CodeKeyAttrRepeatVO keyRuleVO = keyRuleService.getRuleByClassifyFullInfo(classifyFullInfo);
+		//娉ㄦ剰鐨勬槸keyRuleVO鍙兘涓虹┖锛岃〃绀轰笉浣跨敤瑙勫垯鎺у埗
+		//鑾峰彇鎵�鏈夌殑鍏抽敭灞炴��
+		Map<String, CodeClassifyTemplateAttrVO> ketAttrMap = templateVO.getAttributes().stream().filter(s -> VciBaseUtil.getBoolean(s.getKeyAttrFlag())).collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t));
+		Map<String, String> conditionMap = new HashMap<>();
+		boolean trimAll = keyRuleVO == null ? false : VciBaseUtil.getBoolean(keyRuleVO.getIgnoreallspaceflag());
+		//鍏ㄩ儴鍘荤┖鐨勪紭鍏堢骇澶т簬鍘荤┖
+		boolean trim = keyRuleVO == null ? false : VciBaseUtil.getBoolean(keyRuleVO.getIgnorespaceflag());
+		boolean ignoreCase = keyRuleVO == null ? false : VciBaseUtil.getBoolean(keyRuleVO.getIgnorecaseflag());
+		boolean ignoreWidth = keyRuleVO == null ? false : VciBaseUtil.getBoolean(keyRuleVO.getIgnorewidthflag());
+		ketAttrMap.forEach((attrId, attrVO) -> {
+			String value = getValueFromOrderDTO(orderDTO, attrId);
+			if (value == null) {
+				value = "";
+			}
+			engineService.wrapperKeyAttrConditionMap(value, keyRuleVO, attrId, trim, ignoreCase, ignoreWidth, trimAll, conditionMap);
+		});
+
+		//娌℃湁闄愬埗鍒嗙被锛屼絾鏄竴涓ā鏉垮彧鍙兘鍦ㄤ竴涓笟鍔＄被鍨嬮噷闈紝鎵�浠ョ洿鎺ユ煡璇㈣繖涓笟鍔＄被鍨嬪嵆鍙�
+
+		if (!CollectionUtils.isEmpty(conditionMap)) {
+			final String[] sql = {"select count(*) from " + VciBaseUtil.getTableName(classifyFullInfo.getTopClassifyVO().getBtmtypeid()) + " where 1 = 1 "};
+			conditionMap.forEach((key, value) -> {
+				sql[0] += " and " + key + " = " + value;
+			});
+			if (StringUtils.isNotBlank(orderDTO.getOid())) {
+				//淇敼鐨勬椂鍊欙紝闇�瑕佹帓闄よ嚜宸�
+				sql[0] += " and oid != '" + orderDTO.getOid() + "'";
+			} else if (StringUtils.isNotBlank(orderDTO.getCopyFromVersion())) {
+				sql[0] += " and oid != '" + orderDTO.getCopyFromVersion() + "'";
+			}
+			sql[0] += " and lastR = '1' and lastV = '1' ";
+			if (commonsMapper.queryCountBySql(sql[0]) > 0) {
+				String ruleInfoMsg = keyRuleVO == null ? "" : "鏌ヨ瑙勫垯锛氬幓闄ょ┖鏍�--{0},蹇界暐澶у皬鍐�--{1},蹇界暐鍏ㄥ崐瑙�--{2},蹇界暐鍏ㄩ儴绌烘牸--{3}";
+				String[] objs = new String[]{trim ? "鏄�" : "鍚�", ignoreCase ? "鏄�" : "鍚�", ignoreWidth ? "鏄�" : "鍚�", trimAll ? "鏄�" : "鍚�"};
+				String defaultValue=";鏍规嵁鎮ㄥ～鍐欑殑鍏抽敭灞炴�х殑鍐呭锛岀粨鍚堝叧閿睘鎬ф煡璇㈣鍒欙紝鍙戠幇杩欎釜鏁版嵁宸茬粡鍦ㄧ郴缁熶腑瀛樺湪浜嗐�傝淇!銆�";
+				String errormsg=defaultValue+ MessageFormat.format(ruleInfoMsg, objs);
+				errorMap.put(orderDTO.getId(),errorMap.getOrDefault(orderDTO.getId(),"")+errormsg);
+				// throw new VciBaseException("鏍规嵁鎮ㄥ～鍐欑殑鍏抽敭灞炴�х殑鍐呭锛岀粨鍚堝叧閿睘鎬ф煡璇㈣鍒欙紝鍙戠幇杩欎釜鏁版嵁宸茬粡鍦ㄧ郴缁熶腑瀛樺湪浜嗐�傝淇!銆�" + ruleInfoMsg, objs);
+			}
+		}
+	}
+	/**
+	 * 鏍￠獙鏋氫妇鐨勫唴瀹�
+	 *
+	 * @param templateVO 妯℃澘鐨勬樉绀哄璞★紝闇�瑕佸寘鍚睘鎬�
+	 * @param orderDTO   缂栫爜鐢宠鐨勪俊鎭�
+	 */
+	private void checkEnumOnOrder(CodeClassifyTemplateVO templateVO, CodeOrderDTO orderDTO,Map<String,String> errorMap) {
+		//濡傛灉鏋氫妇鍙互淇敼锛屽垯涓嶉渶瑕佹牎楠屾槸鍚︾鍚堟灇涓剧殑閫夐」
+		Map<String, CodeClassifyTemplateAttrVO> enumAttrVOMap = templateVO.getAttributes().stream().filter(s -> (StringUtils.isNotBlank(s.getEnumString()) || StringUtils.isNotBlank(s.getEnumId())) && !VciBaseUtil.getBoolean(s.getEnumEditFlag())).collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t));
+		if (!CollectionUtils.isEmpty(enumAttrVOMap)) {
+			enumAttrVOMap.forEach((attrId, attrVO) -> {
+				String value = getValueFromOrderDTO(orderDTO, attrId);
+				if (StringUtils.isNotBlank(value)) {
+					//鏈夊�兼墠鑳芥牎楠�
+					List<KeyValue> comboboxKVs = this.engineService.listComboboxItems(attrVO);
+					if (!comboboxKVs.stream().anyMatch(s -> value.equalsIgnoreCase(s.getKey()))) {
+						errorMap.put(orderDTO.getId(),errorMap.getOrDefault(orderDTO.getId(),"")+";灞炴�с��"+attrVO.getName()+"銆戠殑鍊间笉绗﹀悎鏋氫妇鐨勮姹�");
+						//throw new VciBaseException("灞炴�с�恵0}銆戠殑鍊间笉绗﹀悎鏋氫妇鐨勮姹�", new String[]{attrVO.getName()});
+					}
+				}
+			});
+		}
+	}
+	/**
+	 * 杞崲鏃堕棿鐨勬牸寮�
+	 *
+	 * @param templateVO 妯℃澘鐨勬樉绀哄璞★紝闇�瑕佸寘鍚睘鎬�
+	 * @param orderDTO   缂栫爜鐢宠鐨勪俊鎭�
+	 */
+	private void switchDateAttrOnOrder(CodeClassifyTemplateVO templateVO, CodeOrderDTO orderDTO) {
+		Map<String, CodeClassifyTemplateAttrVO> dateAttrVOMap = templateVO.getAttributes().stream().filter(s -> StringUtils.isNotBlank(s.getCodeDateFormat())).collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t));
+		if (!CollectionUtils.isEmpty(dateAttrVOMap)) {
+			dateAttrVOMap.forEach((attrId, attrVO) -> {
+				String value = getValueFromOrderDTO(orderDTO, attrId);
+				if (StringUtils.isNotBlank(value)) {
+					DateConverter dateConverter = new DateConverter();
+					dateConverter.setAsText(value);
+					value = VciDateUtil.date2Str(dateConverter.getValue(), VciDateUtil.DateTimeMillFormat);
+					setValueToOrderDTO(orderDTO, attrId, value);
+				}
+			});
+		}
+	}
+
+	/**
+	 * 鎷疯礉鏁版嵁鍒癱bo瀵硅薄涓�
+	 *
+	 * @param classifyFullInfo 鍒嗙被鐨勫叏閮ㄤ俊鎭�
+	 * @param cbo              涓氬姟鏁版嵁
+	 * @param orderDTO         缂栫爜鐢宠鐨勪俊鎭�
+	 * @param templateVO       妯℃澘鐨勬樉绀哄璞�
+	 * @param edit             鏄惁涓轰慨鏀�
+	 */
+	private void copyValueToCBO(CodeClassifyFullInfoBO classifyFullInfo, ClientBusinessObject cbo,
+								CodeOrderDTO orderDTO, CodeClassifyTemplateVO templateVO,
+								boolean edit,Map<String,String> errorMap) {
+		String fullPath = "";
+		if (!CollectionUtils.isEmpty(classifyFullInfo.getParentClassifyVOs())) {
+			fullPath = classifyFullInfo.getParentClassifyVOs().stream().sorted(((o1, o2) -> o2.getDataLevel().compareTo(o1.getDataLevel())))
+				.map(CodeClassifyVO::getOid).collect(Collectors.joining("##"));
+		} else {
+			fullPath = classifyFullInfo.getCurrentClassifyVO().getOid();
+		}
+		orderDTO.getData().forEach((key, value) -> {
+			if (!edit || (!engineService.checkUnAttrUnEdit(key) &&
+				!VciQueryWrapperForDO.LC_STATUS_FIELD.equalsIgnoreCase(key))) {
+				try {
+					cbo.setAttributeValue(key, value);
+				} catch (VciBaseException e) {
+					log.error("璁剧疆灞炴�х殑鍊奸敊璇�", e);
+				}
+			}
+		});
+		try {
+			cbo.setAttributeValue(CODE_CLASSIFY_OID_FIELD, classifyFullInfo.getCurrentClassifyVO().getOid());
+			cbo.setAttributeValue(CODE_TEMPLATE_OID_FIELD, templateVO.getOid());
+			cbo.setAttributeValue(CODE_FULL_PATH_FILED, fullPath);
+			if (!edit && StringUtils.isBlank(orderDTO.getLcStatus())) {
+				//鎵剧敓鍛藉懆鏈熺殑璧峰鐘舵�侊紝
+				if (StringUtils.isNotBlank(cbo.getLctid())) {
+					//OsLifeCycleVO lifeCycleVO = lifeCycleService.getLifeCycleById(cbo.getLctid());
+//					if (lifeCycleVO != null) {
+//						cbo.setLcStatus(lifeCycleVO.getStartStatus());
+//					} else {
+						cbo.setLcStatus(CodeDefaultLC.EDITING.getValue());
+//					}
+				} else {
+					cbo.setLcStatus(CodeDefaultLC.EDITING.getValue());
+				}
+
+			}
+			int secret = VciBaseUtil.getInt(cbo.getAttributeValue(SECRET_FIELD));
+			if (secret == 0 || !secretService.checkDataSecret(secret).getData()) {
+				Integer userSecret = VciBaseUtil.getCurrentUserSecret();
+				cbo.setAttributeValue(SECRET_FIELD, String.valueOf((userSecret == null || userSecret == 0) ? UserSecretEnum.NONE.getValue() : userSecret));
+			}
+		} catch (Throwable e) {
+			log.error("璁剧疆榛樿鐨勫睘鎬х殑鍊奸敊璇�", e);
+		}
+	}
+	/**
+	 * 璁剧疆鏂扮殑鍊煎埌鐢宠瀵硅薄涓�
+	 *
+	 * @param orderDTO 缂栫爜鐢宠瀵硅薄
+	 * @param attrId   灞炴�х殑缂栧彿
+	 * @param value    鍊�
+	 */
+	private void setValueToOrderDTO(CodeOrderDTO orderDTO, String attrId, String value) {
+		attrId = attrId.toLowerCase(Locale.ROOT);
+		if (VciQueryWrapperForDO.BASIC_FIELD_MAP.containsKey(attrId)) {
+			WebUtil.setValueToField(WebUtil.getFieldForObject(attrId, orderDTO.getClass()).getName(), orderDTO, value);
+		} else {
+			orderDTO.getData().put(attrId, value);
+		}
+	}
+	/**
+	 * 浠庣紪鐮佺敵璇蜂俊鎭璞′笂鑾峰彇鏌愪釜灞炴�х殑鍊�
+	 *
+	 * @param orderDTO 缂栫爜鐢宠瀵硅薄
+	 * @param attrId   灞炴�х殑缂栧彿
+	 * @return 鍊�
+	 */
+	private String getValueFromOrderDTO(CodeOrderDTO orderDTO, String attrId) {
+		attrId = attrId.toLowerCase(Locale.ROOT);
+		String value = null;
+		if (VciQueryWrapperForDO.BASIC_FIELD_MAP.containsKey(attrId)) {
+			value = WebUtil.getStringValueFromObject(WebUtil.getValueFromField(WebUtil.getFieldForObject(attrId, orderDTO.getClass()).getName(), orderDTO));
+		} else {
+			//璇存槑鏄嚜琛岄厤缃殑
+			//鍓嶇蹇呴』瑕佷紶閫掑皬鍐欑殑灞炴��
+			value = orderDTO.getData().getOrDefault(attrId, "");
+		}
+		return value;
+	}
+	/**
+	 * 澶勭悊鍒嗙被娉ㄥ叆鐨勪俊鎭�
+	 *
+	 * @param templateVO         妯℃澘鐨勬樉绀哄璞★紝蹇呴』瑕佸悗妯℃澘鐨勫睘鎬�
+	 * @param classifyFullInfoBO 鍒嗙被鐨勫叏璺緞
+	 * @param orderDTO           缂栫爜鐢宠鐨勪俊鎭�
+	 */
+	private void switchClassifyLevelOnOrder(CodeClassifyTemplateVO templateVO, CodeClassifyFullInfoBO classifyFullInfoBO, CodeOrderDTO orderDTO,Map<String,String> errorMap) {
+		Map<String, CodeClassifyTemplateAttrVO> classifyAttrVOMap = templateVO.getAttributes().stream().filter(
+			s -> StringUtils.isNotBlank(s.getClassifyInvokeAttr()) && StringUtils.isNotBlank(s.getClassifyInvokeLevel())
+		).collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t));
+		if (classifyFullInfoBO.getTopClassifyVO() == null) {
+			//闇�瑕侀噸鏂版煡璇竴涓嬶紝鍥犱负杩欎釜鏄寚瀹氱殑鍒嗙被杩涙潵鐨�
+
+		}
+		if (!CollectionUtils.isEmpty(classifyAttrVOMap)) {
+			classifyAttrVOMap.forEach((attrId, attrVO) -> {
+				//鍒嗙被娉ㄥ叆鐨勭紪鍙锋垨鑰呭悕绉帮紝
+				//灞傜骇鍖呭惈鎸囧畾灞傚拰鏈�灏忓眰
+				CodeClassifyVO classifyVO = null;
+				if (!CodeLevelTypeEnum.MIN.getValue().equalsIgnoreCase(attrVO.getClassifyInvokeLevel()) && !"min".equalsIgnoreCase(attrVO.getClassifyInvokeLevel())) {
+					//鎸囧畾浜嗗眰绾х殑
+					//娉ㄦ剰锛屽洜涓烘煡璇笂绾у垎绫诲嚭鏉ョ殑灞傜骇鏄�掑簭鐨勶紝鍗抽《灞傝妭鐐规槸鏈�澶х殑鍊�
+					List<CodeClassifyVO> classifyVOS = classifyFullInfoBO.getParentClassifyVOs().stream().sorted(((o1, o2) -> o2.getDataLevel().compareTo(o1.getDataLevel()))).collect(Collectors.toList());
+					int level = VciBaseUtil.getInt(attrVO.getClassifyInvokeLevel());
+					if (classifyVOS.size() >= level && level > 0) {
+						classifyVO = classifyVOS.get(level - 1);
+					}
+				} else {
+					//褰撳墠鐨勫垎绫�
+					classifyVO = classifyFullInfoBO.getCurrentClassifyVO();
+				}
+				if (classifyVO == null) {
+					//璇存槑灞傜骇鏈夎
+					errorMap.put(orderDTO.getId(),errorMap.getOrDefault(orderDTO.getId(),"")+";鍒嗙被鏍戜笂娌℃湁灞傜骇[" + attrVO.getClassifyInvokeLevel() + "]");
+					//orderDTO.getData().put(attrId, "鍒嗙被鏍戜笂娌℃湁灞傜骇[" + attrVO.getClassifyinvokelevel() + "]");
+					// classifyVO = classifyFullInfoBO.getCurrentClassifyVO();
+				} else {
+					Map<String, String> classifyDataMap = VciBaseUtil.objectToMapString(classifyVO);
+					String value = classifyDataMap.getOrDefault(attrVO.getClassifyInvokeAttr(), "");
+					orderDTO.getData().put(attrId, value);
+				}
+			});
+		}
+	}
+	/***
+	 *
+	 * @param codeClassifyVO
+	 * @param templateVO
+	 * @param codeDataMap
+	 * @param codeSystemObjectMap
+	 * @param codeOrderDTOList
+	 * @param errorMap
+	 * @return
+	 */
+	private void   getCodeOrderDTOs(CodeClassifyVO codeClassifyVO,CodeClassifyTemplateVO templateVO,Map<String ,RowDatas>codeDataMap,Map<String, ClientBusinessObject> codeSystemObjectMap,List<CodeOrderDTO> codeOrderDTOList,Map<String,String> errorMap){
+		codeDataMap.keySet().forEach(code->{
+			RowDatas rowDatas=codeDataMap.get(code);
+			Map<String, String> data= rowDatas.getFiledValue();
+			CodeOrderDTO orderDTO = new CodeOrderDTO();
+			if(codeSystemObjectMap.containsKey(code)){
+				ClientBusinessObject sysDataObject= codeSystemObjectMap.get(code);
+				orderDTO.setCodeClassifyOid(codeClassifyVO.getOid());//鍒嗙被涓婚敭
+				orderDTO.setOid(sysDataObject.getOid());//鏁版嵁oid
+				orderDTO.setLcStatus(rowDatas.getStatus());//鐘舵��
+				orderDTO.setId(code);
+				orderDTO.setTs(sysDataObject.getTs());
+				orderDTO.setBtmname(codeClassifyVO.getBtmname());//涓氬姟绫诲瀷
+				orderDTO.setDescription("闆嗘垚璋冪敤:鏇存柊");//鏁版嵁鎻忚堪
+				if(data.containsKey("name")){
+					String name=data.get("name");
+					orderDTO.setName(name);//鍚嶇О灞炴�у��
+				}
+				orderDTO.setData(data);//璁剧疆鏁版嵁
+				orderDTO.setSecDTOList(null);//鍒嗙被鐮佹
+				orderDTO.setEditInProcess(false);//鏄惁鍦ㄦ祦绋嬩腑
+				orderDTO.setTemplateOid(templateVO.getOid());
+			}else{
+				errorMap.put("code","缂栫爜涓猴細銆�"+code+"銆戠殑鏁版嵁鍦ㄧ郴缁熶腑涓嶅瓨鍦�");
+			}
+			codeOrderDTOList.add(orderDTO);
+		});
 	}
 
 	/**
@@ -129,6 +2504,1094 @@
 	}
 
 	/**
+	 * 妫�鏌ョ爜娈电殑闀垮害鏄惁绗﹀悎瑕佹眰
+	 * @param cboList 鏁版嵁
+	 * @param classifyVOMap 鍒嗙被鏄犲皠
+	 * @param ruleVOMap 瑙勫垯瀵硅薄
+	 * @param ruleOidMap 鍒嗙被鍖呭惈瑙勫垯
+	 * @param errorMap 閿欒鐨勪俊鎭�
+	 * @param ruleRowIndexMap 瑙勫垯鍖呭惈鐨勮鍙凤紝key鏄鍒欎富閿紝value鏄寘鍚殑鍏ㄩ儴琛屽彿
+	 */
+	private void checkSecLengthInHistory(List<ClientBusinessObject> cboList,Map<String,CodeClassifyVO> classifyVOMap,Map<String,CodeRuleVO> ruleVOMap,
+										 Map<String/**鍒嗙被涓婚敭**/,String/**瑙勫垯涓婚敭**/> ruleOidMap,Map<String,String> errorMap,Map<String,List<String>> ruleRowIndexMap){
+
+		cboList.stream().forEach(cbo-> {
+			String rowIndex = cbo.getAttributeValue(IMPORT_ROW_INDEX);
+			String secLength = cbo.getAttributeValue(CODE_SEC_LENGTH_FIELD);
+			//鎵惧垎绫�
+			String classifyOid = cbo.getAttributeValue(CODE_CLASSIFY_OID_FIELD);
+			CodeClassifyVO classifyVO = classifyVOMap.get(classifyOid);
+			if (classifyVO != null) {
+				//2#2#4#1杩欐牱鐨勬柟寮�
+				CodeRuleVO ruleVO = ruleVOMap.getOrDefault(ruleOidMap.get(classifyVO.getOid()), null);
+				if(ruleVO!=null){
+					String[] secValues = secLength.split("#");
+					//鎬婚暱搴﹀拰缂栫爜鐨勯暱搴�
+					String code = cbo.getAttributeValue(CODE_FIELD);
+					if(code.length() != Arrays.stream(secValues).mapToInt(s->VciBaseUtil.getInt(s)).sum()){
+						errorMap.put(rowIndex,errorMap.getOrDefault(rowIndex,"") + ";鐮佹瀹藉害涓庣郴缁熶腑鐨勭紪鐮佽鍒欎笉鍚�" );
+					}else if(secValues.length != ruleVO.getSecVOList().size()){
+						errorMap.put(rowIndex,errorMap.getOrDefault(rowIndex,"") + ";鐮佹瀹藉害涓庣郴缁熶腑鐨勭紪鐮佽鍒欎笉鍚�" );
+					} else {
+						//姣忎竴涓暱搴﹂兘涓嶈兘瓒呰繃鐮佹鐨�
+						boolean fined = false;
+						for (int j = 0; j < ruleVO.getSecVOList().size(); j++) {
+							CodeBasicSecVO secVO = ruleVO.getSecVOList().get(j);
+							String length= secValues[j];
+							if(StringUtils.isNotBlank(secVO.getCodeSecLength())&&VciBaseUtil.getInt(length)>VciBaseUtil.getInt(secVO.getCodeSecLength())){
+								errorMap.put(rowIndex,errorMap.getOrDefault(rowIndex,"") + ";鐮佹瀹藉害涓庣郴缁熶腑鐨勭紪鐮佽鍒欎笉鍚�" );
+								fined = true;
+								break;
+							}
+						}
+						/**for (int i = 0; i < secValues.length; i++) {
+						 for (int j = 0; j < ruleVO.getSecVOList().size(); j++) {
+						 CodeBasicSecVO secVO = ruleVO.getSecVOList().get(j);
+						 if (VciBaseUtil.getInt(secValues[i]) > VciBaseUtil.getInt(secVO.getCodeSecLength())) {
+						 errorMap.put(rowIndex,errorMap.getOrDefault(rowIndex,"") + ";鐮佹瀹藉害涓庣郴缁熶腑鐨勭紪鐮佽鍒欎笉鍚�" );
+						 fined = true;
+						 break;
+						 }
+						 }
+						 if(fined){
+						 break;
+						 }
+						 }***/
+						if(!fined){
+							//鏆傛椂涓嶅彇娴佹按鐨勫唴瀹癸紝鍥犱负璋冪敤produceCode鐨勬椂鍊欏幓澶勭悊
+							List<String> rowIndexList = ruleRowIndexMap.getOrDefault(ruleVO.getOid(), new ArrayList<>());
+							rowIndexList.add(rowIndex);
+							ruleRowIndexMap.put(ruleVO.getOid(),rowIndexList);
+						}
+					}
+				}else{
+					errorMap.put(rowIndex,errorMap.getOrDefault(rowIndex,"") + ";鍒嗙被娌℃湁璁剧疆缂栫爜瑙勫垯" );
+				}
+			}
+		});
+	}
+	/**
+	 * excel杞崲涓篶bo鐨勫璞�
+	 * @param classifyFullInfo 鍒嗙被鐨勫叏閮ㄤ俊鎭�
+	 * @param fieldIndexMap 瀛楁鐨勪綅缃�
+	 * @param rowDataList excel閲岀殑琛屾暟鎹�
+	 * @param templateVO 妯℃澘鐨勬樉绀哄璞�
+	 * @param cboList 鏁版嵁鐨勫垪琛�
+	 * @param fullPath 鍏ㄨ矾寰�
+	 * @param operation 鎿嶄綔绫诲瀷
+	 * @param errorMap 閿欒淇℃伅璁板綍
+	 */
+	private void excelToCbo(CodeClassifyFullInfoBO classifyFullInfo,List<String> titleRowData,Map<Integer,String> fieldIndexMap,List<RowDatas> rowDataList,
+							CodeClassifyTemplateVO templateVO,List<ClientBusinessObject> cboList,
+							String fullPath,boolean isProcess,String operation,Map<String,String> errorMap,Map<String,String> codeOidToSystemOidMap){
+		rowDataList.stream().forEach(rowData -> {
+			String oid=rowData.getOid();
+			String rowNumber=rowData.getRowIndex();
+			ClientBusinessObject cbo = new ClientBusinessObject();
+			DefaultAttrAssimtUtil.addDefaultAttrAssimt(cbo, classifyFullInfo.getTopClassifyVO().getBtmtypeid());
+			rowData.getData().forEach((index,value)->{
+				String field = fieldIndexMap.get(index);
+				if(StringUtils.isBlank(field)){
+					errorMap.put(rowNumber,"灞炴�э細銆�" +titleRowData.get(index)+ "銆戝湪绯荤粺涓笉瀛樺湪");
+				}
+				try {
+					cbo.setAttributeValueWithNoCheck(field,value);
+					if(WebUtil.isDefaultField(field)){
+						WebUtil.setValueToField(field, cbo, value);
+					}
+				} catch (VciBaseException e) {
+					log.error("璁剧疆灞炴�х殑鍊奸敊璇�",e);
+					errorMap.put(rowNumber,"灞炴�э細銆�" +titleRowData.get(index)+ "銆戝湪绯荤粺涓笉瀛樺湪");
+				}
+			});
+			try {
+				cbo.setAttributeValue(IMPORT_ROW_INDEX,rowData.getRowIndex());
+				cbo.setAttributeValue(CODE_TEMPLATE_OID_FIELD,templateVO.getOid());
+				if(operation.equals("create")){
+					log.info("鍒嗙被瀵硅薄锛�"+classifyFullInfo.getCurrentClassifyVO());
+					log.info("codeClassoid:"+classifyFullInfo.getCurrentClassifyVO().getOid());
+					cbo.setAttributeValue(CODE_CLASSIFY_OID_FIELD,classifyFullInfo.getCurrentClassifyVO().getOid());
+					cbo.setAttributeValue(CODE_FULL_PATH_FILED,fullPath);
+					int secret = VciBaseUtil.getInt(cbo.getAttributeValue(SECRET_FIELD));
+					if(secret == 0 || !secretService.checkDataSecret(secret).getData() ){
+						Integer userSecret = VciBaseUtil.getCurrentUserSecret();
+						String secretValue= String.valueOf((userSecret==null || userSecret ==0)? UserSecretEnum.NONE.getValue():userSecret);
+						cbo.setAttributeValue(SECRET_FIELD,secretValue);
+					}
+					if(rowData.getStatus().equals(CodeDefaultLC.DISABLE.getValue())){//鍋滅敤
+						cbo.setLcStatus(CodeDefaultLC.DISABLE.getValue());
+					}else if(rowData.getStatus().equals(CodeDefaultLC.EDITING.getValue())){//缂栬緫
+						cbo.setLcStatus(CodeDefaultLC.EDITING.getValue());
+					}else if(rowData.getStatus().equals(CodeDefaultLC.AUDITING.getValue())) {//瀹℃壒涓�
+						cbo.setLcStatus(CodeDefaultLC.AUDITING.getValue());
+					}else if(rowData.getStatus().equals(CodeDefaultLC.TASK_BACK.getValue())){//鍥炴敹
+						cbo.setLcStatus(CodeDefaultLC.TASK_BACK.getValue());
+					}else{
+						cbo.setLcStatus(CodeDefaultLC.RELEASED.getValue());//鍙戝竷
+					}
+					/**  if(!isProcess){
+					 cbo.setLcStatus(CodeDefaultLC.RELEASED.getValue());
+					 }else {
+					 if(rowData.getStatus().equals(CodeDefaultLC.DISABLE.getValue())){//鍋滅敤
+					 cbo.setLcStatus(CodeDefaultLC.DISABLE.getValue());
+					 }else if(rowData.getStatus().equals(CodeDefaultLC.EDITING.getValue())){//缂栬緫
+					 cbo.setLcStatus(CodeDefaultLC.EDITING.getValue());
+					 }else {//鍙戝竷
+					 cbo.setLcStatus(CodeDefaultLC.RELEASED.getValue());
+					 }
+					 }***/
+					cbo.setCreator(rowData.getCreator());
+					cbo.setLastModifier(rowData.getEditor()==null?"":rowData.getEditor());
+				}else if(operation.equals("update")){
+					//姝ゆ椂杩樻病鏈夎浆鎹㈣矾寰�
+					//cbo.setAttributeValue(CODE_FULL_PATH_FILED, childOidPathMap.getOrDefault(rowData.getData().getOrDefault(CODE_CLASSIFY_OID_FIELD,""),fullPath));
+					if(rowData.getStatus().equals(CodeDefaultLC.DISABLE.getValue())){//鍋滅敤
+						cbo.setLcStatus(CodeDefaultLC.DISABLE.getValue());
+					}else if(rowData.getStatus().equals(CodeDefaultLC.RELEASED.getValue())){//鍙戝竷
+						cbo.setLcStatus(CodeDefaultLC.RELEASED.getValue());
+					}else if(rowData.getStatus().equals(CodeDefaultLC.EDITING.getValue())){//缂栬緫
+						cbo.setLcStatus(CodeDefaultLC.EDITING.getValue());
+					}else if(rowData.getStatus().equals(CodeDefaultLC.AUDITING.getValue())) {//瀹℃壒涓�
+						cbo.setLcStatus(CodeDefaultLC.AUDITING.getValue());
+					}else if(rowData.getStatus().equals(CodeDefaultLC.TASK_BACK.getValue())){//鍥炴敹
+						cbo.setLcStatus(CodeDefaultLC.TASK_BACK.getValue());
+					}
+					cbo.setLastModifier(rowData.getEditor() == null ? "" : rowData.getEditor());//淇敼鑰�
+				}else if(operation.equals("delete")){
+					if(rowData.getStatus().equals(CodeDefaultLC.TASK_BACK.getValue())){//鍥炴敹
+						cbo.setLcStatus(CodeDefaultLC.TASK_BACK.getValue());
+					}else{
+						cbo.setLcStatus(CodeDefaultLC.DISABLE.getValue());//鍋滅敤
+					}
+				}
+
+
+			}catch (Throwable e){
+				log.error("璁剧疆榛樿鐨勫睘鎬х殑鍊奸敊璇�",e);
+				if(e instanceof  VciBaseException){
+					errorMap.put(rowNumber,"璁剧疆榛樿鐨勫睘鎬х殑鍊奸敊璇�"+((VciBaseException) e).getMessage());
+				}else{
+					errorMap.put(rowNumber,"璁剧疆榛樿鐨勫睘鎬х殑鍊奸敊璇�"+e.getMessage());
+				}
+
+			}finally {
+				codeOidToSystemOidMap.put(cbo.getOid(),oid);
+			}
+			cbo.setDescription("");
+			cboList.add(cbo);
+		});
+
+	}
+	/**
+	 * excel杞崲涓篶bo鐨勫璞�
+	 * @param classifyFullInfo 鍒嗙被鐨勫叏閮ㄤ俊鎭�
+	 * @param codeImprotDataVO: 鍒嗙被瀵瑰簲鐨勬暟鎹�
+	 * @param cboList 鏁版嵁鐨勫垪琛�
+	 * @param newCode 鏄惁涓烘壒閲忕敵璇�
+	 */
+	private void excelToCbo(CodeClassifyFullInfoBO classifyFullInfo,CodeImprotDataVO codeImprotDataVO,List<ClientBusinessObject> cboList, boolean newCode){
+		String fullPath = getFullPath(classifyFullInfo);
+		codeImprotDataVO.getDatas().stream().forEach(rowData -> {
+			ClientBusinessObject cbo=new ClientBusinessObject();
+			DefaultAttrAssimtUtil.addDefaultAttrAssimt(cbo, classifyFullInfo.getTopClassifyVO().getBtmtypeid());
+			rowData.forEach((field,value)->{
+				try {
+					cbo.setAttributeValueWithNoCheck(field,value);
+					if(WebUtil.isDefaultField(field)){
+						WebUtil.setValueToField(field, cbo, value);
+					}
+				} catch (VciBaseException e) {
+					log.error("璁剧疆灞炴�х殑鍊奸敊璇�",e);
+				}
+			});
+			try {
+				cbo.setAttributeValue(CODE_TEMPLATE_OID_FIELD,codeImprotDataVO.getTemplateOid());
+				cbo.setAttributeValue(IMPORT_ROW_INDEX,rowData.get(IMPORT_ROW_INDEX));
+				if(newCode){
+					cbo.setAttributeValue(CODE_CLASSIFY_OID_FIELD,classifyFullInfo.getCurrentClassifyVO().getOid());
+					cbo.setAttributeValue(CODE_FULL_PATH_FILED,fullPath);
+					//cbo.setLcStatus(CodeDefaultLC.EDITING.getValue());
+					int secret = VciBaseUtil.getInt(cbo.getAttributeValue(SECRET_FIELD));
+					if(secret == 0 || !secretService.checkDataSecret(secret).getData() ){
+						Integer userSecret = VciBaseUtil.getCurrentUserSecret();
+						cbo.setAttributeValue(SECRET_FIELD,String.valueOf((userSecret==null || userSecret ==0)? UserSecretEnum.NONE.getValue():userSecret));
+					}
+				}else{
+					//姝ゆ椂杩樻病鏈夎浆鎹㈣矾寰�
+					//cbo.setAttributeValue(CODE_FULL_PATH_FILED, childOidPathMap.getOrDefault(rowData.getData().getOrDefault(CODE_CLASSIFY_OID_FIELD,""),fullPath));
+					cbo.setLcStatus(CodeDefaultLC.RELEASED.getValue());
+				}
+				rowData.put("oid",cbo.getOid());
+
+			}catch (Throwable e){
+				log.error("璁剧疆榛樿鐨勫睘鎬х殑鍊奸敊璇�",e);
+			}
+			cboList.add(cbo);
+		});
+
+	}
+	/**
+	 * excel杞崲涓篶bo鐨勫璞�
+	 * @param classifyFullInfo 鍒嗙被鐨勫叏閮ㄤ俊鎭�
+	 * @param fieldIndexMap 瀛楁鐨勪綅缃�
+	 * @param rowDataList excel閲岀殑琛屾暟鎹�
+	 * @param templateVO 妯℃澘鐨勬樉绀哄璞�
+	 * @param cboList 鏁版嵁鐨勫垪琛�
+	 * @param fullPath 鍏ㄨ矾寰�
+	 * @param newCode 鏄惁涓烘壒閲忕敵璇�
+	 */
+	private void excelToCbo(CodeClassifyFullInfoBO classifyFullInfo,Map<Integer,String> fieldIndexMap,List<SheetRowData> rowDataList,
+							CodeClassifyTemplateVO templateVO,List<ClientBusinessObject> cboList,
+							String fullPath,boolean newCode){
+		rowDataList.stream().forEach(rowData -> {
+			ClientBusinessObject cbo=new ClientBusinessObject();
+			 DefaultAttrAssimtUtil.addDefaultAttrAssimt(cbo, classifyFullInfo.getTopClassifyVO().getBtmtypeid());
+			rowData.getData().forEach((index,value)->{
+				String field = fieldIndexMap.get(index);
+				if (StringUtils.isBlank(field)) {
+					throw new VciBaseException("绗�" + (index + 1) + "鍒楃殑鏍囬鍦ㄧ郴缁熶腑涓嶅瓨鍦�");
+				}
+				try {
+					cbo.setAttributeValueWithNoCheck(field, value);
+					if (WebUtil.isDefaultField(field)) {
+						WebUtil.setValueToField(field, cbo, value);
+					}
+				} catch (VciBaseException e) {
+					log.error("璁剧疆灞炴�х殑鍊奸敊璇�", e);
+				}
+			});
+			try {
+				cbo.setAttributeValue(CODE_TEMPLATE_OID_FIELD,templateVO.getOid());
+				cbo.setAttributeValue(IMPORT_ROW_INDEX,rowData.getRowIndex());
+				if(newCode){
+					cbo.setAttributeValue(CODE_CLASSIFY_OID_FIELD,classifyFullInfo.getCurrentClassifyVO().getOid());
+					cbo.setAttributeValue(CODE_FULL_PATH_FILED,fullPath);
+					//cbo.setLcStatus(CodeDefaultLC.EDITING.getValue());
+					int secret = VciBaseUtil.getInt(cbo.getAttributeValue(SECRET_FIELD));
+					if(secret == 0 || !secretService.checkDataSecret(secret).getData() ){
+						Integer userSecret = VciBaseUtil.getCurrentUserSecret();
+						cbo.setAttributeValue(SECRET_FIELD,String.valueOf((userSecret==null || userSecret ==0)? UserSecretEnum.NONE.getValue():userSecret));
+					}
+				}else{
+					//姝ゆ椂杩樻病鏈夎浆鎹㈣矾寰�
+					//cbo.setAttributeValue(CODE_FULL_PATH_FILED, childOidPathMap.getOrDefault(rowData.getData().getOrDefault(CODE_CLASSIFY_OID_FIELD,""),fullPath));
+					cbo.setLcStatus(CodeDefaultLC.RELEASED.getValue());
+				}
+
+			}catch (Throwable e){
+				log.error("璁剧疆榛樿鐨勫睘鎬х殑鍊奸敊璇�",e);
+			}
+			cboList.add(cbo);
+		});
+
+	}
+
+	/**
+	 * 妫�鏌ユ牎楠岃鍒欐病鏈夐�氳繃鐨勫唴瀹�
+	 * @param attrVOS 闇�瑕佹牎楠岀殑灞炴��
+	 * @param dataList 鏁版嵁鐨勫垪琛�
+	 * @param errorMap 閿欒鐨勪俊鎭槧灏�
+	 * @return 鏍￠獙涓嶉�氳繃鐨勮鏁�
+	 */
+	private void batchCheckVerifyOnOrder(Collection<CodeClassifyTemplateAttrVO> attrVOS, List<ClientBusinessObject> dataList,Map<String,String> errorMap) {
+		Map<String, CodeClassifyTemplateAttrVO> verifyAttrVOMap = attrVOS.stream().filter(s -> StringUtils.isNotBlank(s.getVerifyRule()) && StringUtils.isBlank(s.getComponentRule())
+			&&StringUtils.isBlank(s.getClassifyInvokeAttr())
+		).collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t));
+		if(!CollectionUtils.isEmpty(verifyAttrVOMap)){
+			Map<String/**琛屽彿**/,List<String>/**鏍￠獙涓嶉�氳繃鐨勫睘鎬�**/> unPassCheckMap = new HashMap<>();
+			verifyAttrVOMap.forEach((attrId,attrVO)->{
+				dataList.stream().forEach(cbo -> {
+					String value = cbo.getAttributeValue(attrId);
+					if(StringUtils.isNotBlank(value) && !value.matches(attrVO.getVerifyRule())){
+						String rowIndex = cbo.getAttributeValue(IMPORT_ROW_INDEX);
+						List<String> unPassAttrs = unPassCheckMap.getOrDefault(rowIndex, new ArrayList<>());
+						unPassAttrs.add(attrVO.getName());
+						unPassCheckMap.put(rowIndex,unPassAttrs);
+					}
+				});
+			});
+			if(!CollectionUtils.isEmpty(unPassCheckMap)){
+				unPassCheckMap.forEach((rowIndex,unPassAttrs)->{
+					errorMap.put(rowIndex,";灞炴�" + unPassAttrs.stream().collect(Collectors.joining(",")) + "]鍐呭涓嶇鍚堟牎楠岃鍒欑殑瑕佹眰");
+				});
+			}
+		}
+	}
+	/**
+	 * 鎵归噺杞崲鏃堕棿閮戒负鎸囧畾鐨勬牸寮�
+	 * @param attrVOS 妯℃澘灞炴��
+	 * @param cboList 鏁版嵁鐨勫垪琛�
+	 * @param errorMap 閿欒鐨勪俊鎭�
+	 */
+	private void batchSwitchDateAttrOnOrder(Collection<CodeClassifyTemplateAttrVO> attrVOS,List<ClientBusinessObject> cboList,Map<String,String> errorMap){
+		Map<String, CodeClassifyTemplateAttrVO> dateAttrVOMap =attrVOS.stream().filter(s ->
+			StringUtils.isNotBlank(s.getCodeDateFormat()) && VciBaseUtil.getBoolean(s.getCodeDateFormat()) && StringUtils.isBlank(s.getComponentRule())
+				&& StringUtils.isBlank(s.getClassifyInvokeAttr())
+		).collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t));
+		if(!CollectionUtils.isEmpty(dateAttrVOMap)) {
+			dateAttrVOMap.forEach((attrId, attrVO) -> {
+				cboList.stream().forEach(cbo -> {
+					String value = cbo.getAttributeValue(attrId);
+					if (value == null) {
+						value = "";
+					}
+					if (StringUtils.isNotBlank(value)) {
+						boolean formated = false;
+						if(StringUtils.isNotBlank(attrVO.getCodeDateFormat())){
+							try {
+								Date date = VciDateUtil.str2Date(value, attrVO.getCodeDateFormat());
+								if(date!=null){
+									cbo.setAttributeValue(attrId,value);
+									formated = true;
+								}
+							} catch (Exception e) {
+								//璇存槑涓嶆槸杩欎釜鏍煎紡
+							}
+						}
+						if(!formated) {
+							try {
+								DateConverter dateConverter = new DateConverter();
+								dateConverter.setAsText(value);
+								value = VciDateUtil.date2Str(dateConverter.getValue(), VciDateUtil.DateTimeMillFormat);
+								cbo.setAttributeValue(attrId,value);
+							}catch (Throwable e){
+								//杞崲涓嶄簡
+								String rowIndex = cbo.getAttributeValue(IMPORT_ROW_INDEX);
+								errorMap.put(rowIndex,errorMap.getOrDefault(rowIndex,"") + ";灞炴�" + attrVO.getName() + "]鏃堕棿鏍煎紡涓嶆纭�" );
+							}
+						}
+					}
+				});
+			});
+		}
+	}
+
+	/**
+	 * 绯荤粺妯℃澘涓粯璁ゅ�艰缃�
+	 * @param attrVOS 妯℃澘灞炴��
+	 * @param dataList excel鐨勬暟鎹唴瀹�
+	 */
+	private void batchSwitchAttrDefault(Collection<CodeClassifyTemplateAttrVO> attrVOS,List<ClientBusinessObject> dataList) {
+		Map<String, CodeClassifyTemplateAttrVO> dateAttrVOMap = attrVOS.stream().filter(s -> StringUtils.isNotBlank(s.getDefaultValue())).collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t));
+		if(!CollectionUtils.isEmpty(dateAttrVOMap)) {
+			dateAttrVOMap.forEach((attrId, attrVO) -> {
+				String defaultValue = attrVO.getDefaultValue();
+				dataList.stream().forEach(cbo -> {
+					String dataValue= cbo.getAttributeValue(attrId);
+					if(StringUtils.isBlank(dataValue)){
+						dataValue=defaultValue;
+					}
+					try {
+						cbo.setAttributeValue(attrId, dataValue);
+					}catch (Throwable e){
+						log.error("璁剧疆灞炴�х殑閿欒",e);
+					}
+				});
+			});
+		}
+	}
+
+	/**
+	 * 杞Щboolean鍨嬬殑灞炴��
+	 * @param attrVOS 灞炴�х殑瀵硅薄
+	 * @param dataList 鏁版嵁
+	 */
+	private void reSwitchBooleanAttrOnOrder(Collection<CodeClassifyTemplateAttrVO> attrVOS,List<ClientBusinessObject> dataList){
+		Map<String, CodeClassifyTemplateAttrVO> booleanAttrMap = attrVOS.stream().filter(
+			s -> VciFieldTypeEnum.VTBoolean.name().equalsIgnoreCase(s.getAttributeDataType())
+		).collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t));
+		if (!CollectionUtils.isEmpty(booleanAttrMap)) {
+			booleanAttrMap.forEach((attrId, attrVO) -> {
+				dataList.stream().forEach(cbo -> {
+					String text = cbo.getAttributeValue(attrId);
+					try {
+						if (BooleanEnum.TRUE.getValue().equalsIgnoreCase(text) || "鏄�".equalsIgnoreCase(text)) {
+							cbo.setAttributeValue(attrId, BooleanEnum.TRUE.getValue());
+						} else {
+							cbo.setAttributeValue(attrId, BooleanEnum.FASLE.getValue());
+						}
+					}catch (Throwable e){
+
+					}
+				});
+			});
+		}
+	}
+
+	/**
+	 * 澶勭悊缁勫悎瑙勫垯
+	 * @param attrVOS 妯℃澘灞炴��
+	 * @param dataList excel鐨勬暟鎹唴瀹�
+	 */
+	private void batchSwitchComponentAttrOnOrder(Collection<CodeClassifyTemplateAttrVO> attrVOS,List<ClientBusinessObject> dataList) {
+		Map<String, CodeClassifyTemplateAttrVO> dateAttrVOMap = attrVOS.stream().filter(s -> StringUtils.isNotBlank(s.getComponentRule())).collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t));
+		if(!CollectionUtils.isEmpty(dateAttrVOMap)) {
+			dateAttrVOMap.forEach((attrId, attrVO) -> {
+				dataList.stream().forEach(cbo -> {
+					//浠巈xcel涓婃妸灞炴�ц浆鎹负map
+					Map<String,String> thisRowDataMap = new HashMap<>();
+					copyValueToMapFromCbos(cbo,thisRowDataMap);
+					//缁勫悎鍐呭
+					String value = formulaService.getValueByFormula(thisRowDataMap,attrVO.getComponentRule());
+					if(value == null){
+						value = "";
+					}
+					try {
+						cbo.setAttributeValue(attrId, value);
+					}catch (Throwable e){
+						log.error("璁剧疆灞炴�х殑閿欒",e);
+					}
+				});
+			});
+		}
+	}
+
+	/**
+	 * 杞崲鍙傜収鐨勫��
+	 * @param attrVOS 灞炴�х殑鏄剧ず瀵硅薄
+	 * @param dataList 鏁版嵁鍒楄〃
+	 * @param errorMap 閿欒鐨勪俊鎭�
+	 */
+	private void batchSwitchReferAttrOnOrder(Collection<CodeClassifyTemplateAttrVO> attrVOS,List<ClientBusinessObject> dataList,Map<String,String> errorMap){
+		Map<String, CodeClassifyTemplateAttrVO> referAttrVOMap = attrVOS.stream().filter(
+			s -> (StringUtils.isNotBlank(s.getReferBtmId()) || StringUtils.isNotBlank(s.getReferConfig()))
+		).collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t));
+		if(!CollectionUtils.isEmpty(referAttrVOMap)){
+			Map<String/**琛ㄦ牸鍜屽�肩殑灞炴��**/,Map<String/**鏄剧ず灞炴�х殑鍊�**/,List<String>/**琛ㄦ牸閲岀殑鍊�**/>> linkValueMap = new HashMap<>();
+			referAttrVOMap.forEach((attrId,attrVO)->{
+				dataList.stream().forEach(cbo -> {
+					String text = cbo.getAttributeValue(attrId);
+					if(StringUtils.isNotBlank(text)){
+						UIFormReferVO referVO = getReferVO(attrVO);
+						String valueField = getValueField(referVO);
+						String showText = getTextField(referVO);
+						String tableAndAttr = VciBaseUtil.getTableName(referVO.getReferType()) + "#" + valueField;
+						Map<String, List<String>> showTextMap = linkValueMap.getOrDefault(tableAndAttr, new HashMap<>());
+						List<String> textList = showTextMap.getOrDefault(showText, new ArrayList<>());
+						if(!textList.contains(text)) {
+							textList.add(text);
+						}
+						showTextMap.put(showText,textList);
+						linkValueMap.put(tableAndAttr,showTextMap);
+					}
+				});
+			});
+			if(!CollectionUtils.isEmpty(linkValueMap)){
+				//闇�瑕侀�愪釜琛ㄧ殑鍊煎瓧娈碉紝閫愪釜鏌ヨ
+				Map<String/**琛ㄦ牸鍜屽�煎睘鎬�**/,Map<String/**鏄剧ず灞炴��**/, Map<String/**鍊�**/,String/**鏄剧ず鐨勫��**/>>> linkCboMap = new HashMap<>();
+				linkValueMap.forEach((tableAndAttr,showValueMap)->{
+					String[] split = tableAndAttr.split("#");
+					String table = split[0];
+					String valueField = split[1].toLowerCase(Locale.ROOT);
+					Map<String,Map<String,String>> dataMap = new HashMap<>();
+					showValueMap.forEach((showText,valueList)->{
+						Map<String,String> valueOidTextMap = new HashMap<>();
+						List<List<String>> valueCollections = VciBaseUtil.switchListForOracleIn(valueList);
+						String sql = "select " + valueField + "," + showText.toLowerCase(Locale.ROOT) +" from " + table + "  where " + showText + " in (%s)";
+						valueCollections.stream().forEach(values->{
+							List<Map<String,String>> dataMapList = commonsMapper.queryByOnlySqlForMap(String.format(sql, VciBaseUtil.toInSql(values.toArray(new String[0]))));
+							List<ClientBusinessObject> cbos=	ChangeMapTOClientBusinessObjects(dataMapList);
+							if(!CollectionUtils.isEmpty(cbos)){
+								valueOidTextMap.putAll(cbos.stream().collect(Collectors.toMap(s->s.getAttributeValue(valueField),t->t.getAttributeValue(showText))));
+							}
+						});
+						dataMap.put(showText,valueOidTextMap);
+					});
+					linkCboMap.put(tableAndAttr,dataMap);
+				});
+				referAttrVOMap.forEach((attrId,attrVO)->{
+					dataList.stream().forEach(cbo -> {
+						String text = cbo.getAttributeValue(attrId);
+						if (StringUtils.isNotBlank(text)) {
+							UIFormReferVO referVO = getReferVO(attrVO);
+							String valueField = getValueField(referVO);
+							String showText = getTextField(referVO);
+							String tableAndAttr = VciBaseUtil.getTableName(referVO.getReferType()) + "#" + valueField;
+							if(!linkCboMap.containsKey(tableAndAttr)){
+								String rowIndex = cbo.getAttributeValue(IMPORT_ROW_INDEX);
+								errorMap.put(rowIndex,errorMap.getOrDefault(rowIndex,"") + ";鍙傛暟灞炴�" + attrVO.getName() + "]鐨勫�煎湪绯荤粺涓笉瀛樺湪" );
+
+							}else{
+								Map<String, Map<String, String>> dataMap = linkCboMap.get(tableAndAttr);
+								if(!dataMap.containsKey(showText)){
+									String rowIndex = cbo.getAttributeValue(IMPORT_ROW_INDEX);
+									errorMap.put(rowIndex,errorMap.getOrDefault(rowIndex,"") + ";鍙傛暟灞炴�" + attrVO.getName() + "]鐨勫�煎湪绯荤粺涓笉瀛樺湪" );
+								}else{
+									Map<String, String> data = dataMap.get(showText);
+									final boolean[] fined = {false};
+									data.forEach((key,value)->{
+										if(value.equalsIgnoreCase(text)){
+											fined[0] = true;
+											try {
+												cbo.setAttributeValue(attrId, key);
+											}catch (Throwable e){
+
+											}
+										}
+									});
+									if(!fined[0]){
+										String rowIndex = cbo.getAttributeValue(IMPORT_ROW_INDEX);
+										errorMap.put(rowIndex,errorMap.getOrDefault(rowIndex,"") + ";鍙傛暟灞炴�" + attrVO.getName() + "]鐨勫�煎湪绯荤粺涓笉瀛樺湪" );
+									}
+								}
+							}
+						}
+					});
+				});
+			}
+		}
+
+	}
+	/**
+	 * 鎵归噺妫�鏌ヤ紒涓氱紪鐮佹槸鍚﹀瓨鍦�
+	 * @param templateVO 妯℃澘鐨勬樉绀哄璞�
+	 * @param cboList 鏁版嵁鐨勫垪琛�
+	 * @param errorMap 閿欒鐨勪俊鎭�
+	 */
+	private void batchCheckIdExistOnOrder(CodeClassifyTemplateVO templateVO,List<ClientBusinessObject> cboList,Map<String ,String> errorMap) throws Throwable{
+		List<String> existIds = new ArrayList<>();
+		String tableName ="";
+		try {
+			R<BtmTypeVO> r = btmTypeClient.getAllAttributeByBtmId(templateVO.getBtmTypeId());
+			if(r.getCode()!=200) {
+				throw new Throwable(r.getMsg());
+			}
+			BtmTypeVO btmTypeVO = r.getData();
+			if (btmTypeVO == null) {
+				throw new Throwable("鏍规嵁涓氬姟绫诲瀷鏈煡璇㈠埌涓氬姟绫诲瀷瀵硅薄锛�");
+			}
+			tableName = btmTypeVO.getTableName();
+			if (StringUtils.isBlank(tableName)) {
+				throw new Throwable("鏍规嵁涓氬姟绫诲瀷鏈煡璇㈠埌涓氬姟绫诲瀷鐩稿叧鑱旂殑琛�");
+			}
+		}catch (Throwable e){
+			throw e;
+		}
+		String finalTableName = tableName;
+		VciBaseUtil.switchCollectionForOracleIn(cboList).stream().forEach(cbos -> {
+			Map<String, String> conditionMap = new HashMap<>();
+			conditionMap.put("id", QueryOptionConstant.IN + "(" + VciBaseUtil.toInSql(cbos.stream().map(s -> s.getId()).collect(Collectors.toSet()).toArray(new String[0])) + ")");
+
+			StringBuffer sb=new StringBuffer();
+			sb.append(" select id from ");
+			sb.append(finalTableName);
+			sb.append(" where 1=1 ");
+			sb.append(" and id in (");
+			sb.append(VciBaseUtil.toInSql(cbos.stream().map(s -> s.getId()).collect(Collectors.toSet()).toArray(new String[0])));
+			sb.append(")");
+			List<String> idList= commonsMapper.selectById(sb.toString());
+			//涓氬姟鏁版嵁濡傛灉鐮佸�煎洖鏀朵細鐩存帴鍒犻櫎鏁版嵁锛屾墍浠ヨ繖閲岀洿鎺ュ垽鏂槸鍚﹀瓨鍦ㄥ嵆鍙�
+			existIds.addAll(Optional.ofNullable(idList).orElseGet(() -> new ArrayList<>()).stream().map(s -> s.toLowerCase(Locale.ROOT)).collect(Collectors.toList()));
+		});
+		if(!CollectionUtils.isEmpty(existIds)){
+			String idFieldName = templateVO.getAttributes().stream().filter(s -> VciQueryWrapperForDO.ID_FIELD.equalsIgnoreCase(s.getId())).findFirst().orElseGet(() -> new CodeClassifyTemplateAttrVO()).getName();
+			if(StringUtils.isBlank(idFieldName)){
+				idFieldName = "浼佷笟缂栫爜";
+			}
+			String finalIdFieldName = idFieldName;
+			cboList.stream().forEach(cbo->{
+				String id = cbo.getId();
+				if(StringUtils.isBlank(id)){
+					id = cbo.getAttributeValue("id");
+				}
+				if(existIds.contains(id)){
+					String rowIndex = cbo.getAttributeValue(IMPORT_ROW_INDEX);
+					String msg = errorMap.getOrDefault(rowIndex, "");
+					msg+=";" + finalIdFieldName + "鐨勫�煎湪绯荤粺涓凡缁忓瓨鍦�";
+					errorMap.put(rowIndex,msg);
+				}
+			});
+		}
+	}
+	/***
+	 * 鏍￠獙鍒嗙被瀵瑰簲鐨勬ā鏉夸俊鎭�
+	 * @param titleRowData
+	 * @param sheetDataSetList
+	 * @param shetNumber
+	 * @param pathMap
+	 * @param errorMap
+	 * @return
+	 * @throws Throwable
+	 */
+	private LinkedList<CodeClassifyTemplateVO> checkSamesTemplate(List<String> titleRowData,  List<SheetDataSet> sheetDataSetList,int shetNumber,Map<String/**璺緞**/, CodeClassifyVO> pathMap,Map<String,String>errorMap) throws Throwable {
+		Map<String,String>pathOidMap =new HashMap<>();
+		Map<String,String> templateIdRowIndex=new HashedMap();
+		SheetDataSet dataSet=  sheetDataSetList.get(shetNumber);
+		LinkedHashMap<String,CodeClassifyTemplateVO> codeClassifyTemplateVOMap=new LinkedHashMap <String,CodeClassifyTemplateVO>();
+		for (int i=0; i<titleRowData.size();i++){
+			String title= titleRowData.get(i);
+			if(title.equals("鍒嗙被璺緞")) {
+				int finalI = i;
+				dataSet.getRowData().stream().forEach(sheetRowData -> {
+					String Path = sheetRowData.getData().get(finalI);
+					String rowIndex=sheetRowData.getRowIndex();
+					if(StringUtils.isBlank(Path)){
+						Path= "#current#";
+					}
+					CodeClassifyTemplateVO newTemplateVO=new CodeClassifyTemplateVO();
+					String templateOid="";
+					if(pathOidMap.containsKey(Path)){
+						templateOid= pathOidMap.get(Path) ;
+						newTemplateVO=codeClassifyTemplateVOMap.get(templateOid);
+					}else{
+						if (pathMap.containsKey(Path)) {
+							CodeClassifyVO codeClassifyVO = pathMap.get(Path);
+							newTemplateVO = engineService.getUsedTemplateByClassifyOid(codeClassifyVO.getOid());
+							if (newTemplateVO != null) {
+								templateOid = newTemplateVO.getOid();
+							} else {
+								errorMap.put(rowIndex, "绗�" + rowIndex + "琛岋紝鍒嗙被璺緞鏈煡璇㈠埌鐩稿簲鐨勫垎绫绘ā鏉�");
+							}
+						} else {
+							errorMap.put(rowIndex, "绗�" + rowIndex + "琛岋紝鍒嗙被璺緞鏈煡璇㈠埌鐩稿簲鐨勫垎绫�");
+						}
+
+					}
+					pathOidMap.put(Path, templateOid);
+					codeClassifyTemplateVOMap.put(templateOid, newTemplateVO);
+					templateIdRowIndex.put(templateOid, templateIdRowIndex.getOrDefault(templateOid, "") + "锛�" +rowIndex );
+				});
+				break;
+			}
+		}
+		LinkedList<CodeClassifyTemplateVO> codeClassifyTemplateVOList=new LinkedList<>();
+		StringBuffer sb=new StringBuffer();
+		codeClassifyTemplateVOMap.keySet().forEach(tempateOid->{
+			String templateOidInExcel="";
+			String tempateName="";
+			CodeClassifyTemplateVO t= codeClassifyTemplateVOMap.get(tempateOid);
+			codeClassifyTemplateVOList.add(t);
+			if(!CollectionUtils.isEmpty(sheetDataSetList)
+				&& sheetDataSetList.size()>1 && !CollectionUtils.isEmpty(sheetDataSetList.get(sheetDataSetList.size()-1).getColName())){
+				List<SheetRowData>  rowData=  sheetDataSetList.get(sheetDataSetList.size()-1).getRowData();
+				templateOidInExcel=rowData.get(shetNumber).getData().get(0);
+				tempateName=rowData.get(shetNumber).getData().get(2);
+				//templateOidInExcel = sheetDataSetList.get(sheetDataSetList.size()-1).getColName().get(sheetDataSetList.size()-i);
+			}
+			if(StringUtils.isBlank(templateOidInExcel) || !templateOidInExcel.equalsIgnoreCase(tempateOid)){
+				sb.append("妯℃澘銆�"+tempateName+"銆戜腑绗�"+templateIdRowIndex.get(tempateOid)+"琛屾暟鎹笉灞炰簬褰撳墠妯℃澘鐨勬暟鎹紝璇锋牳瀵�!");
+			}
+		});
+		if(StringUtils.isNotBlank(sb.toString())){
+			throw  new Throwable(sb.toString());
+		}
+		if(codeClassifyTemplateVOList.size()>1){
+			String message="妯℃澘銆�"+dataSet.getSheetName()+"銆戞牴鎹垎绫昏矾寰勫垽鏂紝鍒嗙被瀛樺湪澶氫釜妯℃澘";
+
+			throw  new Throwable(message);
+		}
+		if(codeClassifyTemplateVOList.size()==0){
+			String message="妯℃澘銆�"+dataSet.getSheetName()+"銆戞牴鎹暟鎹垎绫昏矾寰勫垽鏂紝鏈尮閰嶅埌瀵瑰簲妯℃澘";
+			throw  new Throwable(message);
+		}
+		return codeClassifyTemplateVOList ;
+	}
+	/**
+	 * 浠庡睘鎬т笂鑾峰彇鍙傜収鐨勫唴瀹�
+	 * @param attrVO 灞炴�х殑淇℃伅
+	 * @return 鍙傜収鐨勫唴瀹�
+	 */
+	private UIFormReferVO getReferVO(CodeClassifyTemplateAttrVO attrVO){
+		UIFormReferVO referVO = null;
+		if(StringUtils.isNotBlank(attrVO.getReferConfig())){
+			referVO = JSONObject.parseObject(attrVO.getReferConfig(),UIFormReferVO.class);
+		}else{
+			referVO = new UIFormReferVO();
+			referVO.setReferType(attrVO.getReferBtmId());
+			referVO.setValueField(VciQueryWrapperForDO.OID_FIELD);
+			referVO.setTextField("name");
+		}
+		return referVO;
+	}
+
+	/**
+	 * 鑾峰彇鍙傜収涓殑鍊肩殑瀛楁
+	 * @param referVO 鍙傜収鐨勫璞�
+	 * @return 榛樿涓篛id锛屾湁澶氫釜鐨勬椂鍊欙紝鑾峰彇绗竴涓�
+	 */
+	private String getValueField(UIFormReferVO referVO){
+		String showText = referVO.getValueField();
+		if(StringUtils.isBlank(showText)){
+			return "oid";
+		}
+		if(showText.contains(",")){
+			//闃叉涓囦竴鏈夊涓紝鐪嬬湅鏈夋病鏈塷id
+			List<String> strings = VciBaseUtil.str2List(showText);
+			if(strings.contains("oid")){
+				showText = "oid";
+			}else{
+				showText = strings.get(0);
+			}
+		}
+		return showText;
+	}
+
+	/**
+	 * 鑾峰彇鍙傜収涓殑鏄剧ず鍐呭鐨勫瓧娈�
+	 * @param referVO 鍙傜収鐨勫璞�
+	 * @return 榛樿涓簄ame锛屾湁澶氫釜鐨勬椂鍊欙紝鑾峰彇绗竴涓�
+	 */
+	private String getTextField(UIFormReferVO referVO){
+		String showText = referVO.getTextField();
+		if(StringUtils.isBlank(showText)){
+			return "name";
+		}
+		if(showText.contains(",")){
+			//闃叉涓囦竴鏈夊涓紝鐪嬬湅鏈夋病鏈塶ame
+			List<String> strings = VciBaseUtil.str2List(showText);
+			if(strings.contains("name")){
+				showText = "name";
+			}else{
+				showText = strings.get(0);
+			}
+		}
+		return showText;
+	}
+	/**
+	 * 澶勭悊鏋氫妇鐨勬樉绀哄璞�
+	 * @param attrVOS 妯℃澘灞炴��
+	 * @param dataList excel鐨勬暟鎹唴瀹�
+	 * @param errorMap 閿欒淇℃伅鐨勬槧灏�
+	 */
+	private void batchSwitchEnumAttrOnOrder(Collection<CodeClassifyTemplateAttrVO> attrVOS,List<ClientBusinessObject> dataList,
+											Map<String,String> errorMap ) {
+		Map<String, CodeClassifyTemplateAttrVO> dateAttrVOMap = attrVOS.stream().filter(
+			s -> (StringUtils.isNotBlank(s.getEnumString()) || StringUtils.isNotBlank(s.getEnumId()))
+		).collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t));
+		if (!CollectionUtils.isEmpty(dateAttrVOMap)) {
+			dateAttrVOMap.forEach((attrId, attrVO) -> {
+				dataList.stream().forEach(cbo -> {
+					String text = cbo.getAttributeValue(attrId);
+					if(StringUtils.isNotBlank(text)){
+						List<KeyValue> valueList = engineService.listComboboxItems(attrVO);
+						boolean fined = false;
+						for (int i = 0; i < valueList.size(); i++) {
+							KeyValue keyValue = valueList.get(i);
+							//if(keyValue.getValue().equalsIgnoreCase(text)){
+							if(keyValue.getValue().equalsIgnoreCase(text)||keyValue.getKey().equalsIgnoreCase(text)){
+								try {
+									cbo.setAttributeValue(attrId, keyValue.getKey());
+								}catch (Throwable e){
+									log.error("璁剧疆灞炴�у嚭閿�");
+								}
+								fined = true;
+								break;
+							}
+						}
+						if(!fined){
+							String rowIndex = cbo.getAttributeValue(IMPORT_ROW_INDEX);
+							errorMap.put(rowIndex,errorMap.getOrDefault(rowIndex,"") + ";灞炴�" + attrVO.getName() + "]鐨勫�间笉绗﹀悎涓嬫媺鐨勮姹�");
+						}
+					}
+				});
+			});
+		}
+	}
+
+	/**
+	 * 鎵归噺鏍￠獙鏁版嵁鐨勪俊鎭�
+	 * @param templateVO 妯℃澘鐨勬樉绀哄璞�
+	 * @param cboList 鏁版嵁鐨勫唴瀹�
+	 */
+	private void batchCheckRequiredAttrOnOrder(CodeClassifyTemplateVO templateVO,List<ClientBusinessObject> cboList,Map<String,String> errorMap){
+		Map<String, CodeClassifyTemplateAttrVO> requiredAttrMap = templateVO.getAttributes().stream().filter(s ->
+			VciBaseUtil.getBoolean(s.getRequireFlag()) && StringUtils.isBlank(s.getComponentRule()) && StringUtils.isBlank(s.getClassifyInvokeLevel())//涓嶈兘鏄粍鍚堢殑鍜屽垎绫绘敞鍏ョ殑
+		).collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t));
+		//涓嶮dmEngineServiceImpl閲岄潰鐨刢heckRequiredAttrOnOrder 閫昏緫搴旇鐩镐技
+		if(!CollectionUtils.isEmpty(requiredAttrMap)) {
+			Set<String> nullRowIndex = cboList.stream().filter(cbo -> requiredAttrMap.keySet().stream().anyMatch(attrId -> StringUtils.isBlank(cbo.getAttributeValue(attrId)))).map(cbo -> cbo.getAttributeValue(IMPORT_ROW_INDEX)).collect(Collectors.toSet());
+			if(!CollectionUtils.isEmpty(nullRowIndex)){
+				String checkAttr = requiredAttrMap.values().stream().map(CodeClassifyTemplateAttrVO::getName).collect(Collectors.joining(","));
+				nullRowIndex.stream().forEach(rowIndex->{
+					errorMap.put(rowIndex,errorMap.getOrDefault(rowIndex,"") + ";鏍￠獙瑙勫垯涓嶉�氳繃锛屾湁鏍￠獙鐨勫睘鎬т负" + checkAttr);
+				});
+			}
+		}
+	}
+	/**
+	 * 澶勭悊鍒嗙被娉ㄥ叆
+	 * @param attrVOS 妯℃澘灞炴��
+	 * @param dataList excel鐨勬暟鎹唴瀹�
+	 * @param classifyFullInfo 鍒嗙被鐨勫叏璺緞
+	 */
+	private void batchSwitchClassifyAttrOnOrder(Collection<CodeClassifyTemplateAttrVO> attrVOS,List<ClientBusinessObject> dataList,
+												CodeClassifyFullInfoBO classifyFullInfo,boolean isImPort) {
+		Map<String, CodeClassifyTemplateAttrVO> dateAttrVOMap = attrVOS.stream().filter(
+			s -> StringUtils.isNotBlank(s.getClassifyInvokeAttr()) && StringUtils.isNotBlank(s.getClassifyInvokeAttr())
+		).collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t));
+		Map<String,CodeClassifyFullInfoBO> classifyFullInfoMap=new HashMap<>();
+		classifyFullInfoMap.put(classifyFullInfo.getCurrentClassifyVO().getOid(),classifyFullInfo);
+		if (!CollectionUtils.isEmpty(dateAttrVOMap)) {
+			dataList.stream().forEach(cbo -> {
+				dateAttrVOMap.forEach((attrId, attrVO) -> {
+					//鍒嗙被娉ㄥ叆鐨勭紪鍙锋垨鑰呭悕绉帮紝
+					//灞傜骇鍖呭惈鎸囧畾灞傚拰鏈�灏忓眰
+					CodeClassifyVO classifyVO = null;
+					if(!CodeLevelTypeEnum.MIN.getValue().equalsIgnoreCase(attrVO.getClassifyInvokeLevel()) && !"min".equalsIgnoreCase(attrVO.getClassifyInvokeLevel())) {
+						//鎸囧畾浜嗗眰绾х殑
+						//娉ㄦ剰锛屽洜涓烘煡璇笂绾у垎绫诲嚭鏉ョ殑灞傜骇鏄�掑簭鐨勶紝鍗抽《灞傝妭鐐规槸鏈�澶х殑鍊�
+						if(isImPort){
+							if(!classifyFullInfoMap.containsKey(cbo.getAttributeValue(CODE_CLASSIFY_OID_FIELD))) {
+								CodeClassifyFullInfoBO currentClassifyFullInfo = classifyService.getClassifyFullInfo(cbo.getAttributeValue(CODE_CLASSIFY_OID_FIELD));
+								classifyFullInfoMap.put(currentClassifyFullInfo.getCurrentClassifyVO().getOid(), currentClassifyFullInfo);
+							}
+						}
+						CodeClassifyFullInfoBO newClassifyFullInfo= classifyFullInfoMap.get(cbo.getAttributeValue(CODE_CLASSIFY_OID_FIELD));
+						List<CodeClassifyVO> classifyVOS = newClassifyFullInfo.getParentClassifyVOs().stream().sorted(((o1, o2) -> o2.getDataLevel().compareTo(o1.getDataLevel()))).collect(Collectors.toList());
+						int level = VciBaseUtil.getInt(attrVO.getClassifyInvokeLevel());
+						if (classifyVOS.size()>=level && level > 0 ) {
+							classifyVO = classifyVOS.get(level-1);
+						}
+					}else{
+						//褰撳墠鐨勫垎绫�
+						classifyVO = classifyFullInfo.getCurrentClassifyVO();
+					}
+					try {
+						if (classifyVO == null) {
+							//璇存槑灞傜骇鏈夎
+							cbo.setAttributeValue(attrId, "鍒嗙被鏍戜笂娌℃湁灞傜骇[" + attrVO.getClassifyInvokeLevel() + "]");
+						} else {
+							Map<String, String> classifyDataMap = VciBaseUtil.objectToMapString(classifyVO);
+							String value = classifyDataMap.getOrDefault(attrVO.getClassifyInvokeAttr(), "");
+							cbo.setAttributeValue(attrId, value);
+						}
+					} catch (Throwable e) {
+						log.error("璁剧疆灞炴�ч敊璇�", e);
+					}
+				});
+			});
+		}
+	}
+	/**
+	 * 鏍￠獙鍏抽敭灞炴��
+	 * @param classifyFullInfo 鍒嗙被鐨勫叏閮ㄤ俊鎭�
+	 * @param templateVO 妯℃澘鐨勫唴瀹癸紝蹇呴』鍖呭惈妯℃澘灞炴��
+	 * @param cboList 鎵归噺鐨勬暟鎹�
+	 */
+	private CodeImportResultVO batchCheckKeyAttrOnOrder(CodeClassifyFullInfoBO classifyFullInfo, CodeClassifyTemplateVO templateVO,
+														List<ClientBusinessObject> cboList) {
+		//涓嶮dmEngineServiceImpl閲岀殑checkKeyAttrOnOrder鐩镐技
+		//鍏堣幏鍙栧叧閿睘鎬х殑瑙勫垯锛屼篃鍒╃敤缁ф壙鐨勬柟寮�
+		CodeKeyAttrRepeatVO keyRuleVO = keyRuleService.getRuleByClassifyFullInfo(classifyFullInfo);
+		//娉ㄦ剰鐨勬槸keyRuleVO鍙兘涓虹┖锛岃〃绀轰笉浣跨敤瑙勫垯鎺у埗
+		//鑾峰彇鎵�鏈夌殑鍏抽敭灞炴��
+		Map<String/**灞炴�х殑缂栧彿**/, CodeClassifyTemplateAttrVO> ketAttrMap = templateVO.getAttributes().stream().filter(s -> VciBaseUtil.getBoolean(s.getKeyAttrFlag())).collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t));
+
+		boolean trimAll =keyRuleVO ==null?false: VciBaseUtil.getBoolean(keyRuleVO.getIgnoreallspaceflag());
+		//鍏ㄩ儴鍘荤┖鐨勪紭鍏堢骇澶т簬鍘荤┖
+		boolean trim =keyRuleVO ==null?false:  VciBaseUtil.getBoolean(keyRuleVO.getIgnorespaceflag());
+		boolean ignoreCase = keyRuleVO ==null?false: VciBaseUtil.getBoolean(keyRuleVO.getIgnorecaseflag());
+		boolean ignoreWidth = keyRuleVO ==null?false: VciBaseUtil.getBoolean(keyRuleVO.getIgnorewidthflag());
+
+		//1. 鎴戜滑闇�瑕佸厛鍒ゆ柇excel瀵煎叆鐨勫唴瀹规槸鍚︽纭�
+		CodeImportResultVO resultVO = new CodeImportResultVO();
+		resultVO.setKeyAttrRuleInfo(String.format(keyRuleVO ==null?"":"鏌ヨ瑙勫垯锛氬幓闄ょ┖鏍�--{0},蹇界暐澶у皬鍐�--{1},蹇界暐鍏ㄥ崐瑙�--{2},蹇界暐鍏ㄩ儴绌烘牸--{3}",
+			new String[]{trim?"鏄�":"鍚�",ignoreCase?"鏄�":"鍚�",ignoreWidth?"鏄�":"鍚�",trimAll?"鏄�":"鍚�"}));
+		resultVO.setSelfRepeatRowIndexList(getSelfRepeatRowIndex(ketAttrMap,cboList,keyRuleVO));
+		if(!CollectionUtils.isEmpty(resultVO.getSelfRepeatRowIndexList())){
+			//鎴戜滑绉婚櫎鏈韩閲嶅鐨勬暟鎹�
+			cboList = cboList.stream().filter(s->!resultVO.getSelfRepeatRowIndexList().contains(s.getAttributeValue(IMPORT_ROW_INDEX))).collect(Collectors.toList());
+		}
+		//2.鍒ゆ柇鍏抽敭灞炴�у湪绯荤粺閲屾槸鍚﹂噸澶�
+		//鍥犱负鏁版嵁閲忓緢澶э紝鎵�浠ュ緱鎯冲姙娉曞苟琛�
+		//SessionInfo sessionInfo = VciBaseUtil.getCurrentUserSessionInfo();
+		Map<String,List<BaseModel>> indexTODataMap=new HashMap<>();
+		List<ClientBusinessObject> repeatDataMap = cboList.parallelStream().filter(cbo -> {
+			//姣忚閮藉緱鏌ヨ.濡傛灉鍏朵腑鍑虹幇浜嗛敊璇紝鎴戜滑灏辩洿鎺ユ姏鍑哄紓甯革紝鍏朵綑鐨勬樉绀�
+			//VciBaseUtil.setCurrentUserSessionInfo(sessionInfo);
+			Map<String, String> conditionMap = new HashMap<>();
+			ketAttrMap.forEach((attrId, attrVO) -> {
+				String value =cbo.getAttributeValue(attrId.toLowerCase(Locale.ROOT));
+				if (value == null) {
+					value = "";
+				}
+				value= value.replace(REQUIRED_CHAR,SPECIAL_CHAR);
+				engineService.wrapperKeyAttrConditionMap(value, keyRuleVO, attrId, trim, ignoreCase, ignoreWidth, trimAll, conditionMap);
+			});
+			if (!CollectionUtils.isEmpty(ketAttrMap)) {
+				CodeTemplateAttrSqlBO sqlBO = engineService.getSqlByTemplateVO(classifyFullInfo.getTopClassifyVO().getBtmtypeid(), templateVO, conditionMap, null);
+				boolean isKeyCheck= commonsMapper.queryCountBySql(sqlBO.getSqlCount()) > 0;
+				if(isKeyCheck){
+					List<Map<String,String>> newDataList=  commonsMapper.queryByOnlySqlForMap(sqlBO.getSqlUnPage());
+					//List<ClientBusinessObject> newCboList=	ChangeMapTOClientBusinessObjects(newDataList);
+					List<BaseModel> newCboList=new ArrayList<>();
+					newDataList.stream().forEach(stringStringMap -> {
+						BaseModel baseModel=new BaseModel();
+						DefaultAttrAssimtUtil.copplyDefaultAttrAssimt(stringStringMap,baseModel);
+						newCboList.add(baseModel);
+					});
+					if(!CollectionUtils.isEmpty(newCboList)) {
+						indexTODataMap.put(cbo.getAttributeValue(IMPORT_ROW_INDEX), newCboList);
+					}
+				}
+				return isKeyCheck;
+			}else{
+				return false;
+			}
+		}).collect(Collectors.toList());
+		if(!CollectionUtils.isEmpty(repeatDataMap)){
+			resultVO.setKeyAttrRepeatRowIndexList(repeatDataMap.stream().map(s->s.getAttributeValue(IMPORT_ROW_INDEX)).collect(Collectors.toSet()));
+		}
+		resultVO.setIndexTODataMap(indexTODataMap);
+		//resultVO.setSuccess(true);
+		return resultVO;
+	}
+
+	/**
+	 * 妫�鏌ュ垎绫荤殑璺緞鏄惁瀛樺湪
+	 * @param cboList 涓氬姟鏁版嵁
+	 * @param errorMap 閿欒淇℃伅
+	 * @param pathMap 璺緞鍜屽垎绫荤殑鏄犲皠
+	 */
+	private void checkClassifyPathInHistory(List<ClientBusinessObject> cboList,
+											Map<String,String> errorMap,     Map<String/**璺緞**/,CodeClassifyVO> pathMap,
+											Map<String/**涓婚敭**/, String/**璺緞**/> childOidPathMap) {
+		cboList.parallelStream().forEach(cbo -> {
+			String classifyPath = cbo.getAttributeValue(CODE_CLASSIFY_OID_FIELD);
+			//濡傛灉path涓虹┖锛屽垯琛ㄧず鏄鍏ュ綋鍓嶅垎绫�
+			if(StringUtils.isBlank(classifyPath)){
+				classifyPath = "#current#";
+			}
+			if ( !pathMap.containsKey(classifyPath)) {
+				String row_index = cbo.getAttributeValue(IMPORT_ROW_INDEX);
+				errorMap.put(row_index,errorMap.getOrDefault(row_index,"") + ";鍒嗙被璺緞涓嶅瓨鍦�");
+			} else {
+				//杞竴涓嬪垎绫荤殑涓婚敭
+				try {
+					String classifyOid = pathMap.get(classifyPath).getOid();
+					cbo.setAttributeValueWithNoCheck(CODE_CLASSIFY_OID_FIELD, classifyOid);
+					cbo.setAttributeValue(CODE_FULL_PATH_FILED, childOidPathMap.getOrDefault(classifyOid,classifyPath));
+				} catch (VciBaseException e) {
+					log.error("璁剧疆灞炴�х殑閿欒", e);
+				}
+			}
+		});
+	}
+
+	/**
+	 * 妫�鏌ュ垎绫讳互鍙婂瓙鍒嗙被鏄惁閮芥湁缂栫爜瑙勫垯
+	 * @param classifyVOMap 鍒嗙被鐨勬樉绀哄璞℃槧灏�
+	 * @param ruleOidMap 瑙勫垯鐨勪富閿槧灏�
+	 * @param unExistRuleClassifyOidList 涓嶅瓨鍦ㄧ紪鐮佽鍒欑殑鍒嗙被鐨勪富閿�
+	 */
+	private void checkRuleOidInHistory( Map<String/**涓婚敭**/,CodeClassifyVO> classifyVOMap,  Map<String/**鍒嗙被涓婚敭**/,String/**瑙勫垯涓婚敭**/> ruleOidMap,
+										List<String> unExistRuleClassifyOidList   ){
+		if(!CollectionUtils.isEmpty(classifyVOMap)){
+			classifyVOMap.values().parallelStream().forEach(classifyVO->{
+				if(StringUtils.isNotBlank(classifyVO.getCoderuleoid())){
+					ruleOidMap.put(classifyVO.getOid(),classifyVO.getCoderuleoid());
+				}else{
+					//閫掑綊鎵句笂绾�
+					List<String> ruleOidList = new ArrayList<>();
+					recursionRule(classifyVOMap,classifyVO.getParentcodeclassifyoid(),ruleOidList);
+					if(!CollectionUtils.isEmpty(ruleOidList)){
+						ruleOidMap.put(classifyVO.getOid(),ruleOidList.get(0));
+					}else{
+						unExistRuleClassifyOidList.add(classifyVO.getOid());
+					}
+				}
+			});
+		}
+		log.info(";;;;");
+	}
+	/**
+	 * 閫掑綊鎵剧紪鐮佽鍒�
+	 * @param classifyVOMap 鍒嗙被鐨勬樉绀哄璞℃槧灏�
+	 * @param classifyOid 鍒嗙被鐨勪富閿�
+	 * @param ruleOidList 瑙勫垯鐨勪富閿甽ist
+	 */
+	private void recursionRule(Map<String, CodeClassifyVO> classifyVOMap,String classifyOid,List<String> ruleOidList){
+		if(classifyVOMap.containsKey(classifyOid)){
+			CodeClassifyVO classifyVO = classifyVOMap.get(classifyOid);
+			if(StringUtils.isNotBlank(classifyVO.getCoderuleoid())){
+				ruleOidList.add(classifyVO.getCoderuleoid());
+				return;
+			}else{
+				recursionRule(classifyVOMap,classifyVO.getParentcodeclassifyoid(),ruleOidList);
+			}
+		}else{
+			Map<String, CodeClassifyVO> parentClassifyVOMap=new HashMap<>();
+			CodeClassifyVO codeClassifyVO= this.classifyService.getObjectByOid(classifyOid);
+			parentClassifyVOMap.put(codeClassifyVO.getOid(),codeClassifyVO);
+			recursionRule(parentClassifyVOMap,codeClassifyVO.getOid(),ruleOidList);
+		}
+	}
+
+	/**
+	 * 鑾峰彇瀛愬垎绫荤殑璺緞
+	 * @param classifyFullInfo 鍒嗙被鍏ㄩ儴淇℃伅
+	 * @param fullPath 鍒嗙被鐨勫叏璺緞
+	 * @return 瀛愬垎绫荤殑璺緞锛宬ey鏄垎绫荤殑涓婚敭
+	 */
+	private Map<String/**鍒嗙被鐨勪富閿�**/,String/**鍒嗙被璺緞**/> getChildClassifyPathMap(CodeClassifyFullInfoBO classifyFullInfo,String fullPath){
+		List<CodeClassifyVO> childPathVOs = classifyService.listChildrenClassify(classifyFullInfo.getCurrentClassifyVO().getOid(), true, VciQueryWrapperForDO.OID_FIELD, true);
+		Map<String/**鍒嗙被鐨勪富閿�**/,String/**鍒嗙被鐨勪富閿�**/> childOidPathMap = new ConcurrentHashMap<>();
+		if(!CollectionUtils.isEmpty(childPathVOs)){
+			childPathVOs.parallelStream().forEach(childPath->{
+				// String thisClassifyPath = fullPath + "##" + childPath.getPath().replace("#" + classifyFullInfo.getCurrentClassifyVO().getOid() + "#","").replace("#","##");
+				List<String> list=Arrays.asList(childPath.getPath().split("#"));
+				List<String> newPahtList=  list.stream().sorted(Comparator.comparing(s -> s,Comparator.reverseOrder())).collect(Collectors.toList());
+				String thisClassifyPath=StringUtils.join(newPahtList,"##")+fullPath;
+				childOidPathMap.put(childPath.getOid(),thisClassifyPath);
+			});
+		}
+		return childOidPathMap;
+	}
+
+
+	/**
+	 * 鑾峰彇瀵煎叆鐨勫唴瀹逛腑鍏抽敭灞炴�ч噸澶嶇殑琛屽彿
+	 * @param ketAttrMap 鍏抽敭灞炴�х殑鏄犲皠
+	 * @param dataList 瀵煎叆鐨勬暟鎹�
+	 * @param keyRuleVO 鍏抽敭灞炴�ф帶鍒惰鍒�
+	 * @return 閲嶅鐨勮鍙�
+	 */
+	private Set<String> getSelfRepeatRowIndex(Map<String/**灞炴�х殑缂栧彿**/, CodeClassifyTemplateAttrVO> ketAttrMap,
+											  List<ClientBusinessObject> dataList,CodeKeyAttrRepeatVO keyRuleVO){
+		Set<String> selfRepeatRowIndexList = new CopyOnWriteArraySet<>();
+		boolean trimAll =keyRuleVO ==null?false: VciBaseUtil.getBoolean(keyRuleVO.getIgnoreallspaceflag());
+		//鍏ㄩ儴鍘荤┖鐨勪紭鍏堢骇澶т簬鍘荤┖
+		boolean trim =keyRuleVO ==null?false:  VciBaseUtil.getBoolean(keyRuleVO.getIgnorespaceflag());
+		boolean ignoreCase = keyRuleVO ==null?false: VciBaseUtil.getBoolean(keyRuleVO.getIgnorecaseflag());
+		boolean ignoreWidth = keyRuleVO ==null?false: VciBaseUtil.getBoolean(keyRuleVO.getIgnorewidthflag());
+		//蹇呴』灏嗗睘鎬ф寜鐓ч『搴忔帓搴忓ソ
+		List<CodeClassifyTemplateAttrVO> attrVOList = ketAttrMap.values().stream().sorted(((o1, o2) -> o1.getOrderNum().compareTo(o2.getOrderNum()))).collect(Collectors.toList());
+		Map<String/**琛屽彿**/,String/**鍏抽敭灞炴�х殑缁勫悎鍐呭**/> rowIndexKeyStringMap = new HashMap<>();
+		dataList.parallelStream().forEach(cbo-> {
+			String rowIndex = cbo.getAttributeValue(IMPORT_ROW_INDEX);
+			StringBuilder sb = new StringBuilder();
+			for (int i = 0; i < attrVOList.size(); i++) {
+				CodeClassifyTemplateAttrVO attrVO = attrVOList.get(i);
+				String attrId = attrVO.getId().toLowerCase(Locale.ROOT);
+				String value = cbo.getAttributeValue( attrId);
+				if (value == null) {
+					value = "";
+				}
+				if(trim){
+					value = value.trim();
+				}
+				if(trimAll){
+					value = value.replace(" ","");
+				}
+				if(ignoreCase){
+					value = value.toLowerCase(Locale.ROOT);
+				}
+				if(ignoreWidth){
+					value = VciBaseUtil.toDBC(value);
+				}
+				sb.append(value).append("${ks}");
+			}
+			String keyString = sb.toString();
+			if(rowIndexKeyStringMap.containsValue(keyString) && StringUtils.isNotBlank(keyString)){
+				selfRepeatRowIndexList.add(rowIndex);
+			}else {
+				rowIndexKeyStringMap.put(rowIndex, sb.toString());
+			}
+		});
+		//鍥犱负鍙槸鍏抽敭灞炴�ч噸澶嶏紝鎵�浠ユ垜浠笉鑳介噸澶嶇殑澶氭潯閫変竴鏉℃潵鎶ラ敊
+		return selfRepeatRowIndexList;
+	}
+	/**
 	 * excel鐨勬爣棰樹笂鑾峰彇瀛楁鎵�鍦ㄧ殑浣嶇疆
 	 * @param titleRowData 鏍囬鐨勫唴瀹�
 	 * @param attrNameIdMap 妯℃澘涓睘鎬у悕绉板拰鑻辨枃鐨勬槧灏�
@@ -139,6 +3602,126 @@
 			String title = titleRowData.get(i);
 			String id = attrNameIdMap.getOrDefault(title.replace(KEY_ATTR_CHAR,"").replace(REQUIRED_CHAR
 				,""),"");
+			if(com.alibaba.cloud.commons.lang.StringUtils.isBlank(id) && "鍒嗙被璺緞".equalsIgnoreCase(title)){
+				id = CODE_CLASSIFY_OID_FIELD;
+			}
+			if(com.alibaba.cloud.commons.lang.StringUtils.isBlank(id) && "鐮佹瀹藉害".equalsIgnoreCase(title)){
+				id = CODE_SEC_LENGTH_FIELD;
+			}
+			if(com.alibaba.cloud.commons.lang.StringUtils.isBlank(id) && "浼佷笟缂栫爜".equalsIgnoreCase(title)){
+				id = CODE_FIELD;
+			}
+			if(com.alibaba.cloud.commons.lang.StringUtils.isNotBlank(id)){
+				fieldIndexMap.put(i,id);
+			}
+		}
+	}
+	private List<ClientBusinessObject> ChangeMapTOClientBusinessObjects(List<Map<String,String>> oldDataMap){
+		List<ClientBusinessObject> clientBusinessObjectList=new CopyOnWriteArrayList<>();
+		oldDataMap.parallelStream().forEach(dataMap->{
+			ClientBusinessObject clientBusinessObject=new ClientBusinessObject();
+			DefaultAttrAssimtUtil.copplyDefaultAttrAssimt(dataMap,clientBusinessObject);
+			dataMap.forEach((key,value)->{
+				clientBusinessObject.setAttributeValue(key,value);
+			});
+		});
+		return clientBusinessObjectList;
+	}
+
+	/***
+	 * 鏍规嵁涓嶅悓妯℃澘缁勭粐execl鏁版嵁
+	 * @param dataSet
+	 * @param pathMap
+	 * @param errorMap
+	 */
+	private void createExeclClassData(SheetDataSet dataSet,Map<String/**璺緞**/, CodeClassifyVO> pathMap,Map<String,String>errorMap,List<CodeImprotDataVO> codeClassifyDatas){
+
+		Map<String,CodeImprotDataVO> pathDatas=new HashMap<>();
+		List<String> titleRowData= dataSet.getColName();
+		List<SheetRowData>  rowDataList= dataSet.getRowData();
+		LinkedHashMap<String,CodeClassifyTemplateVO> codeClassifyTemplateVOMap=new LinkedHashMap <String,CodeClassifyTemplateVO>();
+		LinkedHashMap<String,CodeRuleVO> codeRuleVOVOMap=new LinkedHashMap <String,CodeRuleVO>();
+
+		for (int i=0;i<titleRowData.size();i++){
+			String title= titleRowData.get(i);
+			if(title.equals("鍒嗙被璺緞")) {
+				int finalI = i;
+				rowDataList.stream().forEach(sheetRowData -> {
+					CodeImprotDataVO dataVO=new CodeImprotDataVO();
+					String Path = sheetRowData.getData().get(finalI);
+					String rowIndex=sheetRowData.getRowIndex();
+					Map<Integer, String> execlData= sheetRowData.getData();
+					CodeClassifyTemplateVO newTemplateVO=new CodeClassifyTemplateVO();
+					CodeRuleVO codeRuleVO=new CodeRuleVO();
+					if(StringUtils.isEmpty(Path)){
+						Path="#current#";
+					}
+
+					if(pathMap.containsKey(Path)){
+						CodeClassifyVO codeClassifyVO=pathMap.get(Path);
+						if(codeClassifyTemplateVOMap.containsKey(Path)){
+							newTemplateVO=  codeClassifyTemplateVOMap.get(Path);
+							codeRuleVO=  codeRuleVOVOMap.get(Path);
+							if(newTemplateVO==null||StringUtils.isBlank(newTemplateVO.getOid())){
+								errorMap.put(rowIndex,"绗�"+rowIndex+"琛岋紝鍒嗙被璺緞鏈煡璇㈠埌鐩稿簲鐨勫垎绫绘ā鏉�");
+							}
+							if(codeRuleVO==null||StringUtils.isBlank(codeRuleVO.getOid())){
+								errorMap.put(rowIndex,"绗�"+rowIndex+"琛岋紝鍒嗙被璺緞鏈煡璇㈠埌鐩稿簲鐨勫垎绫昏鍒�");
+							}
+						}else{
+							newTemplateVO =engineService.getUsedTemplateByClassifyOid(codeClassifyVO.getOid());
+							if(newTemplateVO==null||StringUtils.isBlank(newTemplateVO.getOid())){
+								errorMap.put(rowIndex,"绗�"+rowIndex+"琛岋紝鍒嗙被璺緞鏈煡璇㈠埌鐩稿簲鐨勫垎绫绘ā鏉�");
+							}
+							codeRuleVO=engineService.getCodeRuleByClassifyOid(codeClassifyVO.getOid());
+							if(codeRuleVO==null||StringUtils.isBlank(codeRuleVO.getOid())){
+								errorMap.put(rowIndex,"绗�"+rowIndex+"琛岋紝鍒嗙被璺緞鏈煡璇㈠埌鐩稿簲鐨勫垎绫昏鍒�");
+							}
+						}
+						if(pathMap.containsKey(Path)){
+							dataVO=pathDatas.getOrDefault(Path,dataVO);
+						}
+						dataVO.setTemplateOid(newTemplateVO==null?"":newTemplateVO.getOid());
+						dataVO.setCodeClassifyTemplateVO(newTemplateVO);
+						dataVO.setCodeClassifyVO(codeClassifyVO);
+						dataVO.setCodeRuleVO(codeRuleVO);
+						dataVO.setRowIndex(rowIndex);
+						dataVO.setCodeClassifyOid(codeClassifyVO.getOid());//璁剧疆鍒嗙被oid
+						dataVO.setCodeRuleOid(codeRuleVO==null?"":codeRuleVO.getOid());
+						createExeclClassData(titleRowData,newTemplateVO,execlData,dataVO);
+						pathDatas.put(Path,dataVO);
+						codeClassifyTemplateVOMap.put(Path, newTemplateVO);
+						codeRuleVOVOMap.put(Path,codeRuleVO);
+					}else{
+						errorMap.put(rowIndex,"绗�"+rowIndex+"琛岋紝鍒嗙被璺緞鏈煡璇㈠埌鐩稿簲鐨勫垎绫�");
+					}
+				});
+				break;
+			}
+		}
+		List <CodeImprotDataVO> newCodeImprotDataVO= pathDatas.values().stream().collect(Collectors.toList());
+		codeClassifyDatas.addAll(newCodeImprotDataVO);
+		log.info("222");
+	}
+	/***
+	 *  @param titleRowData
+	 * @param newTemplateVO
+	 * @param execlData
+	 * @param codeImprotDataVO
+	 */
+	private void createExeclClassData(List<String> titleRowData, CodeClassifyTemplateVO newTemplateVO, Map<Integer, String> execlData, CodeImprotDataVO codeImprotDataVO){
+		//闄ゅ幓榛樿鐨勫睘鎬�.杩樻湁鍙湁琛ㄥ崟鏄剧ず鐨勫瓧娈垫墠瀵煎叆
+		List<CodeClassifyTemplateAttrVO> attrVOS = newTemplateVO.getAttributes().stream().filter(s ->
+			!DEFAULT_ATTR_LIST.contains(s.getId()) && VciBaseUtil.getBoolean(s.getFormDisplayFlag())
+		).collect(Collectors.toList());
+		Map<String/**涓枃鍚嶇О**/, String/**鑻辨枃鍚嶇О**/> attrNameIdMap = attrVOS.stream().collect(Collectors.toMap(s -> s.getName(), t -> t.getId()));
+		List<String> fields=new ArrayList<>();
+		Map<String,String> filedValueMap=new HashMap<>();
+		List<String> colNames=new ArrayList<>();
+		for (int i = 0; i < titleRowData.size(); i++) {
+			String title = titleRowData.get(i);
+			title=title.replace(KEY_ATTR_CHAR,"").replace(REQUIRED_CHAR,"");
+			String id = attrNameIdMap.getOrDefault(title,"");
 			if(StringUtils.isBlank(id) && "鍒嗙被璺緞".equalsIgnoreCase(title)){
 				id = CODE_CLASSIFY_OID_FIELD;
 			}
@@ -149,10 +3732,320 @@
 				id = CODE_FIELD;
 			}
 			if(StringUtils.isNotBlank(id)){
-				fieldIndexMap.put(i,id);
+				// fieldIndexMap.put(i,id);id
+				fields.add(id);
+				colNames.add(title);
+				String value= StringUtils.isNotBlank(execlData.get(i))?execlData.get(i):"";
+				filedValueMap.put(id,value);
+
 			}
+		}
+		// filedValueMap.put(CODE_CLASSIFY_OID_FIELD,codeImprotDataVO.getCodeClassifyOid());//灏嗗綋鍓嶅垎绫籵id瀛樺叆瀛楁涓�
+		filedValueMap.put("codeclassifyid",codeImprotDataVO.getCodeClassifyOid());
+		filedValueMap.put(IMPORT_ROW_INDEX,codeImprotDataVO.getRowIndex());
+		filedValueMap.put("codetemplateoid",newTemplateVO.getOid());
+		codeImprotDataVO.setFields(fields);
+		codeImprotDataVO.setColNames(colNames);
+		codeImprotDataVO.getDatas().add(filedValueMap);
+	}
+	/***
+	 * 姝ｇ‘閿欒鏁版嵁redis缂撳瓨
+	 * @param uuid
+	 * @param templateVO
+	 * @param rowIndexCbo
+	 * @param dataSet
+	 * @param fieldIndexMap
+	 * @param errorMap
+	 * @param isok
+	 */
+	private void createRedisDatas(String uuid,CodeClassifyTemplateVO templateVO,Map<String,ClientBusinessObject> rowIndexCbo, SheetDataSet dataSet, Map<Integer/**鍒楀彿**/,String/**瀛楁鐨勫悕绉�**/> fieldIndexMap,Map<String,String> errorMap,boolean isok){
+		List<SheetRowData>  needsheetRowDataList =new ArrayList<>();
+		if(errorMap.size()>0) {
+			//瑕佹妸浠ヤ笂鐨勯敊璇殑閮芥姏鍑哄悗锛屽啀缁х画澶勭悊鏃堕棿鍜岀粍鍚堣鍒�
+			needsheetRowDataList = dataSet.getRowData().stream().filter(cbo -> {
+				String rowIndex=cbo.getRowIndex();
+				return  isok? !errorMap.containsKey(rowIndex):errorMap.containsKey(rowIndex);
+			}).collect(Collectors.toList());
+
+		}else{
+			needsheetRowDataList= dataSet.getRowData();
+		}
+		Map<String/**涓枃鍚嶇О**/, SheetRowData/**鑻辨枃鍚嶇О**/> rowIdexDataMap = needsheetRowDataList.stream().collect(Collectors.toMap(s -> s.getRowIndex(), t -> t,(o1, o2)->o2));
+		Map<String,CodeImprotDataVO> clsfDataMap=new HashMap<>();
+		rowIndexCbo .forEach((rowIndex, cbo) -> {
+			CodeImprotDataVO codeImprotDataVO = new CodeImprotDataVO();
+			codeImprotDataVO.setTemplateOid(templateVO.getOid());
+			List<Map<String, String>> dataList = new ArrayList<>();
+			if(rowIdexDataMap.containsKey(rowIndex)){
+				SheetRowData sheetRowData=rowIdexDataMap.get(rowIndex);
+				Map<String, String> dataMap = new HashMap<>();
+				Map<Integer, String> data = sheetRowData.getData();
+				fieldIndexMap.forEach((integer, s) -> {
+					String field = fieldIndexMap.get(integer);
+					if (data.containsKey(integer)) {
+						String vlues = data.get(integer);
+						dataMap.put(field, vlues);
+					}
+				});
+				dataMap.put("oid",cbo.getOid());
+				dataList.add(dataMap);
+			}
+			if(clsfDataMap.containsKey(templateVO.getOid())){
+				codeImprotDataVO=clsfDataMap.get(templateVO.getOid());
+				dataList.addAll(codeImprotDataVO.getDatas());
+			}
+			codeImprotDataVO.setColNames(dataSet.getColName());
+			codeImprotDataVO.setDatas(dataList);
+			clsfDataMap.put(templateVO.getOid(),codeImprotDataVO);
+		});
+		if(!CollectionUtils.isEmpty(clsfDataMap)) {
+			Collection codeImprotDataVOS=clsfDataMap.values();
+			List<CodeImprotDataVO> codeImprotDataVOList=new ArrayList<>();
+			codeImprotDataVOList.addAll(codeImprotDataVOS);
+			bladeRedis.set(uuid+"-"+templateVO.getOid(), codeImprotDataVOList);
+			bladeRedis.expire(uuid+"-"+templateVO.getOid(),BATCHADD_REDIS_TIME);//redis杩囨湡鏃堕棿
 		}
 	}
 
+	/******
+	 * 鏍规嵁缂栫爜瑙勫垯缂撳瓨鏁版嵁
+	 * @param uuid
+	 * @param codeImprotDataVOs
+	 * @param errorMap
+	 * @param isok
+	 */
+	private void createRedisDatas(String uuid, List<CodeImprotDataVO> codeImprotDataVOs, Map<String, String> errorMap, boolean isok){
+		codeImprotDataVOs.stream().forEach(codeImprotDataVO -> {
+			List<Map<String, String>>  dataLists=new ArrayList<>();
+			CodeImprotDataVO newCodeImprotDataVO=new CodeImprotDataVO();
+			if(errorMap.size()>0) {
+				//瑕佹妸浠ヤ笂鐨勯敊璇殑閮芥姏鍑哄悗锛屽啀缁х画澶勭悊鏃堕棿鍜岀粍鍚堣鍒�
+				dataLists = codeImprotDataVO.getDatas().stream().filter(cbo -> {
+					String rowIndex=cbo.get(IMPORT_ROW_INDEX);
+					String msg=StringUtils.isBlank(errorMap.get(rowIndex))?"":errorMap.get(rowIndex);
+					cbo.put("errorMsg",msg);
+					return  isok? !errorMap.containsKey(rowIndex):errorMap.containsKey(rowIndex);
+				}).collect(Collectors.toList());
 
+			}else{
+				dataLists= codeImprotDataVO.getDatas();
+			}
+			BeanUtilForVCI.copyPropertiesIgnoreCase(codeImprotDataVO,newCodeImprotDataVO);
+			newCodeImprotDataVO.setDatas(dataLists);
+			List<CodeImprotDataVO> codeImprotDataVOList=new ArrayList<>();
+			codeImprotDataVOList.add(newCodeImprotDataVO);
+			/***update 鏇存敼鎴愪互瑙勫垯鍒嗙粍*****/
+			String codeRuleOid=codeImprotDataVO.getCodeRuleOid();
+			log.info(uuid+"-"+codeRuleOid+":鏉＄洰鏁�"+codeImprotDataVOList.size());
+			if(codeImprotDataVOList.size()>0) {
+				bladeRedis.set(uuid + "-" + codeRuleOid, codeImprotDataVOList);
+				bladeRedis.expire(uuid + "-" + codeRuleOid, BATCHADD_REDIS_TIME);//redis杩囨湡鏃堕棿
+
+			}
+
+			/*** String codeClassifyOid=codeImprotDataVO.getCodeClassifyOid();
+
+			 redisService.setCacheList(uuid+"-"+codeClassifyOid,codeImprotDataVOList);
+			 logger.info(uuid+"-"+codeClassifyOid+":鏉＄洰鏁�"+codeImprotDataVOList.size());
+			 redisService.expire(uuid+"-"+codeClassifyOid,BATCHADD_REDIS_TIME);//redis杩囨湡鏃堕棿***/
+		});
+	}
+
+	/****
+	 * 鏁版嵁鐩镐技椤规暟鎹牎楠宺edis缂撳瓨
+	 * @param codeClassifyOid
+	 * @param templateVO
+	 * @param cboList
+	 * @param resembleMap
+	 * @param btmtypeid
+	 * @param dataResembleVOS
+	 */
+	private void bathcResembleQuery(String codeClassifyOid, CodeClassifyTemplateVO templateVO, List<ClientBusinessObject> cboList,Map<String,String>resembleMap,String btmtypeid,List<DataResembleVO> dataResembleVOS){
+		CodeClassifyFullInfoBO fullInfoBO = classifyService.getClassifyFullInfo(codeClassifyOid);
+		Map<String, String> conditionMap = new HashMap<>();
+		CodeResembleRuleVO resembleRuleVO = Optional.ofNullable(engineService.getUseResembleRule(fullInfoBO, fullInfoBO.getCurrentClassifyVO())).orElseGet(() -> new CodeResembleRuleVO());
+		//闇�瑕佽幏鍙栨槸鍚︽湁鐩镐技鏌ヨ灞炴��
+		Map<String, CodeClassifyTemplateAttrVO> attrVOs = templateVO.getAttributes().stream().filter(s -> VciBaseUtil.getBoolean(s.getSameRepeatAttrFlag())).collect(Collectors.toMap(s -> s.getId(), t -> t));
+		if (CollectionUtils.isEmpty(attrVOs)) {
+			return;
+		}
+		Map<String,CodeImprotResembleVO> codeImprotResembleVOMap=new HashMap<>();
+		List<CodeImprotResembleVO> codeImprotResembleVOList=new ArrayList<>();
+		Map<String,String> rowIndePathMap=new HashMap<>();
+		cboList.stream().forEach(clientBusinessObject -> {
+			CodeImprotResembleVO codeImprotResembleVO=new CodeImprotResembleVO();
+			final String[] path = {""};
+			List<String> fieldList=new ArrayList<>();
+			List<String> rowIndeList=new ArrayList<>();
+			String rowIndex = clientBusinessObject.getAttributeValue(IMPORT_ROW_INDEX);
+			attrVOs.forEach((attrId, attrVO) -> {
+				String value="";
+                /*if (VciQueryWrapperForDO.BASIC_FIELD_MAP.containsKey(attrId)) {
+                    value = WebUtil.getStringValueFromObject(WebUtil.getValueFromField(WebUtil.getFieldForObject(attrId, orderDTO.getClass()).getName(), orderDTO));
+                }else {*/
+				value= clientBusinessObject.getAttributeValue(attrId);
+				// }
+				fieldList.add(attrId);
+				value=StringUtils.isBlank(value)?"":value;
+				path[0] +=value+"#";
+				engineService.wrapperResembleConditionMap(value, resembleRuleVO, attrId, conditionMap);
+			});
+			List<Map<String,String>> dataMap=new ArrayList<>();
+			if(codeImprotResembleVOMap.containsKey(path[0])) {
+				codeImprotResembleVO=codeImprotResembleVOMap.get(path[0]);
+				rowIndeList=codeImprotResembleVO.getRownIndex();
+				dataMap=  codeImprotResembleVO.getDataList();
+				resembleMap.put(rowIndex, "瀛樺湪鐩镐技鏁版嵁");
+			}else{
+				if (!CollectionUtils.isEmpty(conditionMap)) {
+					Map<String, String> andConditionMap = new HashMap<>();
+					andConditionMap.put("lastr", "1");
+					andConditionMap.put("lastv", "1");
+					conditionMap.putAll(andConditionMap);
+					PageHelper pageHelper = new PageHelper(-1);
+					pageHelper.addDefaultDesc("id");
+					CodeTemplateAttrSqlBO sqlBO = engineService.getSqlByTemplateVO(btmtypeid, templateVO, conditionMap, pageHelper);
+					List<Map<String,String>> dataMapList=commonsMapper.queryByOnlySqlForMap(sqlBO.getSqlUnPage());
+					List<ClientBusinessObject> resembleCboList=	ChangeMapTOClientBusinessObjects(dataMapList);
+					if(!CollectionUtils.isEmpty(resembleCboList)) {
+						List<Map<String, String>> finalDataMap = dataMap;
+						resembleCboList.stream().forEach(cbo->{
+							Map<String,String> resembDataMap=new HashMap<>();
+							fieldList.stream().forEach(field->{
+								String value=cbo.getAttributeValue(field);
+								value=StringUtils.isBlank(value)?"":value;
+								resembDataMap.put(field,value);
+							});
+							resembDataMap.put("codetemplateoid",templateVO.getOid());
+							resembDataMap.put("id",StringUtils.isBlank(cbo.getAttributeValue("id"))?"":cbo.getAttributeValue("id"));
+							resembDataMap.put("rowIndex","");
+							resembDataMap.put("oid",cbo.getOid());
+							finalDataMap.add(resembDataMap);
+						});
+						resembleMap.put(rowIndex, "瀛樺湪鐩镐技鏁版嵁");
+
+					}
+				}
+			}
+			rowIndePathMap.put(rowIndex,path[0]);
+			rowIndeList.add(rowIndex);
+			codeImprotResembleVO.setPath(path[0]);
+			codeImprotResembleVO.setRownIndex(rowIndeList);
+			codeImprotResembleVO.setConditionMap(conditionMap);
+			codeImprotResembleVO.setFields(fieldList);
+			codeImprotResembleVO.setDataList(dataMap);
+			codeImprotResembleVOMap.put(path[0],codeImprotResembleVO);
+		});
+		Map<String, ClientBusinessObject> cboMap = cboList.stream().filter(cbo -> cbo != null).collect(Collectors.toList()).stream().collect(Collectors.toMap(s -> s.getAttributeValue((IMPORT_ROW_INDEX)), t -> t));
+		if(!CollectionUtils.isEmpty(rowIndePathMap)){
+			rowIndePathMap.forEach((rowIndex, path) -> {
+				if(codeImprotResembleVOMap.containsKey(path)){
+					CodeImprotResembleVO codeImprotResembleVO=  codeImprotResembleVOMap.get(path);
+					List<String> fieldList=codeImprotResembleVO.getFields();
+					List<String> rownIndexList= codeImprotResembleVO.getRownIndex();
+					List<String> newRownIndexList = rownIndexList.stream().filter(cbo -> {
+						return rowIndex!=cbo;
+					}).collect(Collectors.toList());
+					newRownIndexList.stream().forEach(s -> {
+						resembleMap.put(s, "瀛樺湪鐩镐技鏁版嵁");
+					});
+					List<Map<String, String>>newDataList=new ArrayList<>();
+					DataResembleVO dataResembleVO=new DataResembleVO();
+					dataResembleVO.setOid(cboMap.get(rowIndex).getOid());
+					List<ClientBusinessObject> needSaveCboList = cboList.stream().filter(cbo -> {
+						String newRowIndex = cbo.getAttributeValue(IMPORT_ROW_INDEX);
+						return rownIndexList.contains(newRowIndex)&&(!newRowIndex.equalsIgnoreCase(rowIndex));
+					}).collect(Collectors.toList());
+					if(!CollectionUtils.isEmpty(needSaveCboList)) {
+						needSaveCboList.stream().forEach(cbo -> {
+							String newRowIndex = cbo.getAttributeValue(IMPORT_ROW_INDEX);
+							Map<String, String> resembDataMap = new HashMap<>();
+							fieldList.stream().forEach(field -> {
+								String value = cbo.getAttributeValue(field);
+								value = StringUtils.isBlank(value) ? "" : value;
+								resembDataMap.put(field, value);
+							});
+							resembDataMap.put("codetemplateoid",templateVO.getOid());
+							resembDataMap.put("id",StringUtils.isBlank(cbo.getAttributeValue("id"))?"":cbo.getAttributeValue("id"));
+							resembDataMap.put("rowIndex", newRowIndex);
+							resembDataMap.put("oid",cbo.getOid());
+							newDataList.add(resembDataMap);
+						});
+					}
+					List<Map<String, String>>dataList=codeImprotResembleVO.getDataList();
+					newDataList.addAll(dataList);
+					dataResembleVO.setDataList(newDataList);
+					dataResembleVOS.add(dataResembleVO);
+				}
+			});
+		}
+	}
+
+	/***
+	 * 瀛樺偍鍒嗙被瀵硅薄鍙婂叾鍒楀悕
+	 * @param uuid
+	 * @param templateVOList
+	 * @param dataSet
+	 * @param fieldIndexMap
+	 * @param iscContain
+	 */
+	private  void createRedisByCodeClassify(String uuid,CodeClassifyTemplateVO templateVOList,SheetDataSet dataSet, Map<Integer/**鍒楀彿**/,String/**瀛楁鐨勫悕绉�**/> fieldIndexMap,boolean iscContain){
+		List<ColumnVO> columnVOList = new ArrayList<>();
+		List<String> outNameList = dataSet.getColName();
+		fieldIndexMap.forEach((integer, s) -> {
+			ColumnVO columnVOS = new ColumnVO();
+			String field = fieldIndexMap.get(integer);
+			String outName = outNameList.get(integer);
+			columnVOS.setField(field);
+			columnVOS.setTitle(outName);
+			columnVOList.add(columnVOS);
+		});
+		CodeImportTemplateVO codeImportTemplateVO=new CodeImportTemplateVO();
+		codeImportTemplateVO.setCodeClassifyTemplateVO(templateVOList);
+		codeImportTemplateVO.setCloNamesList(columnVOList);
+		List<CodeImportTemplateVO> codeImportTemplateVOs= new ArrayList<>();
+
+		codeImportTemplateVOs.add(codeImportTemplateVO);
+		if(codeImportTemplateVOs.size()>0) {
+			bladeRedis.set(uuid, codeImportTemplateVOs);
+			bladeRedis.expire(uuid, BATCHADD_REDIS_TIME);//redis杩囨湡鏃堕棿
+		}
+	}
+	/**
+	 * 鎷疯礉涓氬姟绫诲瀷鍒癿ap
+	 * @param cbo 涓氬姟鏁版嵁
+	 * @param map map
+	 */
+	public static void copyValueToMapFromCbos(ClientBusinessObject cbo,Map<String,String> map){
+		if(cbo!=null){
+			copyValueToMapFromBos(cbo,map);
+		}
+	}
+
+	/**
+	 * 鎷疯礉涓氬姟绫诲瀷鍒癿ap
+	 * @param bo 涓氬姟鏁版嵁
+	 * @param map map
+	 */
+	public static void copyValueToMapFromBos(ClientBusinessObject bo,Map<String,String> map){
+		if(bo!=null ){
+			//鍏堟妸鎵�鏈夌殑瀛楁鏄犲皠鎵惧埌
+			AttributeValue[] newAList = bo.newAttrValList;
+			AttributeValue[] hisAList = bo.hisAttrValList;
+			if(hisAList!=null&&hisAList.length>0){//
+				for(int i = 0 ; i < hisAList.length;i++){
+					AttributeValue av = hisAList[i];
+					String attrName = av.attrName.toLowerCase();
+					map.put(attrName, av.attrVal);
+				}
+			}
+			if(newAList!=null&&newAList.length>0){//NEW鐨勪紭鍏堢骇楂樹簺
+				for(int i = 0 ; i < newAList.length;i++){
+					AttributeValue av = newAList[i];
+					String attrName = av.attrName.toLowerCase();
+					map.put(attrName, av.attrVal);
+				}
+			}
+		}
+	}
 }

--
Gitblit v1.9.3