From 0b714bd4979e605ee6c384e040568d0128975a06 Mon Sep 17 00:00:00 2001
From: xiejun <xj@2023>
Date: 星期四, 24 八月 2023 20:29:11 +0800
Subject: [PATCH] 代码提交

---
 Source/UBCS/ubcs-service/ubcs-code/src/main/java/com/vci/ubcs/code/service/impl/MdmIOServiceImpl.java | 1536 ++++++++++++++++++++++++++++++++++++++++++++++++++++++----
 1 files changed, 1,410 insertions(+), 126 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 cc8e8a7..672fade 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
@@ -6,9 +6,9 @@
 import com.vci.ubcs.code.bo.AttributeValue;
 import com.vci.ubcs.code.bo.CodeClassifyFullInfoBO;
 import com.vci.ubcs.code.bo.CodeTemplateAttrSqlBO;
+import com.vci.ubcs.code.dto.CodeExportAttrDTO;
 import com.vci.ubcs.code.dto.CodeOrderDTO;
 import com.vci.ubcs.code.entity.CodeAllCode;
-import com.vci.ubcs.code.entity.CodeClassify;
 import com.vci.ubcs.code.enumpack.CodeDefaultLC;
 import com.vci.ubcs.code.enumpack.CodeLevelTypeEnum;
 import com.vci.ubcs.code.lifecycle.CodeAllCodeLC;
@@ -20,7 +20,9 @@
 import com.vci.ubcs.code.vo.webserviceModel.attrmap.DataObjectVO;
 import com.vci.ubcs.code.vo.webserviceModel.attrmap.RowDatas;
 import com.vci.ubcs.code.vo.webserviceModel.result.xml.XMLResultDataObjectDetailDO;
+import com.vci.ubcs.file.util.VciZipUtil;
 import com.vci.ubcs.omd.feign.IBtmTypeClient;
+import com.vci.ubcs.omd.feign.IWebSecretClient;
 import com.vci.ubcs.omd.vo.BtmTypeVO;
 import com.vci.ubcs.starter.bo.WriteExcelData;
 import com.vci.ubcs.starter.exception.VciBaseException;
@@ -32,17 +34,13 @@
 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.DataGrid;
-import com.vci.ubcs.starter.web.pagemodel.KeyValue;
-import com.vci.ubcs.starter.web.pagemodel.PageHelper;
-import com.vci.ubcs.starter.web.pagemodel.UIFormReferVO;
+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.apache.commons.collections4.map.HashedMap;
@@ -54,18 +52,22 @@
 import org.apache.poi.ss.usermodel.Workbook;
 import org.springblade.core.redis.cache.BladeRedis;
 import org.springblade.core.tool.api.R;
+import org.springblade.core.tool.utils.Func;
 import org.springframework.beans.BeanUtils;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.annotation.Value;
 import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
 import org.springframework.util.CollectionUtils;
 import javax.annotation.Resource;
 import java.io.File;
 import java.io.IOException;
+import java.text.MessageFormat;
 import java.util.*;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.CopyOnWriteArrayList;
 import java.util.concurrent.CopyOnWriteArraySet;
+import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.stream.Collectors;
 
 import static com.alibaba.druid.util.FnvHash.Constants.LIMIT;
@@ -152,6 +154,18 @@
 	 */
 	@Autowired
 	private IBtmTypeClient btmTypeClient;
+
+	/***
+	 * 瀵嗙骇鏈嶅姟
+	 */
+	@Resource
+	private IWebSecretClient secretService;
+
+	/**
+	 * 瀵煎嚭鐨勫崄涓囨潯
+	 */
+	public static final int EXPORT_LIMIT = 100000;
+
 	/**
 	 * 鎵归噺鐢宠锛氶�夊彇閫変腑鍒嗙被涓嬬殑鎵�鏈夋ā鏉垮叧閿睘鎬э紝鐩镐技灞炴�э紝蹇呭～灞炴�э紝鍐欏叆execl涓�
 	 *
@@ -174,38 +188,40 @@
 			//鍙傜収鐨勮嚜琛岃緭鍏ュ悕绉�
 			//鍒嗙被娉ㄥ叆鐨勪笉鐢紝閮芥槸瀵煎叆鍚庤嚜鍔ㄥ鐞嗙殑
 			//缂栫爜锛岀姸鎬佺瓑瀛楁涓嶅鍏�
-			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=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);
+			if(!CollectionUtils.isEmpty(templateVO.getAttributes())) {
+				List<CodeClassifyTemplateAttrVO> templateAttrVOS = templateVO.getAttributes().stream().filter(s ->
+					!DEFAULT_ATTR_LIST.contains(s.getId())
+						&& StringUtils.isBlank(s.getComponentRule())
+						&& StringUtils.isBlank(s.getClassifyInvokeAttr())
+						&& (VciBaseUtil.getBoolean(s.getFormDisplayFlag()))
+				).collect(Collectors.toList());
+				if(CollectionUtils.isEmpty(templateAttrVOS)){
+					throw new VciBaseException("妯℃澘娌℃湁閰嶇疆浠讳綍銆愯〃鍗曟樉绀恒�戜负銆愭槸銆戠殑灞炴��");
 				}
-			});
+				templateAttrVOS.stream().forEach(codetemplateAttr -> {
+					String field = codetemplateAttr.getId();
+					String name = codetemplateAttr.getName();
+					CodeClassifyTemplateAttrVO codeBaseAttributeDTO = new CodeClassifyTemplateAttrVO();
+					boolean res = (StringUtils.isNotBlank(codetemplateAttr.getAttributeGroup()) && codetemplateAttr.getAttributeGroup().equals(BATCHADD_EXCEPORT_ATTR_TYPE))//鍩烘湰灞炴�у瓧娈垫樉绀�
+						|| (StringUtils.isNotBlank(codetemplateAttr.getKeyAttrFlag()) && Boolean.parseBoolean(codetemplateAttr.getKeyAttrFlag()))//鍏抽敭灞炴�х殑瀛樺叆
+						|| (StringUtils.isNotBlank(codetemplateAttr.getSameRepeatAttrFlag()) && Boolean.parseBoolean(codetemplateAttr.getSameRepeatAttrFlag())) //鐩镐技灞炴�х殑瀛樺叆
+						|| (StringUtils.isNotBlank(codetemplateAttr.getRequireFlag()) && Boolean.parseBoolean(codetemplateAttr.getRequireFlag()));
+					if (allFieldToOutNameMap.containsKey(name)) {//濡傛灉瀛樺湪鐨勮瘽鍒欓渶瑕佹牴鎹叿浣撶殑鍘昏祴鍊�
+						codeBaseAttributeDTO = allFieldToOutNameMap.get(name);
+						if (StringUtils.isNotBlank(codetemplateAttr.getKeyAttrFlag()) && Boolean.parseBoolean(codetemplateAttr.getKeyAttrFlag())) {
+							codeBaseAttributeDTO.setKeyAttrFlag(codetemplateAttr.getKeyAttrFlag());//灞炴�у叧閿睘鎬�
+						}
+						if (StringUtils.isNotBlank(codetemplateAttr.getRequireFlag()) && Boolean.parseBoolean(codetemplateAttr.getRequireFlag())) {
+							codeBaseAttributeDTO.setRequireFlag(codetemplateAttr.getRequireFlag());//灞炴�у繀濉」
+						}
+						if (StringUtils.isNotBlank(codetemplateAttr.getSameRepeatAttrFlag()) && Boolean.parseBoolean(codetemplateAttr.getSameRepeatAttrFlag())) {
+							codeBaseAttributeDTO.setSameRepeatAttrFlag(codetemplateAttr.getSameRepeatAttrFlag());//灞炴�х浉浼煎睘鎬�
+						}
+					} else if (res) {
+						allFieldToOutNameMap.put(name, codetemplateAttr);
+					}
+				});
+			}
 		});
 		//鏁寸悊濂芥墍鏈夋ā鏉块渶瑕佸啓鍏xecl鐨勫睘鎬т俊鎭�
 		Workbook workbook = new HSSFWorkbook();
@@ -354,16 +370,23 @@
 			//鍙傜収鐨勮嚜琛岃緭鍏ュ悕绉�
 			//鍒嗙被娉ㄥ叆鐨勪笉鐢紝閮芥槸瀵煎叆鍚庤嚜鍔ㄥ鐞嗙殑
 			//缂栫爜锛岀姸鎬佺瓑瀛楁涓嶅鍏�
-			List<CodeClassifyTemplateAttrVO> templateAttrVOS = codeClassifyTemplateVO.getAttributes().stream().filter(s ->
+			List<CodeClassifyTemplateAttrVO> codeClassifyTemplateAttrVOList=codeClassifyTemplateVO.getAttributes();
+			if(!CollectionUtils.isEmpty(codeClassifyTemplateAttrVOList)) {
+				if (CollectionUtils.isEmpty(codeClassifyTemplateAttrVOList)) {
+					throw new VciBaseException("妯℃澘娌℃湁閰嶇疆灞炴��");
+				}
+			}
+			List<CodeClassifyTemplateAttrVO> templateAttrVOS = codeClassifyTemplateAttrVOList.stream().filter(s ->
 				!DEFAULT_ATTR_LIST.contains(s.getId())
 					&& StringUtils.isBlank(s.getComponentRule())
 					&& StringUtils.isBlank(s.getClassifyInvokeAttr())
 					&& (isHistory || VciBaseUtil.getBoolean(s.getFormDisplayFlag()))
 			).collect(Collectors.toList());
 
-			if(CollectionUtils.isEmpty(templateAttrVOS)){
-				throw new VciBaseException("妯℃澘娌℃湁閰嶇疆浠讳綍銆愯〃鍗曟樉绀恒�戜负銆愭槸銆戠殑灞炴��");
-			}
+				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();
@@ -666,7 +689,7 @@
 			//鐩镐技鏍￠獙
 			Map<String,String>resembleMap=new HashMap<>();
 			List<DataResembleVO> dataResembleVOS=new ArrayList<>();
-			String btmtypeid= classifyFullInfo.getTopClassifyVO().getBtmtypeid();
+			String btmtypeid= classifyFullInfo.getTopClassifyVO().getBtmTypeId();
 			bathcResembleQuery(codeClassifyOid,templateVO,needSaveCboList,resembleMap,btmtypeid,dataResembleVOS);
 			if(resembleMap.size()>0) {
 				if(!CollectionUtils.isEmpty(dataResembleVOS)) {
@@ -750,7 +773,7 @@
 	 * @return 鏈夐敊璇俊鎭殑excel
 	 */
 	@Override
-	public CodeImProtRusultVO batchImportHistoryData(String codeClassifyOid, String classifyAttr,File file) {
+	public CodeImProtRusultVO batchImportHistoryData(String codeClassifyOid, String classifyAttr,File file) throws  Throwable{
 		VciBaseUtil.alertNotNull(codeClassifyOid,"鍒嗙被鐨勪富閿�");
 		ReadExcelOption reo = new ReadExcelOption();
 		reo.setReadAllSheet(true);
@@ -966,7 +989,7 @@
 			//鐩镐技鏍￠獙
 			Map<String, String> resembleMap = new HashMap<>();
 			List<DataResembleVO> dataResembleVOS = new ArrayList<>();
-			String btmtypeid = classifyFullInfo.getTopClassifyVO().getBtmtypeid();
+			String btmtypeid = classifyFullInfo.getTopClassifyVO().getBtmTypeId();
 			bathcResembleQuery(templateVO.getCodeclassifyoid(), templateVO, needSaveCboList, resembleMap, btmtypeid, dataResembleVOS);
 			if (resembleMap.size() > 0) {
 				if (!CollectionUtils.isEmpty(dataResembleVOS)) {
@@ -995,7 +1018,7 @@
 			if (isExport||newErrorMap.size() > 0) {
 				createRedisDatas(uuid + "-ok", templateVO, rowIndexCboMap, dataSet, fieldIndexMap, newErrorMap, true);
 			} else {
-				List<String> dataCBOIdList=new ArrayList<>();
+				List<BaseModel> dataCBOIdList=new ArrayList<>();
 				//SessionInfo sessionInfo = VciBaseUtil.getCurrentUserSessionInfo();
 				List<ClientBusinessObject> finalNeedSaveCboList = needSaveCboList;
 				CodeClassifyTemplateVO finalTemplateVO = templateVO;
@@ -1007,9 +1030,9 @@
 					thisCbos.stream().forEach(clientBusinessObject -> {
 						BaseModel baseModel=new BaseModel();
 						BeanUtil.convert(clientBusinessObject,baseModel);
-						baseModel.setData(VciBaseUtil.objectToMapString(clientBusinessObject));
+						//baseModel.setData(VciBaseUtil.objectToMapString(clientBusinessObject));
 						dataCBOList.add(baseModel);
-						dataCBOIdList.add(baseModel.getOid());
+						dataCBOIdList.add(baseModel);
 					});
 
 					if (!CollectionUtils.isEmpty(thisCbos)) {
@@ -1021,9 +1044,14 @@
 								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);
 			}
 		}
@@ -1052,7 +1080,19 @@
 
 		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
@@ -1289,7 +1329,7 @@
 		//鐩镐技鏍￠獙
 		Map<String,String>resembleMap=new HashMap<>();
 		List<DataResembleVO> dataResembleVOS=new ArrayList<>();
-		String btmtypeid= classifyFullInfo.getTopClassifyVO().getBtmtypeid();
+		String btmtypeid= classifyFullInfo.getTopClassifyVO().getBtmTypeId();
 		bathcResembleQuery(orderDTO.getCodeClassifyOid(),templateVO,needSaveCboList,resembleMap,btmtypeid,dataResembleVOS);
 		if(resembleMap.size()>0) {
 			isCreateUUid=true;
@@ -1329,14 +1369,14 @@
 				cboList.stream().forEach(clientBusinessObject -> {
 					BaseModel baseModel=new BaseModel();
 					BeanUtil.convert(clientBusinessObject,baseModel);
-					baseModel.setData(VciBaseUtil.objectToMapString(clientBusinessObject));
+					//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, dataCBOIdList);
+					engineService.batchSaveSelectChar(templateVO, dataCBOList);
 				} catch (Exception e) {
 					e.printStackTrace();
 					log.error("鎵逛簡鐢宠鏃跺け璐�");
@@ -1353,8 +1393,7 @@
 	public List<CodeImportTemplateVO> gridclassifys(String redisOid) {
 		List<CodeImportTemplateVO> codeImportTemplateVOs=new ArrayList<>();
 		VciBaseUtil.alertNotNull(redisOid,"鍒嗙被",redisOid,"鍒嗙被缂撳瓨涓婚敭");
-
-		List<CodeImportTemplateVO> redisServiceCacheObjects=bladeRedis.lRange(redisOid,0,-1);
+		List<CodeImportTemplateVO> redisServiceCacheObjects=bladeRedis.get(redisOid);
 		if(redisServiceCacheObjects!=null){
 			codeImportTemplateVOs=  redisServiceCacheObjects;
 		}
@@ -1370,7 +1409,7 @@
 	@Override
 	public DataGrid<Map<String, String>> gridDatas(String codeClssifyOid, String redisOid) {
 		VciBaseUtil.alertNotNull(redisOid,"瀵煎叆鐩镐技鏁版嵁",redisOid,"鏁版嵁缂撳瓨涓婚敭");
-		List<CodeImprotDataVO> codeImprotDataVOs = bladeRedis.lRange(redisOid+"-"+codeClssifyOid,0,-1);
+		List<CodeImprotDataVO> codeImprotDataVOs = bladeRedis.get(redisOid+"-"+codeClssifyOid);
 //		redisService.getCacheList(redisOid+"-"+codeClssifyOid);
 		CodeImprotDataVO codeImprotDataVO=new CodeImprotDataVO();
 		if(!CollectionUtils.isEmpty(codeImprotDataVOs)){
@@ -1404,7 +1443,7 @@
 	@Override
 	public DataGrid<Map<String,String>> gridRowResemble(String oid,String redisOid){
 		VciBaseUtil.alertNotNull(redisOid,"瀵煎叆鐩镐技鏁版嵁",redisOid,"鏁版嵁缂撳瓨涓婚敭");
-		List<DataResembleVO> codeImprotDataVOs = bladeRedis.lRange(redisOid,0,-1);;
+		List<DataResembleVO> codeImprotDataVOs = bladeRedis.get(redisOid);;
 		DataGrid<Map<String, String>> dataGrid = new DataGrid<>();
 		List<Map<String, String>> dataList = new ArrayList<>();
 
@@ -1423,9 +1462,229 @@
 		return dataGrid;
 	}
 
+	/**
+	 * 瀵煎嚭涓婚搴撶殑鏁版嵁
+	 *
+	 * @param exportAttrDTO 瀵煎嚭鐩稿叧鐨勯厤缃紝蹇呴』瑕佹湁涓婚搴撳垎绫荤殑涓婚敭
+	 * @return 瀵煎嚭鐨別xcel鐨勬枃浠�
+	 */
+	@Override
+	public String exportCode(CodeExportAttrDTO exportAttrDTO) {
+		VciBaseUtil.alertNotNull(exportAttrDTO,"瀵煎嚭鐨勯厤缃�",exportAttrDTO.getCodeClassifyOid(),"涓婚搴撳垎绫荤殑涓婚敭");
+		CodeClassifyFullInfoBO classifyFullInfo = classifyService.getClassifyFullInfo(exportAttrDTO.getCodeClassifyOid());
+		//鑾峰彇鏈�鏂扮殑妯℃澘
+		CodeClassifyTemplateVO templateVO = engineService.getUsedTemplateByClassifyOid(exportAttrDTO.getCodeClassifyOid());
+		//鍏堟煡璇㈡暟鎹�
+		String btmTypeId = classifyFullInfo.getTopClassifyVO().getBtmTypeId();
+		Map<String, String> conditionMap = exportAttrDTO.getConditionMap();
+		if(conditionMap == null){
+			conditionMap = new HashMap<>();
+		}
+		if(conditionMap.containsKey(VciQueryWrapperForDO.OID_FIELD)){
+			conditionMap.put(VciQueryWrapperForDO.OID_FIELD,QueryOptionConstant.IN + "(" + VciBaseUtil.toInSql(conditionMap.get(VciQueryWrapperForDO.OID_FIELD)) + ")");
+		}
+		PageHelper pageHelper = new PageHelper(exportAttrDTO.getLimit()==null?-1:exportAttrDTO.getLimit());
+		pageHelper.setPage(exportAttrDTO.getPage()==null?1:exportAttrDTO.getPage());
+		pageHelper.setSort(exportAttrDTO.getSort());
+		pageHelper.setOrder(exportAttrDTO.getOrder());
+
+		pageHelper.addDefaultDesc("createTime");
+		conditionMap.put("codeclsfpath","*" + exportAttrDTO.getCodeClassifyOid() + "*");
+		conditionMap.put("lastr", "1");
+		conditionMap.put("lastv", "1");
+
+		R<List<BtmTypeVO>> listR = btmTypeClient.selectByIdCollection(Arrays.asList(btmTypeId));
+		String tableName = "";
+		if(listR.isSuccess() && !listR.getData().isEmpty()){
+			tableName = Func.isNotBlank(listR.getData().get(0).getTableName()) ? listR.getData().get(0).getTableName():VciBaseUtil.getTableName(btmTypeId);
+		}else{
+			tableName = VciBaseUtil.getTableName(btmTypeId);
+		}
+
+		String countSql = "select count(*) from " + tableName +" where 1=1" +
+			" and lastr = '1'" +
+			" and lastv='1'" +
+			" and codeclsfpath like '%" + exportAttrDTO.getCodeClassifyOid() + "%'";
+
+		//鍏堟煡璇㈡�绘暟
+		int total = 0;
+		if(exportAttrDTO.getEndPage()!=null && exportAttrDTO.getEndPage()>0
+			&&exportAttrDTO.getPage() !=null && exportAttrDTO.getPage() >0
+			&&exportAttrDTO.getEndPage()>exportAttrDTO.getPage()){
+			//浠庡灏戦〉鍒板灏戦〉鐨勬煡璇㈡柟寮忥紝
+			for(int i = exportAttrDTO.getPage() ;i <= exportAttrDTO.getEndPage();i++){
+				PageHelper thisPage = new PageHelper(exportAttrDTO.getLimit()==null?-1:exportAttrDTO.getLimit());
+				thisPage.setPage(exportAttrDTO.getPage()==null?1:exportAttrDTO.getPage());
+				thisPage.setSort(exportAttrDTO.getSort());
+				thisPage.setOrder(exportAttrDTO.getOrder());
+				thisPage.addDefaultDesc("createTime");
+
+				total += commonsMapper.queryCountBySql(countSql);
+			}
+		}else{
+
+			total = commonsMapper.queryCountBySql(countSql);
+		}
+		List<String> selectFieldList = new ArrayList<>();
+		if(!CollectionUtils.isEmpty(exportAttrDTO.getAttrIdIndexMap())){
+			selectFieldList = exportAttrDTO.getAttrIdIndexMap().values().stream().map(s->s.toLowerCase(Locale.ROOT)).collect(Collectors.toList());
+		}else{
+			selectFieldList = templateVO.getAttributes().stream().filter(s->VciBaseUtil.getBoolean(s.getFormDisplayFlag())
+				||VciBaseUtil.getBoolean(s.getTableDisplayFlag())).map(s->s.getId().toLowerCase(Locale.ROOT)).collect(Collectors.toList());
+		}
+		//鍙傜収璁╁钩鍙扮洿鎺ユ煡璇㈠氨琛�
+		List<String> finalSelectFieldList = selectFieldList;
+		List<CodeClassifyTemplateAttrVO> referAttrVOs = templateVO.getAttributes().stream().filter(
+			s -> StringUtils.isNotBlank(s.getReferBtmId())
+				&&
+				(finalSelectFieldList.size() ==0 || finalSelectFieldList.contains(s.getId().toLowerCase(Locale.ROOT)))
+		).collect(Collectors.toList());
+		if(!CollectionUtils.isEmpty(referAttrVOs)){
+			for (int i = 0; i < referAttrVOs.size(); i++) {
+				selectFieldList.add(referAttrVOs.get(i).getId() + ".name");
+			}
+		}
+		List<String> excelNameList = new CopyOnWriteArrayList<>();
+		String tempFolder = LocalFileUtil.getDefaultTempFolder();
+		if(total>EXPORT_LIMIT){
+			//鍒嗙粍鏉ユ墽琛�
+			int queryCount = (total-total%EXPORT_LIMIT)/EXPORT_LIMIT;
+			if(total%EXPORT_LIMIT>0){
+				queryCount = queryCount + 1;
+			}
+			List<Integer> indexList = new ArrayList<>();
+			for (int i = 0; i <queryCount ; i++) {
+				indexList.add(i);
+			}
+			Map<String, String> finalConditionMap = conditionMap;
+			//骞惰鏌ヨ鐪嬬湅
+			SessionInfo sessionInfo = VciBaseUtil.getCurrentUserSessionInfo();
+			indexList.stream().forEach(index->{
+				//绾跨▼鐨勬柟寮忥紝鎵�浠ラ渶瑕佽缃綋鍓嶇敤鎴�
+				VciBaseUtil.setCurrentUserSessionInfo(sessionInfo);
+				PageHelper thisPage = new PageHelper(EXPORT_LIMIT);
+				thisPage.setPage(index+1);
+				thisPage.setSort(exportAttrDTO.getSort());
+				thisPage.setOrder(exportAttrDTO.getOrder());
+				thisPage.addDefaultDesc("createTime");
+				selectDataAndExportExcelName(btmTypeId, finalConditionMap,thisPage,finalSelectFieldList,
+					classifyFullInfo,templateVO,exportAttrDTO,
+					excelNameList,tempFolder,index);
+			});
+		}else{
+			pageHelper.setLimit(total);
+			pageHelper.setPage(1);
+			selectDataAndExportExcelName(btmTypeId,conditionMap,pageHelper,finalSelectFieldList,
+				classifyFullInfo,templateVO,exportAttrDTO,
+				excelNameList,tempFolder,1);
+		}
+		if(excelNameList.size() ==0){
+			throw new VciBaseException("娌℃湁鏁版嵁鍙互琚鍑�");
+		}
+		if(excelNameList.size() == 1){
+			return excelNameList.get(0);
+		}
+		//鏄涓紝鎴戜滑闇�瑕佹墦鎴愬帇缂╁寘
+		String zipFileName = LocalFileUtil.getDefaultTempFolder() + File.separator + classifyFullInfo.getCurrentClassifyVO().getId() + "_" + classifyFullInfo.getCurrentClassifyVO().getName() + "_瀵煎嚭_" + excelNameList.size()+".zip";
+		VciZipUtil zipUtil = new VciZipUtil();
+		File file = new File(tempFolder);
+		zipUtil.addFileToZip(file,zipFileName);
+		File[] files = file.listFiles();
+		for (int i = 0; i < files.length; i++) {
+			LocalFileUtil.deleteTempFile(files[i],false);
+		}
+		LocalFileUtil.deleteTempFile(file,true);
+		return zipFileName;
+	}
+
+	/**
+	 * 鏌ヨ鏁版嵁骞跺鍑哄埌excel
+	 * @param btmTypeId 涓氬姟绫诲瀷
+	 * @param conditionMap 鏌ヨ鏉′欢
+	 * @param pageHelper 鍒嗛〉
+	 * @param selectFieldList 鏌ヨ鐨勫瓧娈�
+	 * @param classifyFullInfo 鍒嗙被鐨勫叏閮ㄤ俊鎭�
+	 * @param templateVO 妯℃澘鐨勪俊鎭�
+	 * @param exportAttrDTO 瀵煎嚭鐨勫睘鎬�
+	 * @param excelNameList excel鐨勬枃浠跺悕绉�
+	 * @param tempFolder 涓存椂鏂囦欢澶�
+	 * @param excelIndex excel鐨勯『搴�
+	 */
+	private void selectDataAndExportExcelName(String btmTypeId, Map<String, String> conditionMap, PageHelper pageHelper, List<String> selectFieldList,
+											  CodeClassifyFullInfoBO classifyFullInfo, CodeClassifyTemplateVO templateVO, CodeExportAttrDTO exportAttrDTO,
+											  List<String> excelNameList, String tempFolder,
+											  Integer excelIndex) {
+		DataGrid<Map<String, String>> dataGrid = engineService.queryGrid(btmTypeId, templateVO, conditionMap, pageHelper);
+		if(dataGrid == null || CollectionUtils.isEmpty(dataGrid.getData())){
+			return;
+		}
+		//杞崲鏁版嵁
+		List<Map<String, String>> dataMap = dataGrid.getData();
+		//灏佽鏌ヨ鍑烘潵鐨勬暟鎹�
+		engineService.wrapperData(dataMap, templateVO, selectFieldList,false);
+		//modify by weidy@2022-09-27
+		//鍥犱负鍦ㄥ垪琛ㄥ拰琛ㄥ崟鐨勬樉绀虹殑鏃跺�欙紝鎴戜滑鐨勫紑鍏崇被鍨嬮〉闈細澶勭悊锛屼絾鏄湪瀵煎嚭鐨勬椂鍊欙紝鎴戜滑闇�瑕佸皢true鍜宖alse閮芥浛鎹㈡垚涓枃
+		engineService.wrapperBoolean(dataMap,templateVO);
+		Map<String, CodeClassifyTemplateAttrVO> attrVOMap = templateVO.getAttributes().stream().filter(s->selectFieldList.contains(s.getId().toLowerCase(Locale.ROOT))).collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t));
+		Map<Integer, String> attrIdIndexMap = exportAttrDTO.getAttrIdIndexMap();
+		if (CollectionUtils.isEmpty(attrIdIndexMap)) {
+			attrIdIndexMap = templateVO.getAttributes().stream().filter(s->selectFieldList.contains(s.getId().toLowerCase(Locale.ROOT))).collect(Collectors.toMap(s -> s.getOrderNum(), t -> t.getId()));
+		}
+		List<Integer> indexList = attrIdIndexMap.keySet().stream().sorted().collect(Collectors.toList());
+
+		String excelName = tempFolder + File.separator +
+			classifyFullInfo.getCurrentClassifyVO().getId() + "_" + classifyFullInfo.getCurrentClassifyVO().getName() + "_瀵煎嚭_" + excelIndex + ".xls";
+		try {
+			new File(excelName).createNewFile();
+		} catch (Throwable e) {
+			throw new VciBaseException(LangBaseUtil.getErrorMsg(e), new String[]{excelName}, e);
+		}
+		excelNameList.add(excelName);
+		List<WriteExcelData> excelDataList = new ArrayList<>();
+		Workbook workbook = new HSSFWorkbook();
+		for (int i = 0; i < indexList.size(); i++) {
+			String attrId = attrIdIndexMap.get(indexList.get(i)).toLowerCase(Locale.ROOT);
+			if (attrVOMap.containsKey(attrId)) {
+				CodeClassifyTemplateAttrVO attrVO = attrVOMap.get(attrId);
+				Object text = attrVO.getName();
+				text = exportKeyAndRequired(workbook,attrVO,text);
+				WriteExcelData excelData = new WriteExcelData(0, i, text);
+				if(text instanceof RichTextString){
+					excelData.setFontColor(String.valueOf(HSSFColor.HSSFColorPredefined.RED.getIndex()));
+				}
+				excelDataList.add(excelData);
+			}
+		}
+		final Integer[] rowIndex = {0};
+		Map<Integer, String> finalAttrIdIndexMap = attrIdIndexMap;
+		dataMap.stream().forEach(data -> {
+			rowIndex[0]++;
+			for (int i = 0; i < indexList.size(); i++) {
+				Integer index = indexList.get(i);
+				String attrId = finalAttrIdIndexMap.get(index).toLowerCase(Locale.ROOT);
+				if (attrVOMap.containsKey(attrId)) {
+					CodeClassifyTemplateAttrVO attrVO = attrVOMap.get(attrId);
+					if (StringUtils.isNotBlank(attrVO.getEnumId()) || StringUtils.isNotBlank(attrVO.getEnumString())) {
+						attrId = attrId + "Text";
+					}
+					if (StringUtils.isNotBlank(attrVO.getReferBtmId()) || StringUtils.isNotBlank(attrVO.getReferConfig())) {
+						attrId = attrId + "name";
+					}
+					if(VciQueryWrapperForDO.LC_STATUS_FIELD.equalsIgnoreCase(attrId)){
+						attrId = VciQueryWrapperForDO.LC_STATUS_FIELD_TEXT.toLowerCase(Locale.ROOT);
+					}
+					excelDataList.add(new WriteExcelData(rowIndex[0], i, data.getOrDefault(attrId, "")));
+				}
+			}
+		});
+		WriteExcelOption excelOption = new WriteExcelOption(excelDataList);
+		ExcelUtil.writeDataToFile(excelName, excelOption);
+	}
+
 	@Override
 	public R batchImportData(List<CodeImprotSaveDatVO> codeImprotSaveDatVOList, String classifyAttr, boolean isImprot) {
-		List<String> allNeedSaveCboList=new ArrayList<>();
+		WriteExcelOption eo = new WriteExcelOption();
+		AtomicBoolean success= new AtomicBoolean(true);
 		codeImprotSaveDatVOList.stream().forEach(codeImprotSaveDatVO -> {
 			List<SheetRowData> rowDataList = new ArrayList<>();
 			List<ClientBusinessObject>cboList=new ArrayList<>();
@@ -1464,19 +1723,31 @@
 			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);
-				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 = 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
@@ -1506,38 +1777,80 @@
 			//4.鏍￠獙瑙勫垯
 			batchCheckVerifyOnOrder(attrVOS, cboList,errorMap);
 
-
-			//SessionInfo sessionInfo = VciBaseUtil.getCurrentUserSessionInfo();
-			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)) {
-				List<BaseModel> dataCBOList=new ArrayList<>();
-				needSaveCboList.stream().forEach(clientBusinessObject -> {
-					BaseModel baseModel=new BaseModel();
-					BeanUtil.convert(clientBusinessObject,baseModel);
-					baseModel.setData(VciBaseUtil.objectToMapString(clientBusinessObject));
-					dataCBOList.add(baseModel);
-					allNeedSaveCboList.add(baseModel.getOid());
-				});
-				try {
-				//9.鎴戜滑澶勭悊涓氬姟鏁版嵁
-					if (isImprot) {
-						productCodeService.productCodeAndSaveData(classifyFullInfo, codeClassifyTemplateVO, ruleVO, null, dataCBOList);
-					}else {
-						productCodeService.productCodeAndSaveData(classifyFullInfo, codeClassifyTemplateVO, ruleVO, orderDTO.getSecDTOList(), dataCBOList);
+			if(isImprot){
+				List<ClientBusinessObject> needSaveCboList = cboList.stream().filter(cbo -> {
+					String rowIndex = cbo.getAttributeValue(IMPORT_ROW_INDEX);
+					return !errorMap.containsKey(rowIndex);
+				}).collect(Collectors.toList());
+				List<ClientBusinessObject> finalNeedSaveCboList = needSaveCboList;
+				Map<String, CodeRuleVO> finalRuleVOMap = ruleVOMap;
+				ruleRowIndexMap.keySet().parallelStream().forEach(ruleOid -> {
+					List <BaseModel>dataCBOList=new CopyOnWriteArrayList<>();
+					List<String> rowIndexList = ruleRowIndexMap.get(ruleOid);
+					List<ClientBusinessObject> thisCbos = needSaveCboList.stream().filter(cbo -> rowIndexList.contains(cbo.getAttributeValue(IMPORT_ROW_INDEX)) && !errorMap.containsKey(cbo.getAttributeValue(IMPORT_ROW_INDEX))).collect(Collectors.toList());
+					if (!CollectionUtils.isEmpty(thisCbos)) {
+						thisCbos.stream().forEach(clientBusinessObject -> {
+							BaseModel baseModel = new BaseModel();
+							BeanUtil.convert(clientBusinessObject, baseModel);
+							dataCBOList.add(baseModel);
+						});
+						try {
+							productCodeService.productCodeAndSaveData(classifyFullInfo, codeClassifyTemplateVO, finalRuleVOMap.get(ruleOid), null, dataCBOList);
+						} catch (Throwable e) {
+							//success=false;
+							log.error("鎵归噺浜х敓缂栫爜鐨勬椂鍊欏嚭閿欎簡", e);
+							thisCbos.stream().forEach(cbo -> {
+								String rowIndex = cbo.getAttributeValue(IMPORT_ROW_INDEX);
+								errorMap.put(rowIndex, errorMap.getOrDefault(rowIndex, "") + ";绯荤粺閿欒锛屽瓨鍌ㄦ暟鎹殑鏃跺�欏嚭閿欎簡:"+e.getMessage());
+							});
+						}
 					}
-				} catch (Exception e) {
-					e.printStackTrace();
+					engineService.batchSaveSelectChar(codeClassifyTemplateVO, dataCBOList);
+				});
+			}else {
+				List<BaseModel> dataCBOList=new ArrayList<>();
+				List<ClientBusinessObject> needSaveCboList = cboList.stream().filter(cbo -> {
+					String rowIndex = cbo.getAttributeValue(IMPORT_ROW_INDEX);
+					return !errorMap.containsKey(rowIndex);
+				}).collect(Collectors.toList());
+				log.info("鍒嗙被锛�" + classifyFullInfo.getCurrentClassifyVO().getName() + "鏁版嵁:" + needSaveCboList.size());
+				if (!CollectionUtils.isEmpty(needSaveCboList)) {
+					needSaveCboList.stream().forEach(clientBusinessObject -> {
+						BaseModel baseModel = new BaseModel();
+						BeanUtil.convert(clientBusinessObject, baseModel);
+						dataCBOList.add(baseModel);
+					});
+					try {
+						productCodeService.productCodeAndSaveData(classifyFullInfo, codeClassifyTemplateVO, ruleVO, orderDTO.getSecDTOList(), dataCBOList);
+					} catch (Exception e) {
+						log.error("鎵归噺浜х敓缂栫爜鐨勬椂鍊欏嚭閿欎簡", e);
+						needSaveCboList.stream().forEach(cbo -> {
+							String rowIndex = cbo.getAttributeValue(IMPORT_ROW_INDEX);
+							errorMap.put(rowIndex, errorMap.getOrDefault(rowIndex, "") + ";绯荤粺閿欒锛屽瓨鍌ㄦ暟鎹殑鏃跺�欏嚭閿欎簡:"+e.getMessage());
+						});
+					}
+					//濡傛灉鏄紪鐮佺敓鎴愬け璐ワ紝鍒欑洿鎺ュ氨澶辫触浜嗭紝鍏朵粬鐨勫垽鏂嚭鏉ユ湁閿欒鐨勬垜浠兘缁熶竴杩斿洖鍒癳xcel閲岄潰
+					engineService.batchSaveSelectChar(codeClassifyTemplateVO, dataCBOList);
 				}
 			}
-			//濡傛灉鏄紪鐮佺敓鎴愬け璐ワ紝鍒欑洿鎺ュ氨澶辫触浜嗭紝鍏朵粬鐨勫垽鏂嚭鏉ユ湁閿欒鐨勬垜浠兘缁熶竴杩斿洖鍒癳xcel閲岄潰
-			engineService.batchSaveSelectChar(codeClassifyTemplateVO, allNeedSaveCboList);
+			if(errorMap.size()>0) {
+				success.set(false);
+				LinkedList<WriteExcelData> excelDataList = new LinkedList<>();
+				excelDataList.add(new WriteExcelData(0, 0, "閿欒淇℃伅"));
+				final int[] index = {1};
+				errorMap.forEach((key,v)->{
+					excelDataList.add(new WriteExcelData(index[0]++, 0, "绗�"+(Integer.parseInt(key)+1)+"琛屾暟鎹細"+v));
+				});
+				eo.addSheetDataList(codeClassifyTemplateVO.getName() + "瀵煎叆妯℃澘", excelDataList);
+			}
 		});
-		return  R.success(isImprot?"鎵归噺鍘嗗彶瀵煎叆鎴愬姛":"鎵归噺鐢宠鎴愬姛");
+		if(!success.get()){
+			String excelName = LocalFileUtil.getDefaultTempFolder() + File.separator + (isImprot?"鎵归噺鍘嗗彶閿欒淇℃伅.xls":"鎵归噺鐢宠閿欒淇℃伅.xls");
+			ExcelUtil.writeDataToFile(excelName,eo);
+			return  R.fail(excelName);
+		}else {
+			return R.success(isImprot ? "鎵归噺鍘嗗彶瀵煎叆鎴愬姛" : "鎵归噺鐢宠鎴愬姛");
+		}
 	}
 
 	/***
@@ -1586,7 +1899,7 @@
 	 * @return 鏈夐敊璇俊鎭殑excel
 	 */
 	@Override
-	public void batchSyncApplyCode(CodeOrderDTO orderDTO, DataObjectVO dataObjectVO, LinkedList<XMLResultDataObjectDetailDO> resultDataObjectDetailDOs) {
+	public void batchSyncApplyCode(CodeOrderDTO orderDTO, DataObjectVO dataObjectVO, LinkedList<XMLResultDataObjectDetailDO> resultDataObjectDetailDOs,boolean isCodeOrGroupCode) {
 		Map<String,String> errorMap=new HashMap<>();
 		VciBaseUtil.alertNotNull(orderDTO,"缂栫爜鐢宠鐩稿叧鐨勬暟鎹�",orderDTO.getCodeClassifyOid(),"涓婚搴撳垎绫讳富閿�");
 		CodeClassifyFullInfoBO classifyFullInfo = classifyService.getClassifyFullInfo(orderDTO.getCodeClassifyOid());
@@ -1621,7 +1934,7 @@
 		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");
@@ -1630,19 +1943,835 @@
 		/** 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 groupCode="";
+					String errorid="103";
+					String mes=errorMap.get(rowIndex);
+					XMLResultDataObjectDetailDO resultDataObjectDetailDO=new XMLResultDataObjectDetailDO();
+					if(isCodeOrGroupCode){
+						resultDataObjectDetailDO.setCode(groupCode);
+					}else{
+						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 groupCode="";
+						String errorid = "201";
+						if(codeOidToSystemOidMap.containsKey(oid)){
+							sourceOid=codeOidToSystemOidMap.get(oid);
+						}
+						List<BaseModel> newCboList = indexTodataMap.get(rowIndex);
+						if (!CollectionUtils.isEmpty(newCboList)) {
+							BaseModel newCbo= newCboList.get(0);
+							String lcstatus =newCbo.getLcStatus();
+							String newOid =newCbo.getOid();
+							Date ts =newCbo.getTs();
+							groupCode=newCbo.getData().get("GROUPCODE");
+							code=newCbo.getId();
+							String lastmodifier=newCbo.getLastModifier();
+							if (lcstatus!=null&&!lcstatus.equals(CodeDefaultLC.RELEASED.getValue())) {
+								newCbo.setOid(newOid);
+								newCbo.setLastModifier(lastmodifier);
+								/*if(isCodeOrGroupCode) {
+									newCbo.setId(code);
+								}else{
+									newCbo.getData().put("groupcode",groupCode);
+								}*/
+								newCbo.setTs(ts);
+								cbo.setLastModifier(cbo.getLastModifier());
+								editBoList.add(newCbo);
+							}
+							String mes = errorKeyMap.get(rowIndex);
+							XMLResultDataObjectDetailDO resultDataObjectDetailDO = new XMLResultDataObjectDetailDO();
+							if(isCodeOrGroupCode) {
+								if(StringUtils.isBlank(groupCode)){
+									mes+="锛涚敵璇风殑缂栫爜绫诲瀷涓洪泦鍥㈢爜锛岀瓑寰呴泦鍥㈢紪鐮佽祴鍊�";
+								}
+								resultDataObjectDetailDO.setCode(groupCode);
+							}else{
+								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){
+				dataCBOList.stream().forEach(needSaveCbo->{
+					XMLResultDataObjectDetailDO resultDataObjectDetailDO=new XMLResultDataObjectDetailDO();
+					String code=needSaveCbo.getId();
+					String groupCode=needSaveCbo.getData().getOrDefault("GROUPCODE","");
+					//resultDataObjectDetailDO.setCode(needSaveCbo.getId());
+					String msg="鐢宠缂栫爜鎴愬姛";
+					String oid=needSaveCbo.getOid();
+					String sourceOid=oid;
+					if(codeOidToSystemOidMap.containsKey(oid)){
+						sourceOid=codeOidToSystemOidMap.get(oid);
+					}
+					if(isCodeOrGroupCode) {
+						if(StringUtils.isBlank(groupCode)){
+							msg="鐢宠鐨勭紪鐮佺被鍨嬩负闆嗗洟鐮侊紝绛夊緟闆嗗洟缂栫爜璧嬪��";
+						}
+						resultDataObjectDetailDO.setCode(groupCode);
+					}else{
+						resultDataObjectDetailDO.setCode(code);
+					}
+					resultDataObjectDetailDO.setId(sourceOid);
+					resultDataObjectDetailDO.setErrorid("0");
+					resultDataObjectDetailDO.setMsg(msg);
+					resultDataObjectDetailDOs.add(resultDataObjectDetailDO);
+				});
+               /* }else{
+                    needSaveCboList.stream().forEach(needSaveCbo->{
+                        XMLResultDataObjectDetailDO resultDataObjectDetailDO=new XMLResultDataObjectDetailDO();
+                       // resultDataObjectDetailDO.setCode(needSaveCbo.getId());//涓嶇敤杩斿洖缂栫爜
+                        String oid=needSaveCbo.getOid();
+                        String sourceOid=oid;
+                        if(codeOidToSystemOidMap.containsKey(oid)){
+                            sourceOid=codeOidToSystemOidMap.get(oid);
+                        }
+                        resultDataObjectDetailDO.setId(sourceOid);
+                        resultDataObjectDetailDO.setErrorid("204");
+                        resultDataObjectDetailDO.setMsg("鐢宠缂栫爜鎴愬姛锛岀瓑寰呯紪鐮佺郴缁熷彂甯冿紒");
+                        resultDataObjectDetailDOs.add(resultDataObjectDetailDO);
+                    });
+
+                }*/
+			}catch (Throwable e){
+				e.printStackTrace();
+				needSaveCboList.stream().forEach(needSaveCbo->{
+					XMLResultDataObjectDetailDO resultDataObjectDetailDO=new XMLResultDataObjectDetailDO();
+					resultDataObjectDetailDO.setCode("");
+					String oid=needSaveCbo.getOid();
+					String sourceOid=oid;
+					if(codeOidToSystemOidMap.containsKey(oid)){
+						sourceOid=codeOidToSystemOidMap.get(oid);
+					}
+					resultDataObjectDetailDO.setId(sourceOid);
+					resultDataObjectDetailDO.setErrorid("1");
+					resultDataObjectDetailDO.setMsg("淇濆瓨鍑虹幇闂:"+e.getMessage());
+					resultDataObjectDetailDOs.add(resultDataObjectDetailDO);
+				});
+
+			}
+		}
 
 	}
 
+	/***
+	 * 闆嗘垚鎵归噺鍚屾鏇存柊鎺ュ彛
+	 * @param codeClassifyVO;
+	 * @param dataObjectVO 鏁版嵁淇℃伅
+	 * @param resultDataObjectDetailDOs 閿欒淇℃伅
+	 */
+	@Transactional(rollbackFor = VciBaseException.class)
 	@Override
 	public void batchSyncEditDatas(CodeClassifyVO codeClassifyVO, DataObjectVO dataObjectVO, LinkedList<XMLResultDataObjectDetailDO> resultDataObjectDetailDOs) {
+		String errorid="";
+		String msg="";
+		//鏌ヨ鍒嗙被鍜屾ā鏉�
+		//鍏堟壘鍒版瘡涓�琛岀殑鏍囬锛岀劧鍚庢牴鎹爣棰樻潵鑾峰彇瀵瑰簲鐨勫睘鎬�
+		List<RowDatas> rowDataList = dataObjectVO.getRowData();
+		Map<String, RowDatas> rowDataMap = new LinkedHashMap<>();
+		Map<String, RowDatas> codeDataMap = new LinkedHashMap<>();
+		rowDataList.stream().forEach(rowData -> {
+			rowDataMap.put(rowData.getRowIndex(), rowData);
+			codeDataMap.put(rowData.getCode(), rowData);
+		});
+		//鎵剧涓�琛岋紝涓轰簡鎵炬爣棰�
+		CodeClassifyTemplateVO templateVO = engineService.getUsedTemplateByClassifyOid(codeClassifyVO.getOid());
+		// 搴旇閮芥槸涓�涓垎绫讳笅鐨勪笟鍔℃暟鎹紝鎵剧涓�鏉＄殑灏辫
+		CodeClassifyFullInfoBO classifyFullInfo = classifyService.getClassifyFullInfo(codeClassifyVO.getOid());
+		//鏍￠獙妯℃澘鏄笉鏄渶鏂扮殑
+		//checkTemplateSync(sheetDataSetList,templateVO);
+		//闄ゅ幓榛樿鐨勫睘鎬�.杩樻湁鍙湁琛ㄥ崟鏄剧ず鐨勫瓧娈垫墠瀵煎叆
+		List<CodeClassifyTemplateAttrVO> attrVOS = templateVO.getAttributes().stream().filter(s -> !DEFAULT_SYNC_ATTR_LIST.contains(s.getId()) && VciBaseUtil.getBoolean(s.getFormDisplayFlag())
+		).collect(Collectors.toList());
+		Map<Integer/**鍒楀彿**/, String/**瀛楁鐨勫悕绉�**/> fieldIndexMap = new HashMap<>();
+		List<String> titleRowData = dataObjectVO.getColName();
+		Map<String/**涓枃鍚嶇О**/, String/**鑻辨枃鍚嶇О**/> attrNameIdMap = attrVOS.stream().collect(Collectors.toMap(s -> s.getName(), t -> t.getId().toLowerCase(Locale.ROOT), (o1, o2) -> o2));
+		getFieldIndexMap(titleRowData, attrNameIdMap, fieldIndexMap);
+		Map<String, String> cboOidMap = new HashMap<>();
+		cboOidMap.put("id", QueryOptionConstant.IN + "(" + VciBaseUtil.toInSql(codeDataMap.keySet().toArray(new String[0])) + ")");
+		String tableName ="";
+		try {
+			R<BtmTypeVO> r = btmTypeClient.getAllAttributeByBtmId(templateVO.getBtmTypeId());
+			if(!r.isSuccess()) {
+				throw new Throwable(r.getMsg());
+			}
+			BtmTypeVO btmTypeVO = r.getData();
+			if (btmTypeVO == null) {
+				throw new Throwable("鏍规嵁涓氬姟绫诲瀷鏈煡璇㈠埌涓氬姟绫诲瀷瀵硅薄锛�");
+			}
+			tableName = btmTypeVO.getTableName();
+			if (StringUtils.isBlank(tableName)) {
+				throw new Throwable("鏍规嵁涓氬姟绫诲瀷鏈煡璇㈠埌涓氬姟绫诲瀷鐩稿叧鑱旂殑琛�");
+			}
+		}catch (Throwable e){
+			log.error("鏌ヨ涓氬姟瀵硅薄琛�"+e);
+			XMLResultDataObjectDetailDO xmlResultDataObjectDetailDO=new XMLResultDataObjectDetailDO();
+			xmlResultDataObjectDetailDO.setErrorid("103");
+			xmlResultDataObjectDetailDO.setMsg("鏌ヨ涓氬姟瀵硅薄琛�"+e);
+			xmlResultDataObjectDetailDO.setId("");
+			xmlResultDataObjectDetailDO.setCode("");
+			resultDataObjectDetailDOs.add(xmlResultDataObjectDetailDO);
+			return;
+		}
 
+		StringBuffer sb=new StringBuffer();
+		sb.append(" select * from ");
+		sb.append(tableName);
+		sb.append(" where 1=1 ");
+		sb.append(" id in (");
+		sb.append(VciBaseUtil.toInSql(codeDataMap.keySet().toArray(new String[0])));
+		sb.append(")");
+		List<Map<String,String>> dataMapList=commonsMapper.queryByOnlySqlForMap(sb.toString());
+		List<ClientBusinessObject> cboList=	ChangeMapTOClientBusinessObjects(dataMapList);
+		Map<String, ClientBusinessObject> codeSystemObjectMap = cboList.stream().filter(systeDataObject -> systeDataObject != null && StringUtils.isNotBlank(systeDataObject.getId())).collect(Collectors.toList()).stream().collect(Collectors.toMap(s -> s.getId(), t -> t));
+		Map<String, String> errorMap = new HashMap<>();
+		List<CodeOrderDTO> codeOrderDTOList = new ArrayList<>();
+		this.getCodeOrderDTOs(codeClassifyVO, templateVO, codeDataMap, codeSystemObjectMap, codeOrderDTOList, errorMap);
+		// List<CodeClassifyProcessTempVO> codeClassifyProcessTempVOS=codeClassifyProcessTempService.listProcessTemplate(templateVO.getOid(),"code_cls_flow_use_order");
+		boolean isProcess=false;
+		/**  if(!CollectionUtils.isEmpty(codeClassifyProcessTempVOS)){
+		 isProcess=true;
+		 }**/
+
+		Map<String, CodeOrderDTO> orderDTOMap = codeOrderDTOList.stream().filter(orderDTO -> orderDTO != null && StringUtils.isNotBlank(orderDTO.getId())).collect(Collectors.toList()).stream().collect(Collectors.toMap(s -> s.getId(), t -> t));
+		List<BaseModel> updateList = new ArrayList<>();
+		List<CodeAllCode> codeAllCodeList = new ArrayList<>();
+		List<String> deleteList = new ArrayList<>();
+
+		CodeClassifyTemplateVO firstTemplateVO = templateService.getObjectHasAttrByOid(orderDTOMap.values().stream().findFirst().get().getTemplateOid());
+		Map<String, ClientBusinessObject> cboMap = cboList.stream().filter(cbo -> cbo != null).collect(Collectors.toList()).stream().collect(Collectors.toMap(s -> s.getId(), t -> t));
+		//  boolean finalIsProcess = isProcess;
+		orderDTOMap.keySet().stream().forEach(code -> {
+			CodeOrderDTO orderDTO = orderDTOMap.get(code);
+			ClientBusinessObject cbo = cboMap.get(code);
+			String dataStatus=cbo.getLcStatus();
+			RowDatas rowData=codeDataMap.get(code);
+			String status=rowData.getStatus();
+			String operation=rowData.getOperation();
+			if (cbo.getTs().compareTo(orderDTO.getTs())==0?true:false) {
+				// throw new VciBaseException("鏁版嵁涓嶆槸鏈�鏂扮殑锛屽彲鑳戒粬浜哄凡缁忎慨鏀癸紝璇峰埛鏂板悗鍐嶈瘯");
+				errorMap.put(orderDTO.getId(),errorMap.getOrDefault(orderDTO.getId(),"")+";鏁版嵁涓嶆槸鏈�鏂扮殑锛屽彲鑳戒粬浜哄凡缁忎慨鏀癸紝璇峰埛鏂板悗鍐嶈瘯");
+			}
+           /* if (!CodeDefaultLC.EDITING.getValue().equalsIgnoreCase(cbo.getLcStatus()) && !orderDTO.isEditInProcess()) {
+                throw new VciBaseException("鏁版嵁涓嶆槸{0}鐨勭姸鎬侊紝涓嶅厑璁镐慨鏀�", new String[]{CodeDefaultLC.EDITING.getText()});
+            }*/
+			if(operation.equals("update")) {
+				//1. 鍒ゆ柇蹇呰緭椤�
+				checkRequiredAttrOnOrder(templateVO, orderDTO, errorMap);
+				//2.鍏堟敞鍏ワ紝鍐嶇粍鍚堬紝鏈�鍚庢牎楠�
+				switchClassifyLevelOnOrder(templateVO, classifyFullInfo, orderDTO, errorMap);
+				//3.澶勭悊缁勫悎瑙勫垯銆傜粍鍚堣鍒欎笉鑳戒娇鐢ㄧ紪鐮佺殑灞炴�э紝鍥犱负缂栫爜鐨勭敓鎴愬彲鑳芥槸闇�瑕佸睘鎬х殑
+				switchComponentAttrOnOrder(templateVO, orderDTO);
+				//4.鏍￠獙瑙勫垯
+				checkVerifyOnOrder(templateVO, orderDTO, errorMap);
+				//5.鍒ゆ柇鍏抽敭灞炴��
+				checkKeyAttrOnOrder(classifyFullInfo, templateVO, orderDTO, errorMap);
+				//6.鏍￠獙鏋氫妇鐨勫唴瀹规槸鍚︽纭�
+				checkEnumOnOrder(templateVO, orderDTO, errorMap);
+				//7.澶勭悊鏃堕棿鏍煎紡锛屽湪鏁版嵁搴撻噷闈笉璁烘槸瀛楃涓茶繕鏄棩鏈熸牸寮忥紝閮戒娇鐢ㄧ浉鍚岀殑鏍煎紡瀛樺偍
+				switchDateAttrOnOrder(templateVO, orderDTO);
+				//榛樿鐨勫唴瀹逛笉鑳藉彉锛屾墍浠ュ彧闇�瑕佹嫹璐濊嚜瀹氫箟鐨勭浉鍏冲睘鎬у嵆鍙�
+				copyValueToCBO(classifyFullInfo, cbo, orderDTO, templateVO, true, errorMap);
+				//浼佷笟鐮佸拰闆嗗洟鐮佺殑涓嶄慨鏀�
+				cbo.setDescription(StringUtils.isBlank(orderDTO.getDescription())?"":orderDTO.getDescription());
+				cbo.setName(orderDTO.getName());
+				try {
+					cbo.setAttributeValueWithNoCheck("description", orderDTO.getDescription());
+					cbo.setAttributeValue("name", orderDTO.getName());
+					//  if(finalIsProcess){//鍦ㄦ祦绋嬩腑涓嶅厑璁告洿鏀�
+					//     errorMap.put(code,errorMap.getOrDefault(code, errorMap.getOrDefault(code,"")+";鏁版嵁"+code+"鍦ㄦ祦绋嬩腑锛屼笉鍏佽鏇存敼!"));
+					//  }else{
+					cbo.setLcStatus(status);
+					cbo.setAttributeValue("lcstatus",status);
+					//  }
+				} catch (VciBaseException e) {
+					e.printStackTrace();
+				}
+
+				List<CodeAllCode>newCodeAllCodeList= codeAllCodeService.selectByWrapper(Wrappers.<CodeAllCode>query().lambda().eq(CodeAllCode::getCreateCodeOid, cbo.getOid()));
+				if (!CollectionUtils.isEmpty(newCodeAllCodeList)) {
+					CodeAllCode codeCbo = codeAllCodeList.get(0);
+					log.info("codeCbos code:" + codeCbo.getId());
+					codeCbo.setLcStatus(status);
+					codeAllCodeList.add(codeCbo);
+				}
+
+				BaseModel baseModel=new BaseModel();
+				BeanUtil.convert(cbo,baseModel);
+				//baseModel.setData(VciBaseUtil.objectToMapString(cbo));
+				updateList.add(baseModel);
+			}else if(operation.equals("delete")){//濡傛灉鍦ㄦ祦绋嬩腑涓嶅厑璁稿垹闄わ紝涓嶅湪娴佺▼涓姸鎬佷负鍙戝竷鎴栬�呭仠鐢ㄧ殑鏁版嵁涓嶅厑璁稿垹闄わ紝灏嗗叾鏇存敼涓哄仠鐢紝鍏朵粬鐨勬儏鍐电洿鎺ュ垹闄�
+				//  if(finalIsProcess){
+				//    errorMap.put(code,errorMap.getOrDefault(code, errorMap.getOrDefault(code,"")+";鏁版嵁"+code+"鍦ㄦ祦绋嬩腑锛屼笉鍏佽鍒犻櫎!"));
+				//}else {
+				try {
+					log.info("oid:" + cbo.getOid());
+					List<CodeAllCode>newCodeAllCodeList= codeAllCodeService.selectByWrapper(Wrappers.<CodeAllCode>query().lambda().eq(CodeAllCode::getCreateCodeOid, cbo.getOid()));
+					log.info("codeCbos size:" + newCodeAllCodeList.size());
+					if (!CollectionUtils.isEmpty(newCodeAllCodeList)) {
+						CodeAllCode codeCbo = codeAllCodeList.get(0);
+						log.info("codeCbos code:" + codeCbo.getId());
+						codeCbo.setLcStatus(CodeDefaultLC.TASK_BACK.getValue());
+						codeAllCodeList.add(codeCbo);
+					}
+					deleteList.add(cbo.getOid());
+				}catch (VciBaseException e) {
+					e.printStackTrace();
+				}
+				// }
+			}else if(operation.equals("editstatus")){
+				try {
+					//  if (finalIsProcess) {
+					//      errorMap.put(code, errorMap.getOrDefault(code, errorMap.getOrDefault(code, "") + ";鏁版嵁" + code + "鍦ㄦ祦绋嬩腑锛屼笉鍏佽鏇存敼鐘舵��!"));
+					//   } else {
+					cbo.setLcStatus(status);
+					cbo.setAttributeValue("lcstatus", status);
+
+					//  }
+
+					List<CodeAllCode>newCodeAllCodeList= codeAllCodeService.selectByWrapper(Wrappers.<CodeAllCode>query().lambda().eq(CodeAllCode::getCreateCodeOid, cbo.getOid()));
+					if (!CollectionUtils.isEmpty(newCodeAllCodeList)) {
+						CodeAllCode codeCbo = codeAllCodeList.get(0);
+						log.info("codeCbos code:" + codeCbo.getId());
+						codeCbo.setLcStatus(status);
+						codeAllCodeList.add(codeCbo);
+					}
+
+					BaseModel baseModel=new BaseModel();
+					BeanUtil.convert(cbo,baseModel);
+					//baseModel.setData(VciBaseUtil.objectToMapString(cbo));
+					updateList.add(baseModel);
+				}catch (VciBaseException e) {
+					e.printStackTrace();
+				}
+			}
+		});
+		/**
+		 * 閿欒淇℃伅杈撳嚭
+		 */
+		if(errorMap.size()>0){
+			errorMap.keySet().forEach(code->{
+				if(codeDataMap.containsKey(code)){
+					RowDatas rowDatas=  codeDataMap.get(code);
+					String dataMsg=errorMap.get(code);
+					String oid=rowDatas.getOid();
+					XMLResultDataObjectDetailDO xmlResultDataObjectDetailDO=new XMLResultDataObjectDetailDO();
+					xmlResultDataObjectDetailDO.setErrorid("103");
+					xmlResultDataObjectDetailDO.setMsg(dataMsg);
+					xmlResultDataObjectDetailDO.setId(oid);
+					xmlResultDataObjectDetailDO.setCode(code);
+					resultDataObjectDetailDOs.add(xmlResultDataObjectDetailDO);
+				}
+			});
+		}else {
+			//瀛樺偍鏁版嵁
+			try {
+				engineService.updateBatchByBaseModel(classifyFullInfo.getTopClassifyVO().getBtmTypeId(),updateList);
+				codeAllCodeService.saveBatch(codeAllCodeList);
+				if(deleteList.size()>0) {
+					commonsMapper.deleteByTaleAndOid(tableName, VciBaseUtil.array2String(deleteList.toArray(new String[]{})));
+				}
+				errorid="0";
+				msg="鏇存柊/鐘舵�佹洿鏀�/鍒犻櫎鎴愬姛锛�";
+			}catch (Throwable e){
+				errorid="1";
+				msg="淇濆瓨澶辫触锛�"+e;
+			}finally {
+				String finalMsg = msg;
+				String finalErrorid = errorid;
+				cboList.stream().forEach(cbo->{
+					String code =cbo.getId();
+					if(codeDataMap.containsKey(code)) {
+						RowDatas rowDatas=codeDataMap.get(code);
+						String oid=rowDatas.getOid();
+						XMLResultDataObjectDetailDO xmlResultDataObjectDetailDO = new XMLResultDataObjectDetailDO();
+						xmlResultDataObjectDetailDO.setErrorid(finalErrorid);
+						xmlResultDataObjectDetailDO.setMsg(finalMsg);
+						xmlResultDataObjectDetailDO.setId(oid);
+						xmlResultDataObjectDetailDO.setCode(code);
+						resultDataObjectDetailDOs.add(xmlResultDataObjectDetailDO);
+					}
+				});
+
+			}
+		}
+	}
+
+	/**
+	 * 鏍￠獙灞炴�ф槸鍚︿负蹇呰緭
+	 *
+	 * @param templateVO 妯℃澘鐨勬樉绀哄璞★紝闇�瑕佸寘鍚ā鏉垮睘鎬�
+	 * @param orderDTO   缂栫爜鐢宠鐨勪俊鎭�
+	 */
+	private void checkRequiredAttrOnOrder(CodeClassifyTemplateVO templateVO, CodeOrderDTO orderDTO,Map<String,String> errorMap) {
+		Map<String, CodeClassifyTemplateAttrVO> requiredAttrMap = templateVO.getAttributes().stream().filter(
+				s -> VciBaseUtil.getBoolean(s.getRequireFlag()) && StringUtils.isBlank(s.getComponentRule())
+					&& StringUtils.isBlank(s.getClassifyInvokeAttr()))
+			.collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t));
+		if (!CollectionUtils.isEmpty(requiredAttrMap)) {
+			requiredAttrMap.forEach((attrId, attrVO) -> {
+				//鍙湁浼佷笟缂栫爜锛岀姸鎬侊紝澶囨敞锛屾ā鏉夸富閿紝鍒嗙被涓婚敭杩欏嚑涓槸鍥哄畾鐨勶紝鍏朵綑閮芥槸鑷閰嶇疆鐨�
+				if (StringUtils.isBlank(getValueFromOrderDTO(orderDTO, attrId))) {
+					errorMap.put(orderDTO.getId(),errorMap.getOrDefault(orderDTO.getId(),"") + ";灞炴�с�恵"+attrVO.getName()+"}銆戝繀椤昏杈撳叆(閫夋嫨)鍐呭" );
+					//  throw new VciBaseException("灞炴�с�恵0}銆戝繀椤昏杈撳叆(閫夋嫨)鍐呭", new String[]{attrVO.getName()});
+				}
+			});
+		}
+	}
+	/**
+	 * 杞崲缁勫悎瑙勫垯鐨勫��
+	 *
+	 * @param templateVO 妯℃澘鐨勬樉绀哄璞★紝闇�瑕佸寘鍚ā鏉垮睘鎬�
+	 * @param orderDTO   缂栫爜鐢宠鐨勪俊鎭�
+	 */
+	private void switchComponentAttrOnOrder(CodeClassifyTemplateVO templateVO, CodeOrderDTO orderDTO) {
+		Map<String, CodeClassifyTemplateAttrVO> compAttrVOMap = templateVO.getAttributes().stream().filter(s -> StringUtils.isNotBlank(s.getComponentRule())).collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t));
+		if (!CollectionUtils.isEmpty(compAttrVOMap)) {
+			Map<String, String> dataMap = WebUtil.objectToMapString(orderDTO);
+
+			Map<String, String> dataLowMap = new HashMap<>();
+			if (!CollectionUtils.isEmpty(dataMap)) {
+				dataMap.forEach((key, value) -> {
+					dataLowMap.put(key.toLowerCase(Locale.ROOT), value);
+				});
+			}
+			dataLowMap.putAll(orderDTO.getData());
+			compAttrVOMap.forEach((attrId, attrVO) -> {
+				dataLowMap.put(attrId, formulaService.getValueByFormula(dataLowMap, attrVO.getComponentRule()));
+			});
+			dataLowMap.forEach((key, value) -> {
+				setValueToOrderDTO(orderDTO, key, value);
+			});
+		}
+	}
+
+	/**
+	 * 鏍￠獙姝ｅ垯琛ㄨ揪寮忔槸鍚︽纭�
+	 *
+	 * @param templateVO 妯℃澘鐨勪俊鎭紝蹇呴』鍖呭惈灞炴�х殑鍐呭
+	 * @param orderDTO   缂栫爜鐢宠鐨勭浉鍏崇殑淇℃伅
+	 */
+	private void checkVerifyOnOrder(CodeClassifyTemplateVO templateVO, CodeOrderDTO orderDTO,Map<String,String> errorMap) {
+		Map<String, CodeClassifyTemplateAttrVO> verifyAttrVOMap = templateVO.getAttributes().stream().filter(s -> StringUtils.isNotBlank(s.getVerifyRule())).collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t));
+		if (!CollectionUtils.isEmpty(verifyAttrVOMap)) {
+			verifyAttrVOMap.forEach((attrId, attrVO) -> {
+				String value = getValueFromOrderDTO(orderDTO, attrId);
+				if (StringUtils.isNotBlank(value) && !value.matches(attrVO.getVerifyRule())) {
+					errorMap.put(orderDTO.getId(),errorMap.getOrDefault(orderDTO.getId(),"")+";灞炴�"+attrVO.getName()+"]鐨勫�间笉绗﹀悎鏍￠獙瑙勫垯鐨勮姹�");
+					//鏍￠獙姝ｅ垯琛ㄨ揪寮�
+					// throw new VciBaseException("灞炴�{0}]鐨勫�间笉绗﹀悎鏍￠獙瑙勫垯鐨勮姹�", new String[]{attrVO.getName()});
+				}
+			});
+		}
+	}
+	/**
+	 * 鏍￠獙鍏抽敭灞炴��
+	 *
+	 * @param classifyFullInfo 鍒嗙被鐨勫叏閮ㄤ俊鎭�
+	 * @param templateVO       妯℃澘鐨勫唴瀹癸紝蹇呴』鍖呭惈妯℃澘灞炴��
+	 * @param orderDTO         缂栫爜鐢宠鐨勭浉鍏崇殑淇℃伅
+	 */
+	private void checkKeyAttrOnOrder(CodeClassifyFullInfoBO classifyFullInfo, CodeClassifyTemplateVO templateVO, CodeOrderDTO orderDTO,Map<String,String> errorMap) {
+		//鍏堣幏鍙栧叧閿睘鎬х殑瑙勫垯锛屼篃鍒╃敤缁ф壙鐨勬柟寮�
+		CodeKeyAttrRepeatVO keyRuleVO = keyRuleService.getRuleByClassifyFullInfo(classifyFullInfo);
+		//娉ㄦ剰鐨勬槸keyRuleVO鍙兘涓虹┖锛岃〃绀轰笉浣跨敤瑙勫垯鎺у埗
+		//鑾峰彇鎵�鏈夌殑鍏抽敭灞炴��
+		Map<String, CodeClassifyTemplateAttrVO> ketAttrMap = templateVO.getAttributes().stream().filter(s -> VciBaseUtil.getBoolean(s.getKeyAttrFlag())).collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t));
+		Map<String, String> conditionMap = new HashMap<>();
+		boolean trimAll = keyRuleVO == null ? false : VciBaseUtil.getBoolean(keyRuleVO.getIgnoreallspaceflag());
+		//鍏ㄩ儴鍘荤┖鐨勪紭鍏堢骇澶т簬鍘荤┖
+		boolean trim = keyRuleVO == null ? false : VciBaseUtil.getBoolean(keyRuleVO.getIgnorespaceflag());
+		boolean ignoreCase = keyRuleVO == null ? false : VciBaseUtil.getBoolean(keyRuleVO.getIgnorecaseflag());
+		boolean ignoreWidth = keyRuleVO == null ? false : VciBaseUtil.getBoolean(keyRuleVO.getIgnorewidthflag());
+		ketAttrMap.forEach((attrId, attrVO) -> {
+			String value = getValueFromOrderDTO(orderDTO, attrId);
+			if (value == null) {
+				value = "";
+			}
+			engineService.wrapperKeyAttrConditionMap(value, keyRuleVO, attrId, trim, ignoreCase, ignoreWidth, trimAll, conditionMap);
+		});
+
+		//娌℃湁闄愬埗鍒嗙被锛屼絾鏄竴涓ā鏉垮彧鍙兘鍦ㄤ竴涓笟鍔＄被鍨嬮噷闈紝鎵�浠ョ洿鎺ユ煡璇㈣繖涓笟鍔＄被鍨嬪嵆鍙�
+
+		if (!CollectionUtils.isEmpty(conditionMap)) {
+			final String[] sql = {"select count(*) from " + VciBaseUtil.getTableName(classifyFullInfo.getTopClassifyVO().getBtmTypeId()) + " where 1 = 1 "};
+			conditionMap.forEach((key, value) -> {
+				sql[0] += " and " + key + " = " + value;
+			});
+			if (StringUtils.isNotBlank(orderDTO.getOid())) {
+				//淇敼鐨勬椂鍊欙紝闇�瑕佹帓闄よ嚜宸�
+				sql[0] += " and oid != '" + orderDTO.getOid() + "'";
+			} else if (StringUtils.isNotBlank(orderDTO.getCopyFromVersion())) {
+				sql[0] += " and oid != '" + orderDTO.getCopyFromVersion() + "'";
+			}
+			sql[0] += " and lastR = '1' and lastV = '1' ";
+			if (commonsMapper.queryCountBySql(sql[0]) > 0) {
+				String ruleInfoMsg = keyRuleVO == null ? "" : "鏌ヨ瑙勫垯锛氬幓闄ょ┖鏍�--{0},蹇界暐澶у皬鍐�--{1},蹇界暐鍏ㄥ崐瑙�--{2},蹇界暐鍏ㄩ儴绌烘牸--{3}";
+				String[] objs = new String[]{trim ? "鏄�" : "鍚�", ignoreCase ? "鏄�" : "鍚�", ignoreWidth ? "鏄�" : "鍚�", trimAll ? "鏄�" : "鍚�"};
+				String defaultValue=";鏍规嵁鎮ㄥ～鍐欑殑鍏抽敭灞炴�х殑鍐呭锛岀粨鍚堝叧閿睘鎬ф煡璇㈣鍒欙紝鍙戠幇杩欎釜鏁版嵁宸茬粡鍦ㄧ郴缁熶腑瀛樺湪浜嗐�傝淇!銆�";
+				String errormsg=defaultValue+ MessageFormat.format(ruleInfoMsg, objs);
+				errorMap.put(orderDTO.getId(),errorMap.getOrDefault(orderDTO.getId(),"")+errormsg);
+				// throw new VciBaseException("鏍规嵁鎮ㄥ～鍐欑殑鍏抽敭灞炴�х殑鍐呭锛岀粨鍚堝叧閿睘鎬ф煡璇㈣鍒欙紝鍙戠幇杩欎釜鏁版嵁宸茬粡鍦ㄧ郴缁熶腑瀛樺湪浜嗐�傝淇!銆�" + ruleInfoMsg, objs);
+			}
+		}
+	}
+	/**
+	 * 鏍￠獙鏋氫妇鐨勫唴瀹�
+	 *
+	 * @param templateVO 妯℃澘鐨勬樉绀哄璞★紝闇�瑕佸寘鍚睘鎬�
+	 * @param orderDTO   缂栫爜鐢宠鐨勪俊鎭�
+	 */
+	private void checkEnumOnOrder(CodeClassifyTemplateVO templateVO, CodeOrderDTO orderDTO,Map<String,String> errorMap) {
+		//濡傛灉鏋氫妇鍙互淇敼锛屽垯涓嶉渶瑕佹牎楠屾槸鍚︾鍚堟灇涓剧殑閫夐」
+		Map<String, CodeClassifyTemplateAttrVO> enumAttrVOMap = templateVO.getAttributes().stream().filter(s -> (StringUtils.isNotBlank(s.getEnumString()) || StringUtils.isNotBlank(s.getEnumId())) && !VciBaseUtil.getBoolean(s.getEnumEditFlag())).collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t));
+		if (!CollectionUtils.isEmpty(enumAttrVOMap)) {
+			enumAttrVOMap.forEach((attrId, attrVO) -> {
+				String value = getValueFromOrderDTO(orderDTO, attrId);
+				if (StringUtils.isNotBlank(value)) {
+					//鏈夊�兼墠鑳芥牎楠�
+					List<KeyValue> comboboxKVs = this.engineService.listComboboxItems(attrVO);
+					if (!comboboxKVs.stream().anyMatch(s -> value.equalsIgnoreCase(s.getKey()))) {
+						errorMap.put(orderDTO.getId(),errorMap.getOrDefault(orderDTO.getId(),"")+";灞炴�с��"+attrVO.getName()+"銆戠殑鍊间笉绗﹀悎鏋氫妇鐨勮姹�");
+						//throw new VciBaseException("灞炴�с�恵0}銆戠殑鍊间笉绗﹀悎鏋氫妇鐨勮姹�", new String[]{attrVO.getName()});
+					}
+				}
+			});
+		}
+	}
+	/**
+	 * 杞崲鏃堕棿鐨勬牸寮�
+	 *
+	 * @param templateVO 妯℃澘鐨勬樉绀哄璞★紝闇�瑕佸寘鍚睘鎬�
+	 * @param orderDTO   缂栫爜鐢宠鐨勪俊鎭�
+	 */
+	private void switchDateAttrOnOrder(CodeClassifyTemplateVO templateVO, CodeOrderDTO orderDTO) {
+		Map<String, CodeClassifyTemplateAttrVO> dateAttrVOMap = templateVO.getAttributes().stream().filter(s -> StringUtils.isNotBlank(s.getCodeDateFormat())).collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t));
+		if (!CollectionUtils.isEmpty(dateAttrVOMap)) {
+			dateAttrVOMap.forEach((attrId, attrVO) -> {
+				String value = getValueFromOrderDTO(orderDTO, attrId);
+				if (StringUtils.isNotBlank(value)) {
+					DateConverter dateConverter = new DateConverter();
+					dateConverter.setAsText(value);
+					value = VciDateUtil.date2Str(dateConverter.getValue(), VciDateUtil.DateTimeMillFormat);
+					setValueToOrderDTO(orderDTO, attrId, value);
+				}
+			});
+		}
+	}
+
+	/**
+	 * 鎷疯礉鏁版嵁鍒癱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);
+		});
 	}
 
 	/**
@@ -1728,7 +2857,118 @@
 			}
 		});
 	}
+	/**
+	 * 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 鍒嗙被鐨勫叏閮ㄤ俊鎭�
@@ -1740,7 +2980,7 @@
 		String fullPath = getFullPath(classifyFullInfo);
 		codeImprotDataVO.getDatas().stream().forEach(rowData -> {
 			ClientBusinessObject cbo=new ClientBusinessObject();
-			DefaultAttrAssimtUtil.addDefaultAttrAssimt(cbo, classifyFullInfo.getTopClassifyVO().getBtmtypeid());
+			DefaultAttrAssimtUtil.addDefaultAttrAssimt(cbo, classifyFullInfo.getTopClassifyVO().getBtmTypeId());
 			rowData.forEach((field,value)->{
 				try {
 					cbo.setAttributeValueWithNoCheck(field,value);
@@ -1758,11 +2998,12 @@
 					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) ){
+					int secret = VciBaseUtil.getInt(cbo.getAttributeValue(SECRET_FIELD));
+					if(secret == 0 || !secretService.checkDataSecret(secret).getData() ){
 						Integer userSecret = VciBaseUtil.getCurrentUserSecret();
 						cbo.setAttributeValue(SECRET_FIELD,String.valueOf((userSecret==null || userSecret ==0)? UserSecretEnum.NONE.getValue():userSecret));
-					}*/
+					}
+					cbo.setLcStatus(CodeDefaultLC.EDITING.getValue());
 				}else{
 					//姝ゆ椂杩樻病鏈夎浆鎹㈣矾寰�
 					//cbo.setAttributeValue(CODE_FULL_PATH_FILED, childOidPathMap.getOrDefault(rowData.getData().getOrDefault(CODE_CLASSIFY_OID_FIELD,""),fullPath));
@@ -1792,7 +3033,7 @@
 							String fullPath,boolean newCode){
 		rowDataList.stream().forEach(rowData -> {
 			ClientBusinessObject cbo=new ClientBusinessObject();
-			 DefaultAttrAssimtUtil.addDefaultAttrAssimt(cbo, classifyFullInfo.getTopClassifyVO().getBtmtypeid());
+			 DefaultAttrAssimtUtil.addDefaultAttrAssimt(cbo, classifyFullInfo.getTopClassifyVO().getBtmTypeId());
 			rowData.getData().forEach((index,value)->{
 				String field = fieldIndexMap.get(index);
 				if (StringUtils.isBlank(field)) {
@@ -1815,10 +3056,11 @@
 					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) ){
+					if(secret == 0 || !secretService.checkDataSecret(secret).getData() ){
 						Integer userSecret = VciBaseUtil.getCurrentUserSecret();
 						cbo.setAttributeValue(SECRET_FIELD,String.valueOf((userSecret==null || userSecret ==0)? UserSecretEnum.NONE.getValue():userSecret));
-					}*/
+					}
+					cbo.setLcStatus(CodeDefaultLC.EDITING.getValue());
 				}else{
 					//姝ゆ椂杩樻病鏈夎浆鎹㈣矾寰�
 					//cbo.setAttributeValue(CODE_FULL_PATH_FILED, childOidPathMap.getOrDefault(rowData.getData().getOrDefault(CODE_CLASSIFY_OID_FIELD,""),fullPath));
@@ -2095,21 +3337,35 @@
 	 * @param cboList 鏁版嵁鐨勫垪琛�
 	 * @param errorMap 閿欒鐨勪俊鎭�
 	 */
-	private void batchCheckIdExistOnOrder(CodeClassifyTemplateVO templateVO,List<ClientBusinessObject> cboList,Map<String ,String> errorMap){
+	private void batchCheckIdExistOnOrder(CodeClassifyTemplateVO templateVO,List<ClientBusinessObject> cboList,Map<String ,String> errorMap) throws Throwable{
 		List<String> existIds = new ArrayList<>();
+		String tableName ="";
+		try {
+			R<BtmTypeVO> r = btmTypeClient.getAllAttributeByBtmId(templateVO.getBtmTypeId());
+			if(!r.isSuccess()) {
+				throw new Throwable(r.getMsg());
+			}
+			BtmTypeVO btmTypeVO = r.getData();
+			if (btmTypeVO == null) {
+				throw new Throwable("鏍规嵁涓氬姟绫诲瀷鏈煡璇㈠埌涓氬姟绫诲瀷瀵硅薄锛�");
+			}
+			tableName = btmTypeVO.getTableName();
+			if (StringUtils.isBlank(tableName)) {
+				throw new Throwable("鏍规嵁涓氬姟绫诲瀷鏈煡璇㈠埌涓氬姟绫诲瀷鐩稿叧鑱旂殑琛�");
+			}
+		}catch (Throwable e){
+			throw e;
+		}
+		String finalTableName = tableName;
 		VciBaseUtil.switchCollectionForOracleIn(cboList).stream().forEach(cbos -> {
 			Map<String, String> conditionMap = new HashMap<>();
 			conditionMap.put("id", QueryOptionConstant.IN + "(" + VciBaseUtil.toInSql(cbos.stream().map(s -> s.getId()).collect(Collectors.toSet()).toArray(new String[0])) + ")");
 
-			R<BtmTypeVO>  r= btmTypeClient.getDetail(templateVO.getBtmTypeId());
-			BtmTypeVO btmTypeVO =r.getData();
-			String tableName=btmTypeVO.getTableName();
-
 			StringBuffer sb=new StringBuffer();
 			sb.append(" select id from ");
-			sb.append(tableName);
+			sb.append(finalTableName);
 			sb.append(" where 1=1 ");
-			sb.append(" id in (");
+			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());
@@ -2420,7 +3676,8 @@
 		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));
+		//resultVO.setSelfRepeatRowIndexList(getSelfRepeatRowIndex(ketAttrMap,cboList,keyRuleVO));
+		getSelfRepeatRowIndex(ketAttrMap,cboList,keyRuleVO,resultVO);
 		if(!CollectionUtils.isEmpty(resultVO.getSelfRepeatRowIndexList())){
 			//鎴戜滑绉婚櫎鏈韩閲嶅鐨勬暟鎹�
 			cboList = cboList.stream().filter(s->!resultVO.getSelfRepeatRowIndexList().contains(s.getAttributeValue(IMPORT_ROW_INDEX))).collect(Collectors.toList());
@@ -2428,7 +3685,7 @@
 		//2.鍒ゆ柇鍏抽敭灞炴�у湪绯荤粺閲屾槸鍚﹂噸澶�
 		//鍥犱负鏁版嵁閲忓緢澶э紝鎵�浠ュ緱鎯冲姙娉曞苟琛�
 		//SessionInfo sessionInfo = VciBaseUtil.getCurrentUserSessionInfo();
-		Map<String,List<ClientBusinessObject>> indexTODataMap=new HashMap<>();
+		Map<String,List<BaseModel>> indexTODataMap=new HashMap<>();
 		List<ClientBusinessObject> repeatDataMap = cboList.parallelStream().filter(cbo -> {
 			//姣忚閮藉緱鏌ヨ.濡傛灉鍏朵腑鍑虹幇浜嗛敊璇紝鎴戜滑灏辩洿鎺ユ姏鍑哄紓甯革紝鍏朵綑鐨勬樉绀�
 			//VciBaseUtil.setCurrentUserSessionInfo(sessionInfo);
@@ -2442,12 +3699,20 @@
 				engineService.wrapperKeyAttrConditionMap(value, keyRuleVO, attrId, trim, ignoreCase, ignoreWidth, trimAll, conditionMap);
 			});
 			if (!CollectionUtils.isEmpty(ketAttrMap)) {
-				CodeTemplateAttrSqlBO sqlBO = engineService.getSqlByTemplateVO(classifyFullInfo.getTopClassifyVO().getBtmtypeid(), templateVO, conditionMap, null);
+				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);
-					indexTODataMap.put(cbo.getAttributeValue(IMPORT_ROW_INDEX),newCboList);
+					//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{
@@ -2457,7 +3722,7 @@
 		if(!CollectionUtils.isEmpty(repeatDataMap)){
 			resultVO.setKeyAttrRepeatRowIndexList(repeatDataMap.stream().map(s->s.getAttributeValue(IMPORT_ROW_INDEX)).collect(Collectors.toSet()));
 		}
-		//resultVO.setIndexTODataMap(indexTODataMap);
+		resultVO.setIndexTODataMap(indexTODataMap);
 		//resultVO.setSuccess(true);
 		return resultVO;
 	}
@@ -2503,12 +3768,12 @@
 										List<String> unExistRuleClassifyOidList   ){
 		if(!CollectionUtils.isEmpty(classifyVOMap)){
 			classifyVOMap.values().parallelStream().forEach(classifyVO->{
-				if(StringUtils.isNotBlank(classifyVO.getCoderuleoid())){
-					ruleOidMap.put(classifyVO.getOid(),classifyVO.getCoderuleoid());
+				if(StringUtils.isNotBlank(classifyVO.getCodeRuleOid())){
+					ruleOidMap.put(classifyVO.getOid(),classifyVO.getCodeRuleOid());
 				}else{
 					//閫掑綊鎵句笂绾�
 					List<String> ruleOidList = new ArrayList<>();
-					recursionRule(classifyVOMap,classifyVO.getParentcodeclassifyoid(),ruleOidList);
+					recursionRule(classifyVOMap,classifyVO.getParentCodeClassifyOid(),ruleOidList);
 					if(!CollectionUtils.isEmpty(ruleOidList)){
 						ruleOidMap.put(classifyVO.getOid(),ruleOidList.get(0));
 					}else{
@@ -2528,11 +3793,11 @@
 	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());
+			if(StringUtils.isNotBlank(classifyVO.getCodeRuleOid())){
+				ruleOidList.add(classifyVO.getCodeRuleOid());
 				return;
 			}else{
-				recursionRule(classifyVOMap,classifyVO.getParentcodeclassifyoid(),ruleOidList);
+				recursionRule(classifyVOMap,classifyVO.getParentCodeClassifyOid(),ruleOidList);
 			}
 		}else{
 			Map<String, CodeClassifyVO> parentClassifyVOMap=new HashMap<>();
@@ -2571,9 +3836,10 @@
 	 * @param keyRuleVO 鍏抽敭灞炴�ф帶鍒惰鍒�
 	 * @return 閲嶅鐨勮鍙�
 	 */
-	private Set<String> getSelfRepeatRowIndex(Map<String/**灞炴�х殑缂栧彿**/, CodeClassifyTemplateAttrVO> ketAttrMap,
-											  List<ClientBusinessObject> dataList,CodeKeyAttrRepeatVO keyRuleVO){
+	private void getSelfRepeatRowIndex(Map<String/**灞炴�х殑缂栧彿**/, CodeClassifyTemplateAttrVO> ketAttrMap,
+											  List<ClientBusinessObject> dataList,CodeKeyAttrRepeatVO keyRuleVO,CodeImportResultVO resultVO){
 		Set<String> selfRepeatRowIndexList = new CopyOnWriteArraySet<>();
+		Map<String,List<String>> keyAttrOkOidTORepeatOidMap=new HashMap<>();
 		boolean trimAll =keyRuleVO ==null?false: VciBaseUtil.getBoolean(keyRuleVO.getIgnoreallspaceflag());
 		//鍏ㄩ儴鍘荤┖鐨勪紭鍏堢骇澶т簬鍘荤┖
 		boolean trim =keyRuleVO ==null?false:  VciBaseUtil.getBoolean(keyRuleVO.getIgnorespaceflag());
@@ -2582,8 +3848,10 @@
 		//蹇呴』灏嗗睘鎬ф寜鐓ч『搴忔帓搴忓ソ
 		List<CodeClassifyTemplateAttrVO> attrVOList = ketAttrMap.values().stream().sorted(((o1, o2) -> o1.getOrderNum().compareTo(o2.getOrderNum()))).collect(Collectors.toList());
 		Map<String/**琛屽彿**/,String/**鍏抽敭灞炴�х殑缁勫悎鍐呭**/> rowIndexKeyStringMap = new HashMap<>();
+		Map<String/**鍏抽敭灞炴�х殑缁勫悎鍐呭**/,String/**绗竴涓叧閿睘鎬х殑鏁版嵁oid**/> okOidKeyStringMap = new HashMap<>();
 		dataList.parallelStream().forEach(cbo-> {
 			String rowIndex = cbo.getAttributeValue(IMPORT_ROW_INDEX);
+			String oid=cbo.getOid();
 			StringBuilder sb = new StringBuilder();
 			for (int i = 0; i < attrVOList.size(); i++) {
 				CodeClassifyTemplateAttrVO attrVO = attrVOList.get(i);
@@ -2609,12 +3877,25 @@
 			String keyString = sb.toString();
 			if(rowIndexKeyStringMap.containsValue(keyString) && StringUtils.isNotBlank(keyString)){
 				selfRepeatRowIndexList.add(rowIndex);
+				String okOid=okOidKeyStringMap.getOrDefault(keyString,"");
+				if(StringUtils.isBlank(okOid)){
+					List<String>newOidList=new ArrayList<>();
+					newOidList.add(oid);
+					if(keyAttrOkOidTORepeatOidMap.containsKey(okOid)){
+						List<String> oldOidList=	keyAttrOkOidTORepeatOidMap.get(okOid);
+						newOidList.addAll(oldOidList);
+
+					}
+					keyAttrOkOidTORepeatOidMap.put(okOid,newOidList);
+				}
 			}else {
+				okOidKeyStringMap.put(sb.toString(),oid);
 				rowIndexKeyStringMap.put(rowIndex, sb.toString());
 			}
 		});
 		//鍥犱负鍙槸鍏抽敭灞炴�ч噸澶嶏紝鎵�浠ユ垜浠笉鑳介噸澶嶇殑澶氭潯閫変竴鏉℃潵鎶ラ敊
-		return selfRepeatRowIndexList;
+		resultVO.setKeyAttrRepeatRowIndexList(selfRepeatRowIndexList);
+		resultVO.setKeyAttrOkOidTORepeatOidMap(keyAttrOkOidTORepeatOidMap);
 	}
 	/**
 	 * excel鐨勬爣棰樹笂鑾峰彇瀛楁鎵�鍦ㄧ殑浣嶇疆
@@ -2642,13 +3923,15 @@
 		}
 	}
 	private List<ClientBusinessObject> ChangeMapTOClientBusinessObjects(List<Map<String,String>> oldDataMap){
-		List<ClientBusinessObject> clientBusinessObjectList=new CopyOnWriteArrayList<>();
-		oldDataMap.parallelStream().forEach(dataMap->{
+		List<ClientBusinessObject> clientBusinessObjectList=new ArrayList<>();
+		oldDataMap.stream().forEach(dataMap->{
 			ClientBusinessObject clientBusinessObject=new ClientBusinessObject();
 			DefaultAttrAssimtUtil.copplyDefaultAttrAssimt(dataMap,clientBusinessObject);
-			dataMap.forEach((key,value)->{
-				clientBusinessObject.setAttributeValue(key,value);
-			});
+			for (String key:dataMap.keySet()){
+				Object value= dataMap.getOrDefault(key,"");
+				clientBusinessObject.setAttributeValue(key,value.toString());
+			}
+			clientBusinessObjectList.add(clientBusinessObject);
 		});
 		return clientBusinessObjectList;
 	}
@@ -2924,8 +4207,8 @@
 			}else{
 				if (!CollectionUtils.isEmpty(conditionMap)) {
 					Map<String, String> andConditionMap = new HashMap<>();
-					andConditionMap.put("islastr", "1");
-					andConditionMap.put("islastv", "1");
+					andConditionMap.put("lastr", "1");
+					andConditionMap.put("lastv", "1");
 					conditionMap.putAll(andConditionMap);
 					PageHelper pageHelper = new PageHelper(-1);
 					pageHelper.addDefaultDesc("id");
@@ -3073,4 +4356,5 @@
 			}
 		}
 	}
+
 }

--
Gitblit v1.9.3