From 93db5b42a725ded6bd1cc41981804bc8649c03ba Mon Sep 17 00:00:00 2001
From: 田源 <lastanimals@163.com>
Date: 星期四, 14 三月 2024 15:30:13 +0800
Subject: [PATCH] func vaildate添加说明注释

---
 Source/UBCS/ubcs-service/ubcs-code/src/main/java/com/vci/ubcs/code/service/impl/MdmIOServiceImpl.java | 1100 +++++++++++++++++++++++++++++++++++++++++++++++++--------
 1 files changed, 934 insertions(+), 166 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 b5998d2..db7167c 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
@@ -5,18 +5,15 @@
 import com.alibaba.nacos.common.utils.StringUtils;
 import com.baomidou.mybatisplus.core.toolkit.Wrappers;
 import com.google.protobuf.ServiceException;
-import com.vci.ubcs.code.applyjtcodeservice.entity.DockingPreAttrMapping;
 import com.vci.ubcs.code.applyjtcodeservice.feign.IMdmInterJtClient;
 import com.vci.ubcs.code.applyjtcodeservice.vo.DockingPreAttrMappingVO;
 import com.vci.ubcs.code.bo.AttributeValue;
 import com.vci.ubcs.code.bo.CodeClassifyFullInfoBO;
 import com.vci.ubcs.code.bo.CodeTemplateAttrSqlBO;
-import com.vci.ubcs.code.constant.MdmEngineConstant;
 import com.vci.ubcs.code.dto.*;
 import com.vci.ubcs.code.entity.CodeAllCode;
-import com.vci.ubcs.code.enumpack.CodeDefaultLC;
-import com.vci.ubcs.code.enumpack.CodeLevelTypeEnum;
-import com.vci.ubcs.code.enumpack.sysIntegrationPushTypeEnum;
+import com.vci.ubcs.code.entity.CodeSynonym;
+import com.vci.ubcs.code.enumpack.*;
 import com.vci.ubcs.code.lifecycle.CodeAllCodeLC;
 import com.vci.ubcs.code.mapper.CommonsMapper;
 import com.vci.ubcs.code.service.*;
@@ -50,6 +47,7 @@
 import com.vci.ubcs.starter.web.util.*;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
+import oracle.sql.TIMESTAMP;
 import org.apache.commons.collections4.map.HashedMap;
 import org.apache.poi.hssf.usermodel.HSSFRichTextString;
 import org.apache.poi.hssf.usermodel.HSSFWorkbook;
@@ -58,6 +56,8 @@
 import org.apache.poi.ss.usermodel.RichTextString;
 import org.apache.poi.ss.usermodel.Workbook;
 import org.springblade.core.redis.cache.BladeRedis;
+import org.springblade.core.secure.BladeUser;
+import org.springblade.core.secure.utils.AuthUtil;
 import org.springblade.core.tool.api.R;
 import org.springblade.core.tool.utils.Func;
 import org.springblade.core.tool.utils.StringUtil;
@@ -68,14 +68,24 @@
 import org.springframework.transaction.annotation.Transactional;
 import org.springframework.util.CollectionUtils;
 import javax.annotation.Resource;
+import javax.xml.bind.ValidationEvent;
+import java.beans.BeanInfo;
+import java.beans.Introspector;
+import java.beans.PropertyDescriptor;
 import java.io.File;
 import java.io.IOException;
+import java.lang.reflect.Method;
+import java.math.BigDecimal;
 import java.text.MessageFormat;
 import java.text.SimpleDateFormat;
+import java.time.LocalDateTime;
+import java.time.ZoneId;
+import java.time.ZonedDateTime;
 import java.util.*;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.CopyOnWriteArrayList;
 import java.util.concurrent.CopyOnWriteArraySet;
+import java.util.concurrent.ForkJoinPool;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicReference;
 import java.util.stream.Collectors;
@@ -88,7 +98,6 @@
 @Service
 @Slf4j
 public class MdmIOServiceImpl implements MdmIOService {
-
 
 	/**
 	 * 瀛楁
@@ -134,7 +143,7 @@
 	 * 妯℃澘鐨勬湇鍔�
 	 */
 	@Resource
-	private CodeClstemplateServiceImpl templateService;
+	private ICodeClstemplateService templateService;
 
 	/**
 	 * 涓绘暟鎹紩鎿庣殑鏈嶅姟
@@ -157,30 +166,40 @@
 	private ICodeKeyAttrRepeatService keyRuleService;
 
 	/**
+	 * 杩戜箟璇嶈鍒欐煡璇㈡湇鍔�
+	 */
+	@Autowired ICodeSynonymService codeSynonymService;
+
+	/**
 	 * 鍏紡鐨勬湇鍔�
 	 */
 	@Autowired
 	private FormulaServiceImpl formulaService;
+
 	/**
 	 * 瑙勫垯鐨勬湇鍔�
 	 */
 	@Autowired
 	private ICodeRuleService ruleService;
+
 	/**
 	 * 涓氬姟绫诲瀷鐨勬湇鍔�
 	 */
 	@Autowired
 	private IBtmTypeClient btmTypeClient;
+
 	/***
 	 * 鐢宠闆嗗洟缂栫爜鏈嶅姟
 	 */
 	@Resource
 	private IMdmInterJtClient mdmInterJtClient;
+
 	/***
 	 * 瀵嗙骇鏈嶅姟
 	 */
 	@Resource
 	private IWebSecretClient secretService;
+
 	/**
 	 * 鏃ュ織淇濆瓨宸ュ叿绫�
 	 */
@@ -188,9 +207,14 @@
 	private SaveLogUtil saveLogUtil;
 
 	/**
-	 * 瀵煎嚭鐨勫崄涓囨潯
+	 * 瀹㈡埛鐜板満excel涓鸿�佺増鏈紝瀵煎嚭鐨勬�绘暟闄愬埗涓�65535
 	 */
-	public static final int EXPORT_LIMIT = 100000;
+	public static final int EXPORT_LIMIT = 65535;
+
+	/**
+	 * 鑷畾涔夊苟鍙慒orkJoinPool
+	 */
+	private static final ForkJoinPool customForkJoinPool = new ForkJoinPool(Runtime.getRuntime().availableProcessors()-1);
 
 	/**
 	 * 鎵归噺鐢宠锛氶�夊彇閫変腑鍒嗙被涓嬬殑鎵�鏈夋ā鏉垮叧閿睘鎬э紝鐩镐技灞炴�э紝蹇呭～灞炴�э紝鍐欏叆execl涓�
@@ -371,7 +395,7 @@
 		CodeClassifyVO codeClassifyVO = classifyService.getObjectByOid(codeClassifyOid);
 
 		//鑾峰彇鐮佹瀹藉害
-		//String secWidth = getCodeSegmentWidth(codeClassifyVO.getOid());
+		String secWidth = getCodeSegmentWidth(codeClassifyVO.getOid());
 
 		if(isHistory){
 			templateVOList= templateService.childTemplates(codeClassifyOid);
@@ -422,6 +446,8 @@
 				excelDataList.add(new WriteExcelData(0,0,"鍒嗙被璺緞",""));
 				excelDataList.add(new WriteExcelData(0,1,"鐮佹瀹藉害",""));
 				excelDataList.add(new WriteExcelData(0,2,!CollectionUtils.isEmpty(idAttrVOList)?idAttrVOList.get(0).getName():"浼佷笟缂栫爜",idAttrVOList.get(0).getId()));
+				// 濉厖鐮佹
+				excelDataList.add(new WriteExcelData(1,1,secWidth));
 			}
 			for (int i = 0; i < templateAttrVOS.size(); i++) {
 				CodeClassifyTemplateAttrVO attrVO = templateAttrVOS.get(i);
@@ -486,27 +512,243 @@
 	}
 
 	/**
+	 * 鐢熸垚鎵归噺淇敼瀵煎叆鐨勬枃浠�
+	 *
+	 * @param codeClassifyOid 鍒嗙被鐨勪富閿�
+	 * @return excel鐨勬枃浠跺湴鍧�
+	 */
+	@Override
+	public String downloadImportExcelBatchEdit(String codeClassifyOid) {
+		List<CodeClassifyTemplateVO> templateVOList=new ArrayList<>();
+		VciBaseUtil.alertNotNull("瀵煎嚭妯℃澘","瀵煎嚭鐨勯厤缃�",codeClassifyOid,"涓婚搴撳垎绫荤殑涓婚敭");
+
+		CodeClassifyVO codeClassifyVO = classifyService.getObjectByOid(codeClassifyOid);
+
+		templateVOList= templateService.childTemplates(codeClassifyOid);
+
+		WriteExcelOption eo = new WriteExcelOption();
+		eo.setAppend(true);
+		//澧炲姞妯℃澘鐨勪俊鎭鍏�
+		LinkedList<WriteExcelData> tempEDList = new LinkedList<>();
+		tempEDList.add(new WriteExcelData(0,0,"缂栧彿"));
+		for(int j=0;j<templateVOList.size();j++){
+			CodeClassifyTemplateVO  templateVO=templateVOList.get(j);
+			CodeClassifyTemplateVO codeClassifyTemplateVO = new CodeClassifyTemplateVO();
+			BeanUtils.copyProperties(templateVO,codeClassifyTemplateVO);
+			//缁勫悎鏍煎紡鐨勪笉瀵煎叆锛�
+			// 鏋氫妇鐨勬彁渚涘簭鍒楃殑閫夋嫨
+			//鏃堕棿鍏ㄩ儴缁熶竴涓簓yyy-MM-dd HH:mm:ss
+			//鍙傜収鐨勮嚜琛岃緭鍏ュ悕绉�
+			//鍒嗙被娉ㄥ叆鐨勪笉鐢紝閮芥槸瀵煎叆鍚庤嚜鍔ㄥ鐞嗙殑
+			//缂栫爜锛岀姸鎬佺瓑瀛楁涓嶅鍏�
+			List<CodeClassifyTemplateAttrVO> codeClassifyTemplateAttrVOList=codeClassifyTemplateVO.getAttributes();
+			if(!CollectionUtils.isEmpty(codeClassifyTemplateAttrVOList)) {
+				if (CollectionUtils.isEmpty(codeClassifyTemplateAttrVOList)) {
+					throw new VciBaseException("妯℃澘娌℃湁閰嶇疆灞炴��");
+				}
+			}
+			List<CodeClassifyTemplateAttrVO> templateAttrVOS = codeClassifyTemplateAttrVOList.stream().filter(s ->
+				!DEFAULT_ATTR_LIST.contains(s.getId())
+					&& StringUtils.isBlank(s.getComponentRule())
+					&& StringUtils.isBlank(s.getClassifyInvokeAttr())
+					&& (VciBaseUtil.getBoolean(s.getFormDisplayFlag()))
+			).collect(Collectors.toList());
+
+			if (CollectionUtils.isEmpty(templateAttrVOS)) {
+				throw new VciBaseException("妯℃澘娌℃湁閰嶇疆浠讳綍銆愯〃鍗曟樉绀恒�戜负銆愭槸銆戠殑灞炴��");
+			}
+
+//			List<CodeClassifyTemplateAttrVO> idAttrVOList = codeClassifyTemplateVO.getAttributes().stream().filter(s -> s.getId().equalsIgnoreCase(CODE_FIELD)).collect(Collectors.toList());
+			LinkedList<WriteExcelData> excelDataList = new LinkedList<>();
+			Workbook workbook = new HSSFWorkbook();
+//			if(isHistory){
+			excelDataList.add(new WriteExcelData(0,0,"缂栫爜(id)",""));
+//				excelDataList.add(new WriteExcelData(0,1,"鐮佹瀹藉害",""));
+//			excelDataList.add(new WriteExcelData(0,1,!CollectionUtils.isEmpty(idAttrVOList)?idAttrVOList.get(0).getName():"浼佷笟缂栫爜",idAttrVOList.get(0).getId()));
+//			}
+			for (int i = 0; i < templateAttrVOS.size(); i++) {
+				CodeClassifyTemplateAttrVO attrVO = templateAttrVOS.get(i);
+
+				Object text = attrVO.getName();
+				text = exportKeyAndRequired(workbook,attrVO,text);
+				int colIndex = 1 + i;
+				WriteExcelData excelData = new WriteExcelData(0, colIndex, text,attrVO.getId());
+				if(StringUtils.isNotBlank(attrVO.getCodeDateFormat())
+					|| VciFieldTypeEnum.VTDateTime.name().equalsIgnoreCase(attrVO.getAttributeDataType())
+					|| VciFieldTypeEnum.VTDate.name().equalsIgnoreCase(attrVO.getAttributeDataType())
+					||VciFieldTypeEnum.VTTime.name().equalsIgnoreCase(attrVO.getAttributeDataType())){
+					excelData.setDateFormat(VciDateUtil.DateTimeFormat);
+				}
+				if(text instanceof RichTextString){
+					excelData.setFontColor(String.valueOf(HSSFColor.HSSFColorPredefined.RED.getIndex()));
+				}
+				excelDataList.add(excelData);
+				if(StringUtils.isNotBlank(attrVO.getEnumString()) || StringUtils.isNotBlank(attrVO.getEnumId())){
+					//娣诲姞鏁版嵁鏈夋晥鎬�
+					List<String> enumValueList = new ArrayList<>();
+					enumValueList.add("");
+					List<KeyValue> valueList = engineService.listComboboxItems(attrVO);
+					if(!CollectionUtils.isEmpty(valueList)){
+						valueList.stream().forEach(kv->{
+							enumValueList.add(kv.getValue());
+						});
+					}
+					//榛樿鍔�1涓囨潯
+					WriteExcelData ed = new WriteExcelData(1,colIndex,"");
+					ed.setRowTo(100);
+					ed.setColTo(colIndex);
+					ed.setValidation(true);
+					ed.setValidationDataList(enumValueList);
+					ed.setValidationErrorMsg("璇峰湪搴忓垪涓�夋嫨姝ｇ‘鐨勫��");
+					excelDataList.add(ed);
+				}
+				if(VciFieldTypeEnum.VTBoolean.name().equalsIgnoreCase(attrVO.getAttributeDataType())){
+					List<String> booleanList = new ArrayList<>();
+
+					booleanList.add("鏄�");
+					booleanList.add("鍚�");
+					//榛樿鍔�1涓囨潯
+					WriteExcelData ed = new WriteExcelData(1,colIndex,"");
+					ed.setRowTo(100);
+					ed.setColTo(colIndex);
+					ed.setValidation(true);
+					ed.setValidationDataList(booleanList);
+					ed.setValidationErrorMsg("璇峰湪搴忓垪涓�夋嫨姝ｇ‘鐨勫��");
+					excelDataList.add(ed);
+				}
+			}
+			eo.addSheetDataList(j+templateVO.getName(),excelDataList);
+			tempEDList.add(new WriteExcelData(j+1,0,templateVO.getOid()));
+			tempEDList.add(new WriteExcelData(j+1,1,templateVO.getId()));
+			tempEDList.add(new WriteExcelData(j+1,2,templateVO.getName()));
+		}
+		String excelName = LocalFileUtil.getDefaultTempFolder() + File.separator + codeClassifyVO.getName() + ("_灞炴�ф壒閲忎慨鏀规ā鏉�.xls");
+		eo.addSheetDataList(templateVOList.size()+"妯℃澘淇℃伅銆愯鍕垮垹闄ゆ垨绉诲姩銆�",tempEDList);
+		ExcelUtil.writeDataToFile(excelName,eo);
+		return excelName;
+	}
+
+	/**
 	 * 鑾峰彇鐮佹瀹藉害
 	 * @param codeClassifyOid
 	 * @return
 	 */
 	private String getCodeSegmentWidth(String codeClassifyOid){
-		CodeClassifyVO codeClassifyVO = classifyService.getObjectByOid(codeClassifyOid);
+		CodeClassifyFullInfoBO classifyFullInfoBO = classifyService.getClassifyFullInfo(codeClassifyOid);
 		// 瑕佽幏鍙栫爜娈靛搴︼紝鍏堣鑾峰彇瑙勫垯锛屽綋鍓嶆病鏈夊線涓婃壘
 		CodeRuleVO codeRuleByClassifyFullInfo = mdmEngineService.getCodeRuleByClassifyFullInfo(classifyService.getClassifyFullInfo(codeClassifyOid));
 		List<CodeBasicSecVO> secVOList = codeRuleByClassifyFullInfo.getSecVOList();
 		if(secVOList.isEmpty()){
 			return "";
 		}
-
 		StringBuffer secWidth = new StringBuffer("");
-
-		for (int j = 0; j < secVOList.size(); j++) {
-			CodeBasicSecVO secVO = secVOList.get(j);
-			int width = VciBaseUtil.getInt(secVO.getCodeSecLength()) + ((secVO.getPrefixCode() + secVO.getSuffixCode()).length());
-			secWidth.append(width).append("#");
-		}
+		secVOList.stream().forEach(item->{
+			switch (item.getSecType().toLowerCase(Locale.ROOT)){
+				case "codeclassifysec":
+				case "codevariablesec":
+				case "coderefersec":
+				case "codefixedsec":
+				case "codeattrsec":
+				case "codeserialsec":
+					countSecWith(item,secWidth);
+					break;
+				case "codelevelsec":
+					//灞傜骇鐮佹锛岄渶瑕佷粠鍒嗙被涓婅幏鍙栫浉搴旂殑淇℃伅
+					String secValue = "";
+					if (CodeLevelTypeEnum.MIN.getValue().equalsIgnoreCase(item.getCodeLevelType())) {
+						//鏈�灏忓眰锛屽洜涓烘垜浠彧鑳藉湪鍙跺瓙鑺傜偣涓婄敵璇风紪鐮侊紝鎵�浠ヨ繖涓氨鏄綋鍓嶅垎绫荤殑
+						if (CodeGetValueTypeEnum.CURRENT.getValue().equalsIgnoreCase(item.getCodeGetValueType()) || CollectionUtils.isEmpty(classifyFullInfoBO.getParentClassifyVOs())) {
+							//灏辨槸褰撳墠鍒嗙被鐨�
+							secValue = classifyFullInfoBO.getCurrentClassifyVO().getId();
+						} else {
+							//鎴戜滑闇�瑕佷粠椤跺眰寮�濮嬫壘鍒板綋鍓嶅垎绫讳负姝�
+							secValue = classifyFullInfoBO.getParentClassifyVOs().stream().sorted(((o1, o2) -> -o1.getDataLevel().compareTo(o2.getDataLevel()))).map(CodeClassifyVO::getId).collect(Collectors.joining()) + classifyFullInfoBO.getCurrentClassifyVO().getId();
+						}
+					} else {
+						//鎸囧畾灞傦紝鎴戜滑闇�瑕侀�氳繃涓婄骇鐨勬潵鑾峰彇
+						if (CollectionUtils.isEmpty(classifyFullInfoBO.getParentClassifyVOs())) {
+							//璇存槑褰撳墠宸茬粡鏄渶楂樼殑浜�
+							secValue = classifyFullInfoBO.getCurrentClassifyVO().getId();
+						} else {
+							//杩欎釜鎴戜滑闇�瑕佺湅鐪�,灞傜骇鏄笉鏄ぇ浜庝簡鏈�澶у眰绾х殑鏁�
+							List<CodeClassifyVO> parentClassifyVOList = classifyFullInfoBO.getParentClassifyVOs().stream().sorted(((o1, o2) -> -o1.getDataLevel().compareTo(o2.getDataLevel()))).collect(Collectors.toList());
+							if (item.getCodeLevelValue() > (parentClassifyVOList.size() + 1)) {
+								//鎸囧畾鐨勫眰绾ф瘮褰撳墠鐨勫眰绾ц繕澶т簡锛屾墍浠ュ彧鑳借幏鍙栧綋鍓嶅眰绾т簡
+								if (CodeGetValueTypeEnum.CURRENT.getValue().equalsIgnoreCase(item.getCodeGetValueType())) {
+									secValue = classifyFullInfoBO.getCurrentClassifyVO().getId();
+								} else {
+									secValue = parentClassifyVOList.stream().map(CodeClassifyVO::getId).collect(Collectors.joining()) + classifyFullInfoBO.getCurrentClassifyVO().getId();
+								}
+							} else {
+								//鎴戜滑鑾峰彇鍏朵腑鎸囧畾灞傜殑鍐呭
+								if (CodeGetValueTypeEnum.CURRENT.getValue().equalsIgnoreCase(item.getCodeGetValueType())) {
+									CodeClassifyVO classifyVO = parentClassifyVOList.stream().filter(s -> s.getDataLevel().intValue() == item.getCodeLevelValue().intValue()).findFirst().orElseGet(() -> null);
+									if (classifyVO != null) {
+										secValue = classifyVO.getId();
+									}
+								} else {
+									//灏忎簬绛変簬鐨勫叏閮ㄦ嬁鍑烘潵
+									secValue = parentClassifyVOList.stream().filter(s -> s.getDataLevel().intValue() <= item.getCodeLevelValue().intValue()).sorted(((o1, o2) -> -o1.getDataLevel().compareTo(o2.getDataLevel()))).map(CodeClassifyVO::getId).collect(Collectors.joining());
+								}
+							}
+						}
+					}
+					//鐪嬬湅闀垮害鏄惁闇�瑕佹埅鏂�
+					if (!CodeCutTypeEnum.NONE.getValue().equalsIgnoreCase(item.getValueCutType()) &&
+						item.getValueCutLength() != null && item.getValueCutLength() > 0 && secValue.length() > item.getValueCutLength()) {
+						if (CodeCutTypeEnum.RIGHT.getValue().equalsIgnoreCase(item.getValueCutType())) {
+							//宸︽埅鍙栨槸浠庡乏杈瑰壀鎺夛紝鍙虫埅鍙栨槸浠庡彸杈瑰壀鎺�--淇濈暀宸﹁竟
+							secValue = secValue.substring(0, item.getValueCutLength());
+						} else {
+							secValue = secValue.substring(secValue.length() - item.getValueCutLength());
+						}
+					}
+					secValue = productCodeService.joinPreffixAndSuffix(item,secValue);
+					secWidth.append(secValue.length()).append("#");
+					break;
+				case "codedatesec":
+					String dateFormatStr = item.getCodeDateFormatStr();
+					if(Func.isNotEmpty(dateFormatStr)) {
+						// 鑾峰彇褰撳墠鏃堕棿
+						Date currentDate = new Date();
+						// 鎸囧畾鏃ユ湡鏍煎紡
+						SimpleDateFormat dateFormat = new SimpleDateFormat(dateFormatStr);
+						// 灏嗗綋鍓嶆椂闂磋浆鎹负鎸囧畾鏃ユ湡鏍煎紡
+						// 浣跨敤姝ｅ垯琛ㄨ揪寮忓幓鎺夐櫎鏁板瓧浠ュ鐨勬墍鏈夊瓧绗︿覆
+						String cleanedDate = dateFormat.format(currentDate).replaceAll("[^0-9]", "");
+						int width = cleanedDate.length();
+						if (Func.isNotEmpty(item.getPrefixCode())) {
+							width += item.getPrefixCode().length();
+						}
+						if (Func.isNotEmpty(item.getSuffixCode())) {
+							width += item.getSuffixCode().length();
+						}
+						secWidth.append(width).append("#");
+					}
+					break;
+			}
+		});
 		return secWidth.toString().substring(0, secWidth.length() - 1);
+	}
+
+	/**
+	 * 璁＄畻鐮佹闀垮害鍔犲墠鍚庣紑鐨勯暱搴�
+	 * @param codeBasicSecVO
+	 * @param secWidth
+	 */
+	private void countSecWith(CodeBasicSecVO codeBasicSecVO,StringBuffer secWidth){
+		if(Func.isNotEmpty(codeBasicSecVO.getCodeSecLength())){
+			int width = VciBaseUtil.getInt(codeBasicSecVO.getCodeSecLength());
+			if(Func.isNotEmpty(codeBasicSecVO.getPrefixCode())){
+				width += codeBasicSecVO.getPrefixCode().length();
+			}
+			if(Func.isNotEmpty(codeBasicSecVO.getSuffixCode())){
+				width += codeBasicSecVO.getSuffixCode().length();
+			}
+			secWidth.append(width).append("#");
+		}else {
+			secWidth.append(0).append("#");
+		}
 	}
 
 	/**
@@ -645,7 +887,8 @@
 
 			//闄ゅ幓榛樿鐨勫睘鎬�.杩樻湁鍙湁琛ㄥ崟鏄剧ず鐨勫瓧娈垫墠瀵煎叆
 			List<CodeClassifyTemplateAttrVO> attrVOS = templateVO.getAttributes().stream().filter(s ->
-				!DEFAULT_ATTR_LIST.contains(s.getId()) && VciBaseUtil.getBoolean(s.getFormDisplayFlag())
+				!DEFAULT_ATTR_LIST.contains(s.getId()) &&
+					((Func.isNotEmpty(s.getClassifyInvokeAttr()) || Func.isNotEmpty(s.getClassifyInvokeAttrName())) || VciBaseUtil.getBoolean(s.getFormDisplayFlag()))
 			).collect(Collectors.toList());
 
 			Map<String/**妯℃澘灞炴�у瓧娈祇id**/, String /**妯℃澘灞炴�у閮ㄥ悕绉�**/> fieldNameMap =attrVOS.stream().collect(Collectors.toMap(CodeClassifyTemplateAttrVO::getId,s->s.getName()));
@@ -694,17 +937,17 @@
 			//2.鍒ゆ柇蹇呰緭椤广�傘�傞渶瑕佸叏閮ㄧ殑灞炴�э紝濡傛灉鏄繀杈擄紝浣嗘槸琛ㄥ崟閲岄潰涓嶆樉绀虹殑锛屽彧鑳芥槸鍒嗙被娉ㄥ叆鎴栬�呯粍鍚堣鍒�
 			batchCheckRequiredAttrOnOrder(templateVO,allCboList,errorMap);
 			//3.鍒ゆ柇鍏抽敭灞炴��
-			CodeImportResultVO keyResultVO = batchCheckKeyAttrOnOrder(classifyFullInfo, templateVO, allCboList,errorMap);
+			CodeImportResultVO keyResultVO = batchCheckKeyAttrOnOrder(classifyFullInfo, templateVO, allCboList,false,errorMap);
 			Set<String> selfRepeatRowIndexList = keyResultVO.getSelfRepeatRowIndexList();
 			Set<String> keyAttrRepeatRowIndexList = keyResultVO.getKeyAttrRepeatRowIndexList();
 			if(!CollectionUtils.isEmpty(selfRepeatRowIndexList)){
 				selfRepeatRowIndexList.stream().forEach(rowIndex->{
-					errorMap.put(rowIndex,errorMap.getOrDefault(rowIndex,"") + ";鍦ㄥ綋鍓嶅鐞嗙殑鏁版嵁鏂囦欢涓叧閿睘鎬ч噸澶�" );
+					errorMap.put(rowIndex, errorMap.getOrDefault(rowIndex, "") + String.format(";鍦ㄥ綋鍓嶅鐞嗙殑鏁版嵁鏂囦欢涓叧閿睘鎬ч噸澶峓%s],[%s];",keyResultVO.getKeyAttrRuleInfo(),keyResultVO.getSynonymRuleInfo()));
 				});
 			}
 			if(!CollectionUtils.isEmpty(keyAttrRepeatRowIndexList)){
 				keyAttrRepeatRowIndexList.stream().forEach(rowIndex->{
-					errorMap.put(rowIndex, "鍏抽敭灞炴�т笌绯荤粺涓殑閲嶅;" + errorMap.getOrDefault(rowIndex,"") );
+					errorMap.put(rowIndex, errorMap.getOrDefault(rowIndex, "") + String.format("鍏抽敭灞炴�т笌绯荤粺涓殑閲嶅[%s],[%s];",keyResultVO.getKeyAttrRuleInfo(),keyResultVO.getSynonymRuleInfo()));
 				});
 			}
 			//鍒嗙被娉ㄥ叆
@@ -727,9 +970,7 @@
 			//鏈�鍚庡紕缁勫悎瑙勫垯
 			batchSwitchComponentAttrOnOrder(attrVOS,allCboList);
 
-
 			Map<String, ClientBusinessObject> rowIndexCboMap = allCboList.stream().filter(cbo -> cbo != null).collect(Collectors.toList()).stream().collect(Collectors.toMap(s -> s.getAttributeValue((IMPORT_ROW_INDEX)), t -> t));
-
 
 			List<ClientBusinessObject> needSaveCboList = allCboList.stream().filter(cbo -> {
 				String rowIndex = cbo.getAttributeValue(IMPORT_ROW_INDEX);
@@ -739,6 +980,7 @@
 			Map<String,String>resembleMap=new HashMap<>();
 			List<DataResembleVO> dataResembleVOS=new ArrayList<>();
 			String btmtypeid= classifyFullInfo.getTopClassifyVO().getBtmTypeId();
+			//鐩镐技椤规煡璇㈣鍒�
 			bathcResembleQuery(codeClassifyOid,templateVO,needSaveCboList,resembleMap,btmtypeid,dataResembleVOS);
 			if(resembleMap.size()>0) {
 				if(!CollectionUtils.isEmpty(dataResembleVOS)) {
@@ -967,17 +1209,17 @@
 				batchSwitchComponentAttrOnOrder(attrVOS, cboList);
 
 				//3.鍒ゆ柇鍏抽敭灞炴��
-				CodeImportResultVO keyResultVO = batchCheckKeyAttrOnOrder(classifyFullInfo, templateVO, cboList,errorMap);
+				CodeImportResultVO keyResultVO = batchCheckKeyAttrOnOrder(classifyFullInfo, templateVO, cboList,false,errorMap);
 				Set<String> selfRepeatRowIndexList = keyResultVO.getSelfRepeatRowIndexList();
 				Set<String> keyAttrRepeatRowIndexList = keyResultVO.getKeyAttrRepeatRowIndexList();
 				if (!CollectionUtils.isEmpty(selfRepeatRowIndexList)) {
 					selfRepeatRowIndexList.stream().forEach(rowIndex -> {
-						errorMap.put(rowIndex, errorMap.getOrDefault(rowIndex, "") + ";鍦ㄥ綋鍓峞xcel鏂囦欢涓叧閿睘鎬ч噸澶�");
+						errorMap.put(rowIndex, errorMap.getOrDefault(rowIndex, "") + String.format(";鍦ㄥ綋鍓峞xcel鏂囦欢涓叧閿睘鎬ч噸澶峓%s],[%s];",keyResultVO.getKeyAttrRuleInfo(),keyResultVO.getSynonymRuleInfo()));
 					});
 				}
 				if (!CollectionUtils.isEmpty(keyAttrRepeatRowIndexList)) {
 					keyAttrRepeatRowIndexList.stream().forEach(rowIndex -> {
-						errorMap.put(rowIndex, "鍏抽敭灞炴�т笌绯荤粺涓殑閲嶅;" + errorMap.getOrDefault(rowIndex, ""));
+						errorMap.put(rowIndex, errorMap.getOrDefault(rowIndex, "") + String.format("鍏抽敭灞炴�т笌绯荤粺涓殑閲嶅[%s],[%s];",keyResultVO.getKeyAttrRuleInfo(),keyResultVO.getSynonymRuleInfo()));
 					});
 				}
 				//4.鏍￠獙瑙勫垯
@@ -1048,6 +1290,7 @@
 				Map<String, String> resembleMap = new HashMap<>();
 				List<DataResembleVO> dataResembleVOS = new ArrayList<>();
 				String btmtypeid = classifyFullInfo.getTopClassifyVO().getBtmTypeId();
+				// 鐩镐技椤规煡璇�
 				bathcResembleQuery(templateVO.getCodeclassifyoid(), templateVO, needSaveCboList, resembleMap, btmtypeid, dataResembleVOS);
 				if (resembleMap.size() > 0) {
 					if (!CollectionUtils.isEmpty(dataResembleVOS)) {
@@ -1055,6 +1298,7 @@
 						createRedisDatas(uuid + "-resemble", templateVO, rowIndexCboMap, dataSet, fieldIndexMap, resembleMap, false);
 					}
 				}
+
 				//鐢熸垚class缂撳瓨
 				Map<String, String> rowIndexClsOidMap = cboList.stream().filter(cbo -> cbo != null).collect(Collectors.toList()).stream().collect(Collectors.toMap(s -> s.getAttributeValue((IMPORT_ROW_INDEX)), t -> t.getAttributeValue(CODE_CLASSIFY_OID_FIELD)));
 				createRedisByCodeClassify(uuid + "-class",templateVO,dataSet,fieldIndexMap,true);
@@ -1080,6 +1324,7 @@
 					//SessionInfo sessionInfo = VciBaseUtil.getCurrentUserSessionInfo();
 					List<ClientBusinessObject> finalNeedSaveCboList = needSaveCboList;
 					CodeClassifyTemplateVO finalTemplateVO = templateVO;
+					final BladeUser user = AuthUtil.getUser();
 					ruleRowIndexMap.keySet().parallelStream().forEach(ruleOid -> {
 						//VciBaseUtil.setCurrentUserSessionInfo(sessionInfo);
 						List<String> rowIndexList = ruleRowIndexMap.get(ruleOid);
@@ -1096,7 +1341,7 @@
 						if (!CollectionUtils.isEmpty(thisCbos)) {
 							try {
 								// TODO 澶氱嚎绋嬫祦闂
-								productCodeService.productCodeAndSaveData(classifyFullInfo, finalTemplateVO, ruleVOMap.get(ruleOid), null, dataCBOList);
+								productCodeService.productCodeAndSaveData(classifyFullInfo, finalTemplateVO, ruleVOMap.get(ruleOid), null, dataCBOList,user);
 								importCount.add(dataCBOList.size());
 							} catch (Throwable e) {
 								log.error("鎵归噺浜х敓缂栫爜鐨勬椂鍊欏嚭閿欎簡", e);
@@ -1114,8 +1359,6 @@
 					engineService.batchSaveSelectChar(templateVO, dataCBOIdList);
 				}
 			}
-			//long end = System.currentTimeMillis();
-			//log.info("=============for鎵ц鏃堕棿================="+String.valueOf((end-start)/1000));
 			String excelFileName="";
 			if(isExport&&!CollectionUtils.isEmpty(shetNameMap)) {
 				excelFileName = LocalFileUtil.getDefaultTempFolder() + File.separator + "閿欒淇℃伅.xls";
@@ -1129,14 +1372,17 @@
 					throw new VciBaseException(LangBaseUtil.getErrorMsg(e));
 				}
 				ExcelUtil.writeDataToFile(excelFileName, eo);
+				saveLogUtil.operateLog("鍘嗗彶鏁版嵁瀵煎叆",true, StringUtil.format("閿欒淇℃伅锛歿}",JSON.toJSONString(shetNameMap)));
+			}else{
+				// 鍘嗗彶鏁版嵁瀵煎叆鏃跺嚭鐜颁簡鐩镐技椤硅繑鍥炵粨鏋滄椂涓嶇畻瀵煎叆鎴愬姛
+				if(shetNameMap.isEmpty() || !isCreateUUid){
+					saveLogUtil.operateLog("鍘嗗彶鏁版嵁瀵煎叆",false, StringUtil.format("瀵煎叆鍒板垎绫粄}涓紝瀵煎叆鎴愬姛鎬绘暟涓猴細{}", JSON.toJSONString(classifyFullInfo), Func.isEmpty(importCount) ? 0:importCount.get(0)));
+				}
 			}
 			CodeImProtRusultVO codeImProtRusultVO=new CodeImProtRusultVO();
 			if(StringUtils.isNotBlank(excelFileName)) {
 				codeImProtRusultVO.setFilePath(excelFileName);
 				codeImProtRusultVO.setFileOid("");
-				saveLogUtil.operateLog("鍘嗗彶鏁版嵁瀵煎叆",true, StringUtil.format("閿欒淇℃伅锛歿}",JSON.toJSONString(shetNameMap)));
-			}else{
-				saveLogUtil.operateLog("鍘嗗彶鏁版嵁瀵煎叆",false, StringUtil.format("瀵煎叆鍒板垎绫粄}涓紝瀵煎叆鎴愬姛鎬绘暟涓猴細{}", JSON.toJSONString(classifyFullInfo),importCount.get(0)));
 			}
 			if(isCreateUUid){
 				codeImProtRusultVO.setRedisUuid(uuid);
@@ -1148,6 +1394,131 @@
 		}
 	}
 
+	/**
+	 * 瀵煎叆鎵归噺缂栬緫鏁版嵁
+	 *
+	 * @param codeClassifyOid 鍒嗙被鐨勪富閿�
+	 * @param classifyAttr 鍒嗙被璺緞浣跨敤鐨勫睘鎬�
+	 * @param file            excel鏂囦欢鐨勪俊鎭�
+	 * @return 鏈夐敊璇俊鎭殑excel
+	 */
+	@Transactional
+	@Override
+	public CodeImProtRusultVO batchImportEdit(String codeClassifyOid, String classifyAttr,File file) throws  Throwable{
+		VciBaseUtil.alertNotNull(codeClassifyOid,"鍒嗙被鐨勪富閿�");
+		ReadExcelOption reo = new ReadExcelOption();
+		reo.setReadAllSheet(true);
+		List<SheetDataSet> sheetDataSetList = ExcelUtil.readDataObjectFromExcel(file,null,reo);
+		if (sheetDataSetList.get(0).getRowData().size() > LIMIT + 1) {
+			throw new ServiceException("涓轰簡淇濊瘉绯荤粺鐨勭ǔ瀹氭�э紝璇蜂竴娆′笉瑕佸鍏ヨ秴杩�1涓囨潯鐨勬暟鎹�");
+		}
+		if (sheetDataSetList.get(0).getRowData().size() == 0) {
+			throw new ServiceException("鏈鍙栧埌excle鐩稿叧鏁版嵁锛岃纭锛侊紒锛�");
+		}
+		boolean isExport=false;
+		Map<String,List<WriteExcelData>> shetNameMap=new HashMap<>();
+		for(int i=0;i<sheetDataSetList.size()-1;i++) {
+			if (CollectionUtils.isEmpty(sheetDataSetList) || CollectionUtils.isEmpty(sheetDataSetList.get(i).getRowData())
+				|| sheetDataSetList.get(i).getRowData().size() < 1) {
+				continue;
+			}
+			// 鍗曟瀵煎叆鏁伴噺闄愬埗
+			if(sheetDataSetList.get(i).getRowData().size() > IMPORT_DATA_LIMIT){
+				throw new ServiceException("涓轰簡淇濊瘉绯荤粺鐨勭ǔ瀹氭�э紝璇蜂竴娆′笉瑕佸鍏ヨ秴杩�"+IMPORT_DATA_LIMIT+"鏉＄殑鏁版嵁");
+			}
+			//鏌ヨ鍒嗙被鍜屾ā鏉�
+			CodeClassifyFullInfoBO classifyFullInfo = classifyService.getClassifyFullInfo(codeClassifyOid);
+
+			//鍏堟壘鍒版瘡涓�琛岀殑鏍囬锛岀劧鍚庢牴鎹爣棰樻潵鑾峰彇瀵瑰簲鐨勫睘鎬�
+			SheetDataSet dataSet = sheetDataSetList.get(i);
+			List<SheetRowData> rowDataList = dataSet.getRowData();
+
+			//鎵剧涓�琛岋紝涓轰簡鎵炬爣棰�
+			CodeClassifyTemplateVO templateVO ;
+			//閮借浆鎹㈠畬浜嗐�傞渶瑕佹壒閲忔鏌�
+			//鎵炬墍鏈夌殑鍒嗙被璺緞,闇�瑕佹牎楠岃矾寰勬槸鍚︽纭紝鏄惁閮藉湪褰撳墠鐨勫垎绫荤殑涓嬬骇
+			List<CodeClassifyVO> childClassifyVOs = classifyService.listChildrenClassify(codeClassifyOid, true, classifyAttr, true);
+			Map<String/**璺緞**/, CodeClassifyVO> pathMap = Optional.ofNullable(childClassifyVOs).orElseGet(() -> new ArrayList<>()).stream().collect(Collectors.toMap(s -> s.getPath().startsWith("#") ? s.getPath().substring(1) : s.getPath(), t -> t));
+			List<String> titleRowData = dataSet.getColName();
+			Map<String, String> errorMap = new ConcurrentHashMap<>();
+			pathMap.put("#current#",classifyFullInfo.getCurrentClassifyVO());
+
+			try {
+				titleRowData.add("鍒嗙被璺緞");
+				List<CodeClassifyTemplateVO> templateVOList= checkSamesTemplate(titleRowData,sheetDataSetList,i,pathMap,errorMap);
+				titleRowData.remove(titleRowData.size()-1);
+				templateVO= templateVOList.get(0);
+			}catch (Throwable e){
+				throw new ServiceException(e.getMessage());
+			}
+
+			CodeClassifyTemplateVO finalTemplateVO = templateVO;
+
+			List<SheetRowData> needowDataList = rowDataList.stream().filter(cbo -> {
+				String rowIndex = cbo.getRowIndex();
+				return !errorMap.containsKey(rowIndex);
+			}).collect(Collectors.toList());
+			//杩欓噷涓嶉櫎鍘婚粯璁ょ殑灞炴��
+			List<CodeClassifyTemplateAttrVO> attrVOS = templateVO.getAttributes();
+			Map<Integer/**鍒楀彿**/, String/**瀛楁鐨勫悕绉�**/> fieldIndexMap = new HashMap<>();
+
+			Map<String/**涓枃鍚嶇О**/, String/**鑻辨枃鍚嶇О**/> attrNameIdMap = attrVOS.stream().collect(Collectors.toMap(s -> s.getName(), t -> t.getId()));
+			fieldIndexMap.put(0,"id");
+			getFieldIndexMap(titleRowData, attrNameIdMap, fieldIndexMap);
+			//鍏堜笉鐢ㄧ灞炴�ф槸鍚﹂兘瀛樺湪锛屽厛杞崲涓�涓嬫暟鎹�
+			CodeOrderDTO orderDTO = new CodeOrderDTO();
+			for (SheetRowData sheetRowData : needowDataList) {
+				//鏌ヨ鏁版嵁
+				Map<String, String> conditionMap = new HashMap<>();
+				conditionMap.put("t.id", sheetRowData.getData().get(0));
+				conditionMap.put("t.lastv", "1");
+				CodeTemplateAttrSqlBO sqlBO = mdmEngineService.getSqlByTemplateVO(classifyFullInfo.getTopClassifyVO().getBtmTypeId(), templateVO, conditionMap, new PageHelper(-1));
+				//鎴戜滑浣跨敤鍜屼笟鍔＄被鍨嬬殑鏉ユ煡璇�
+				List<Map> cbosB = commonsMapper.selectBySql(sqlBO.getSqlUnPage());
+				if(cbosB.size() == 0){
+					throw new ServiceException("缂栫爜锛�"+ sheetRowData.getData().get(0) + ",鏈兘鏌ヨ鍒扮浉鍏虫暟鎹��");
+				}
+				excelToCboEdit(fieldIndexMap, sheetRowData, orderDTO, cbosB.get(0));
+				orderDTO.setCopyFromVersion(orderDTO.getOid());
+				orderDTO.setOid(null);
+				try {
+					mdmEngineService.upSaveCode(orderDTO);
+				} catch (Throwable e) {
+					log.error("鎵归噺浜х敓缂栫爜鐨勬椂鍊欏嚭閿欎簡", e);
+					errorMap.put(sheetRowData.getRowIndex(), ";绯荤粺閿欒锛屽瓨鍌ㄦ暟鎹殑鏃跺�欏嚭閿欎簡:"+e.getMessage());
+				}
+			}
+			if (errorMap.size() > 0) {
+				isExport = true;
+			}
+			createWriteExcelData(rowDataList, errorMap, new ArrayList<>(), titleRowData, shetNameMap, finalTemplateVO);
+
+		}
+		String excelFileName="";
+		if(isExport&&!CollectionUtils.isEmpty(shetNameMap)) {
+			excelFileName = LocalFileUtil.getDefaultTempFolder() + File.separator + "閿欒淇℃伅.xls";
+			WriteExcelOption eo = new WriteExcelOption();
+			shetNameMap.forEach((shetName, errorDataList) -> {
+				eo.addSheetDataList(shetName, errorDataList);
+			});
+			try {
+				new File(excelFileName).createNewFile();
+			} catch (IOException e) {
+				throw new VciBaseException(LangBaseUtil.getErrorMsg(e));
+			}
+			ExcelUtil.writeDataToFile(excelFileName, eo);
+		}
+		CodeImProtRusultVO codeImProtRusultVO=new CodeImProtRusultVO();
+		if(StringUtils.isNotBlank(excelFileName)) {
+			codeImProtRusultVO.setFilePath(excelFileName);
+			codeImProtRusultVO.setFileOid("");
+			saveLogUtil.operateLog("鏁版嵁鎵归噺鏇存敼",true, StringUtil.format("閿欒淇℃伅锛歿}",JSON.toJSONString(shetNameMap)) );
+		}else{
+			saveLogUtil.operateLog("鏁版嵁鎵归噺鏇存敼",false, StringUtil.format("瀵煎叆鎴愬姛鎬绘暟涓猴細{}",
+				sheetDataSetList.size()-1));
+		}
+		return codeImProtRusultVO;
+	}
 	/*private void converBaseModels(List<ClientBusinessObject> clientBusinessObjects,List<BaseModel>dataCBOList){
 		clientBusinessObjects.stream().forEach(clientBusinessObject -> {
 			BaseModel baseModel=new BaseModel();
@@ -1331,7 +1702,8 @@
 
 			//闄ゅ幓榛樿鐨勫睘鎬�.杩樻湁鍙湁琛ㄥ崟鏄剧ず鐨勫瓧娈垫墠瀵煎叆
 			List<CodeClassifyTemplateAttrVO> attrVOS = templateVO.getAttributes().stream().filter(s ->
-				!DEFAULT_ATTR_LIST.contains(s.getId()) && VciBaseUtil.getBoolean(s.getFormDisplayFlag())
+				!DEFAULT_ATTR_LIST.contains(s.getId()) &&
+					((Func.isNotEmpty(s.getClassifyInvokeAttr()) || Func.isNotEmpty(s.getClassifyInvokeAttrName())) || VciBaseUtil.getBoolean(s.getFormDisplayFlag()))
 			).collect(Collectors.toList());
 			Map<Integer/**鍒楀彿**/,String/**瀛楁鐨勫悕绉�**/> fieldIndexMap = new HashMap<>();
 			List<String> titleRowData = dataSet.getColName();
@@ -1354,17 +1726,17 @@
 			//2.鍒ゆ柇蹇呰緭椤广�傘�傞渶瑕佸叏閮ㄧ殑灞炴�э紝濡傛灉鏄繀杈擄紝浣嗘槸琛ㄥ崟閲岄潰涓嶆樉绀虹殑锛屽彧鑳芥槸鍒嗙被娉ㄥ叆鎴栬�呯粍鍚堣鍒�
 			batchCheckRequiredAttrOnOrder(templateVO,cboList,errorMap);
 			//3.鍒ゆ柇鍏抽敭灞炴��
-			CodeImportResultVO keyResultVO = batchCheckKeyAttrOnOrder(classifyFullInfo, templateVO, cboList,errorMap);
+			CodeImportResultVO keyResultVO = batchCheckKeyAttrOnOrder(classifyFullInfo, templateVO,cboList,false,errorMap);
 			Set<String> selfRepeatRowIndexList = keyResultVO.getSelfRepeatRowIndexList();
 			Set<String> keyAttrRepeatRowIndexList = keyResultVO.getKeyAttrRepeatRowIndexList();
 			if(!CollectionUtils.isEmpty(selfRepeatRowIndexList)){
 				selfRepeatRowIndexList.stream().forEach(rowIndex->{
-					errorMap.put(rowIndex,errorMap.getOrDefault(rowIndex,"") + ";鍦ㄥ綋鍓嶅鐞嗙殑鏁版嵁鏂囦欢涓叧閿睘鎬ч噸澶�" );
+					errorMap.put(rowIndex, errorMap.getOrDefault(rowIndex, "") + String.format(";鍦ㄥ綋鍓嶅鐞嗙殑鏁版嵁鏂囦欢涓叧閿睘鎬ч噸澶峓%s],[%s];",keyResultVO.getKeyAttrRuleInfo(),keyResultVO.getSynonymRuleInfo()));
 				});
 			}
 			if(!CollectionUtils.isEmpty(keyAttrRepeatRowIndexList)){
 				keyAttrRepeatRowIndexList.stream().forEach(rowIndex->{
-					errorMap.put(rowIndex,"鍏抽敭灞炴�т笌绯荤粺涓殑閲嶅;" + errorMap.getOrDefault(rowIndex,""));
+					errorMap.put(rowIndex, errorMap.getOrDefault(rowIndex, "") + String.format("鍏抽敭灞炴�т笌绯荤粺涓殑閲嶅[%s],[%s];",keyResultVO.getKeyAttrRuleInfo(),keyResultVO.getSynonymRuleInfo()));
 				});
 			}
 			//鍒嗙被娉ㄥ叆
@@ -1399,6 +1771,7 @@
 			Map<String,String>resembleMap=new HashMap<>();
 			List<DataResembleVO> dataResembleVOS=new ArrayList<>();
 			String btmtypeid= classifyFullInfo.getTopClassifyVO().getBtmTypeId();
+			//鐩镐技椤规煡璇�
 			bathcResembleQuery(orderDTO.getCodeClassifyOid(),templateVO,needSaveCboList,resembleMap,btmtypeid,dataResembleVOS);
 			if(resembleMap.size()>0) {
 				isCreateUUid=true;
@@ -1423,7 +1796,7 @@
 				createRedisDatas(uuid + "-ok",templateVO, rowIndexCboMap, dataSet, fieldIndexMap, newErrorMap,true);
 			}else {
 				uuid="";
-
+				final BladeUser user = AuthUtil.getUser();
 				//瑕佹妸浠ヤ笂鐨勯敊璇殑閮芥姏鍑哄悗锛屽啀缁х画澶勭悊鏃堕棿鍜岀粍鍚堣鍒�
 				needSaveCboList = cboList.stream().filter(cbo -> {
 					String rowIndex = cbo.getAttributeValue(IMPORT_ROW_INDEX);
@@ -1443,7 +1816,7 @@
 						dataCBOIdList.add(baseModel.getOid());
 					});
 					try {
-						codeList = productCodeService.productCodeAndSaveData(classifyFullInfo,templateVO,ruleVO, orderDTO.getSecDTOList(),dataCBOList);
+						codeList = productCodeService.productCodeAndSaveData(classifyFullInfo,templateVO,ruleVO, orderDTO.getSecDTOList(),dataCBOList,user);
 						//濡傛灉鏄紪鐮佺敓鎴愬け璐ワ紝鍒欑洿鎺ュ氨澶辫触浜嗭紝鍏朵粬鐨勫垽鏂嚭鏉ユ湁閿欒鐨勬垜浠兘缁熶竴杩斿洖鍒癳xcel閲岄潰
 						engineService.batchSaveSelectChar(templateVO, dataCBOList);
 					} catch (Exception e) {
@@ -1580,21 +1953,23 @@
 			" 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()){
 			//浠庡灏戦〉鍒板灏戦〉鐨勬煡璇㈡柟寮忥紝
+			String countPageSql = "select count(*) from (select * FROM " + tableName +" where 1=1" +
+				" and lastr = '1'" +
+				" and lastv='1'" +
+				" and codeclsfpath like '%" + exportAttrDTO.getCodeClassifyOid() + "%' {}";
 			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);
+				total += commonsMapper.queryCountBySql(StringUtil.format(countPageSql," limit " + exportAttrDTO.getLimit() +" offset "+ i +")subquery;"));
 			}
 		}else{
 			total = commonsMapper.queryCountBySql(countSql);
@@ -1632,10 +2007,10 @@
 			}
 			Map<String, String> finalConditionMap = conditionMap;
 			//骞惰鏌ヨ鐪嬬湅
-			SessionInfo sessionInfo = VciBaseUtil.getCurrentUserSessionInfo();
+			//SessionInfo sessionInfo = VciBaseUtil.getCurrentUserSessionInfo();
 			indexList.stream().forEach(index->{
 				//绾跨▼鐨勬柟寮忥紝鎵�浠ラ渶瑕佽缃綋鍓嶇敤鎴�
-				VciBaseUtil.setCurrentUserSessionInfo(sessionInfo);
+				//VciBaseUtil.setCurrentUserSessionInfo(sessionInfo);
 				PageHelper thisPage = new PageHelper(EXPORT_LIMIT);
 				thisPage.setPage(index+1);
 				thisPage.setSort(exportAttrDTO.getSort());
@@ -1755,10 +2130,18 @@
 		ExcelUtil.writeDataToFile(excelName, excelOption);
 	}
 
+	/**
+	 * 鐩镐技椤规煡璇㈠嚭鏉ヤ箣鍚庡啀鐐瑰嚮纭鏃惰皟鐢ㄧ殑
+	 * @param codeImprotSaveDatVOList
+	 * @param classifyAttr
+	 * @param isImprot
+	 * @return
+	 */
 	@Override
 	public R batchImportData(List<CodeImprotSaveDatVO> codeImprotSaveDatVOList, String classifyAttr, boolean isImprot) {
 		WriteExcelOption eo = new WriteExcelOption();
 		AtomicBoolean success= new AtomicBoolean(true);
+		AtomicReference<CodeClassifyTemplateVO> codeClassifyTemplateVO = new AtomicReference<>();
 		codeImprotSaveDatVOList.stream().forEach(codeImprotSaveDatVO -> {
 			List<SheetRowData> rowDataList = new ArrayList<>();
 			List<ClientBusinessObject>cboList=new ArrayList<>();
@@ -1787,15 +2170,16 @@
 			log.info("鍒嗙被锛�"+classifyFullInfo.getCurrentClassifyVO().getName()+"鏁版嵁:"+codeImprotSaveDatVO.getDataList().size());
 
 			// CodeClassifyTemplateVO codeClassifyTemplateVO=   engineService.getUsedTemplateByClassifyOid(orderDTO.getCodeClassifyOid());
-			CodeClassifyTemplateVO codeClassifyTemplateVO=  templateService.getObjectHasAttrByOid(orderDTO.getTemplateOid());
+			codeClassifyTemplateVO.set(templateService.getObjectHasAttrByOid(orderDTO.getTemplateOid()));
 			//瑙勫垯鐨勪富閿渶瑕佸幓鑾峰彇
 			CodeRuleVO ruleVO = engineService.getCodeRuleByClassifyFullInfo(classifyFullInfo);
 			//闄ゅ幓榛樿鐨勫睘鎬�.杩樻湁鍙湁琛ㄥ崟鏄剧ず鐨勫瓧娈垫墠瀵煎叆
-			List<CodeClassifyTemplateAttrVO> attrVOS = codeClassifyTemplateVO.getAttributes().stream().filter(s ->
-				!DEFAULT_ATTR_LIST.contains(s.getId()) && VciBaseUtil.getBoolean(s.getFormDisplayFlag())
+			List<CodeClassifyTemplateAttrVO> attrVOS = codeClassifyTemplateVO.get().getAttributes().stream().filter(s ->
+				!DEFAULT_ATTR_LIST.contains(s.getId()) &&
+					((Func.isNotEmpty(s.getClassifyInvokeAttr()) || Func.isNotEmpty(s.getClassifyInvokeAttrName())) || VciBaseUtil.getBoolean(s.getFormDisplayFlag()))
 			).collect(Collectors.toList());
 			String fullPath = getFullPath(classifyFullInfo);
-			excelToCbo(classifyFullInfo,fieldIndexMap,rowDataList, codeClassifyTemplateVO,cboList,fullPath,!isImprot);
+			excelToCbo(classifyFullInfo,fieldIndexMap,rowDataList, codeClassifyTemplateVO.get(),cboList,fullPath,!isImprot);
 			Map<String,String> errorMap=new ConcurrentHashMap<>();
 			Map<String/**璺緞**/, CodeClassifyVO> pathMap=new HashMap<>() ;
 			//鏍￠獙缂栫爜瑙勫垯鍜岀爜娈垫槸鍚︽纭�
@@ -1841,12 +2225,12 @@
 			//鏈�鍚庡紕缁勫悎瑙勫垯
 			batchSwitchComponentAttrOnOrder(attrVOS,cboList);
 			//3.鍒ゆ柇鍏抽敭灞炴��
-			CodeImportResultVO keyResultVO = batchCheckKeyAttrOnOrder(classifyFullInfo, codeClassifyTemplateVO, cboList,errorMap);
+			CodeImportResultVO keyResultVO = batchCheckKeyAttrOnOrder(classifyFullInfo, codeClassifyTemplateVO.get(), cboList,false,errorMap);
 			Set<String> selfRepeatRowIndexList = keyResultVO.getSelfRepeatRowIndexList();
 			Set<String> keyAttrRepeatRowIndexList = keyResultVO.getKeyAttrRepeatRowIndexList();
 			if(!CollectionUtils.isEmpty(keyAttrRepeatRowIndexList)){
 				keyAttrRepeatRowIndexList.stream().forEach(rowIndex->{
-					errorMap.put(rowIndex,"鍏抽敭灞炴�т笌绯荤粺涓殑閲嶅;" + errorMap.getOrDefault(rowIndex,""));
+					errorMap.put(rowIndex, errorMap.getOrDefault(rowIndex, "") + String.format("鍏抽敭灞炴�т笌绯荤粺涓殑閲嶅[%s],[%s];",keyResultVO.getKeyAttrRuleInfo(),keyResultVO.getSynonymRuleInfo()));
 				});
 			}
 			//4.鏍￠獙瑙勫垯
@@ -1859,7 +2243,9 @@
 				}).collect(Collectors.toList());
 				List<ClientBusinessObject> finalNeedSaveCboList = needSaveCboList;
 				Map<String, CodeRuleVO> finalRuleVOMap = ruleVOMap;
-				ruleRowIndexMap.keySet().parallelStream().forEach(ruleOid -> {
+				// TODO锛� 澶氱嚎绋嬫祦濂楀绾跨▼娴侊紝鏈夊潙锛屾垜鎶婅繖鍎挎敼鎴愬崟绾跨▼浜�
+				final BladeUser user = AuthUtil.getUser();
+				ruleRowIndexMap.keySet().stream().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());
@@ -1870,7 +2256,7 @@
 							dataCBOList.add(baseModel);
 						});
 						try {
-							productCodeService.productCodeAndSaveData(classifyFullInfo, codeClassifyTemplateVO, finalRuleVOMap.get(ruleOid), null, dataCBOList);
+							productCodeService.productCodeAndSaveData(classifyFullInfo, codeClassifyTemplateVO.get(), finalRuleVOMap.get(ruleOid), null, dataCBOList, user);
 						} catch (Throwable e) {
 							//success=false;
 							log.error("鎵归噺浜х敓缂栫爜鐨勬椂鍊欏嚭閿欎簡", e);
@@ -1880,9 +2266,10 @@
 							});
 						}
 					}
-					engineService.batchSaveSelectChar(codeClassifyTemplateVO, dataCBOList);
+					engineService.batchSaveSelectChar(codeClassifyTemplateVO.get(), dataCBOList);
 				});
 			}else {
+				final BladeUser user = AuthUtil.getUser();
 				List<BaseModel> dataCBOList=new ArrayList<>();
 				List<ClientBusinessObject> needSaveCboList = cboList.stream().filter(cbo -> {
 					String rowIndex = cbo.getAttributeValue(IMPORT_ROW_INDEX);
@@ -1896,7 +2283,7 @@
 						dataCBOList.add(baseModel);
 					});
 					try {
-						productCodeService.productCodeAndSaveData(classifyFullInfo, codeClassifyTemplateVO, ruleVO, orderDTO.getSecDTOList(), dataCBOList);
+						productCodeService.productCodeAndSaveData(classifyFullInfo, codeClassifyTemplateVO.get(), ruleVO, orderDTO.getSecDTOList(), dataCBOList,user);
 					} catch (Exception e) {
 						log.error("鎵归噺浜х敓缂栫爜鐨勬椂鍊欏嚭閿欎簡", e);
 						needSaveCboList.stream().forEach(cbo -> {
@@ -1905,7 +2292,7 @@
 						});
 					}
 					//濡傛灉鏄紪鐮佺敓鎴愬け璐ワ紝鍒欑洿鎺ュ氨澶辫触浜嗭紝鍏朵粬鐨勫垽鏂嚭鏉ユ湁閿欒鐨勬垜浠兘缁熶竴杩斿洖鍒癳xcel閲岄潰
-					engineService.batchSaveSelectChar(codeClassifyTemplateVO, dataCBOList);
+					engineService.batchSaveSelectChar(codeClassifyTemplateVO.get(), dataCBOList);
 				}
 			}
 			if(errorMap.size()>0) {
@@ -1916,14 +2303,16 @@
 				errorMap.forEach((key,v)->{
 					excelDataList.add(new WriteExcelData(index[0]++, 0, "绗�"+(Integer.parseInt(key)+1)+"琛屾暟鎹細"+v));
 				});
-				eo.addSheetDataList(codeClassifyTemplateVO.getName() + "瀵煎叆妯℃澘", excelDataList);
+				eo.addSheetDataList(codeClassifyTemplateVO.get().getName() + "瀵煎叆妯℃澘", excelDataList);
 			}
 		});
 		if(!success.get()){
 			String excelName = LocalFileUtil.getDefaultTempFolder() + File.separator + (isImprot?"鎵归噺鍘嗗彶閿欒淇℃伅.xls":"鎵归噺鐢宠閿欒淇℃伅.xls");
 			ExcelUtil.writeDataToFile(excelName,eo);
-			return  R.fail(excelName);
+			saveLogUtil.operateLog("鍘嗗彶鏁版嵁瀵煎叆",true, StringUtil.format("閿欒淇℃伅锛歿}",JSON.toJSONString(eo.getWriteDataMap())));
+			return R.fail(excelName);
 		}else {
+			saveLogUtil.operateLog("鍘嗗彶鏁版嵁瀵煎叆",false, StringUtil.format("瀵煎叆鍒板垎绫粄}涓紝瀵煎叆鎴愬姛鎬绘暟涓猴細{}", JSON.toJSONString(codeClassifyTemplateVO), Func.isEmpty(codeImprotSaveDatVOList.get(0).getDataList().size())));
 			return R.success(isImprot ? "鎵归噺鍘嗗彶瀵煎叆鎴愬姛" : "鎵归噺鐢宠鎴愬姛");
 		}
 	}
@@ -1994,8 +2383,10 @@
 
 		//鏍￠獙妯℃澘鏄笉鏄渶鏂扮殑
 		//checkTemplateSync(sheetDataSetList,templateVO);
-		//闄ゅ幓榛樿鐨勫睘鎬�.杩樻湁鍙湁琛ㄥ崟鏄剧ず鐨勫瓧娈垫墠瀵煎叆
-		List<CodeClassifyTemplateAttrVO> attrVOS = templateVO.getAttributes().stream().filter(s ->!DEFAULT_SYNC_ATTR_LIST.contains(s.getId()) && VciBaseUtil.getBoolean(s.getFormDisplayFlag())
+		//闄ゅ幓榛樿鐨勫睘鎬�.杩樻湁鍙湁鍏锋湁鍒嗙被娉ㄥ叆鐨勬墠杩囨护鍑烘潵
+		List<CodeClassifyTemplateAttrVO> attrVOS = templateVO.getAttributes().stream().filter(
+			s ->!DEFAULT_SYNC_ATTR_LIST.contains(s.getId()) &&
+				((Func.isNotEmpty(s.getClassifyInvokeAttr()) || Func.isNotEmpty(s.getClassifyInvokeAttrName())) || VciBaseUtil.getBoolean(s.getFormDisplayFlag()))
 		).collect(Collectors.toList());
 		Map<Integer/**鍒楀彿**/,String/**瀛楁鐨勫悕绉�**/> fieldIndexMap = new HashMap<>();
 		List<String> titleRowData = dataObjectVO.getColName();
@@ -2047,7 +2438,7 @@
 		//鏈�鍚庡紕缁勫悎瑙勫垯
 		batchSwitchComponentAttrOnOrder(attrVOS,cboList);
 		//3.鍒ゆ柇鍏抽敭灞炴��
-		CodeImportResultVO keyResultVO = batchCheckKeyAttrOnOrder(classifyFullInfo, templateVO, cboList,errorKeyMap);
+		CodeImportResultVO keyResultVO = batchCheckKeyAttrOnOrder(classifyFullInfo, templateVO, cboList,false,errorKeyMap);
 		Set<String> selfRepeatRowIndexList = keyResultVO.getSelfRepeatRowIndexList();
 		Set<String> keyAttrRepeatRowIndexList = keyResultVO.getKeyAttrRepeatRowIndexList();
 
@@ -2063,7 +2454,7 @@
                 resultDataObjectDetailDO.setMsg(errorMap.getOrDefault(rowIndex,"") + ";鍏抽敭灞炴�ч噸澶�");
                 resultDataObjectDetailDOs.add(resultDataObjectDetailDO);
                 */
-				errorKeyMap.put(rowIndex,errorMap.getOrDefault(rowIndex,"") + ";浼犲叆鐨勬暟鎹腑鍏抽敭灞炴�ч噸澶�");
+				errorKeyMap.put(rowIndex, errorKeyMap.getOrDefault(rowIndex, "") + String.format(";浼犲叆鐨勬暟鎹腑鍏抽敭灞炴�ч噸澶峓%s],[%s];",keyResultVO.getKeyAttrRuleInfo(),keyResultVO.getSynonymRuleInfo()));
 			});
 		}
 		/****
@@ -2084,7 +2475,7 @@
 				if(indexTODataMap.containsKey(rowIndex)){
 					List<BaseModel> baseModelList= indexTODataMap.get(rowIndex);
 				}
-				errorKeyMap.put(rowIndex, "鍏抽敭灞炴�т笌绯荤粺涓殑閲嶅;" + errorKeyMap.getOrDefault(rowIndex,""));
+				errorKeyMap.put(rowIndex, errorKeyMap.getOrDefault(rowIndex, "") + String.format("鍏抽敭灞炴�т笌绯荤粺涓殑閲嶅[%s],[%s];",keyResultVO.getKeyAttrRuleInfo(),keyResultVO.getSynonymRuleInfo()));
 			});
 		}
 		//鏍￠獙灞炴�ф槸鍚︽纭敊璇俊鎭�
@@ -2142,10 +2533,10 @@
 						if (!CollectionUtils.isEmpty(newCboList)) {
 							//澶勭悊鍏抽敭灞炴�ф煡鍑哄鏉＄殑璇濓紝鏍规嵁闆嗘垚璋冪敤鐨勫綋鍓嶅垎绫讳唬鍙峰彇褰撳墠鍒嗙被鐨勭爜鍊笺��
 							Map<String/**缂栫爜**/, BaseModel/**閲嶅缂栫爜鏁版嵁**/> classOidTOBaseModelMap = new HashMap<>();
-								newCboList.stream().forEach(baseModel->{
-									String codeclsfid=baseModel.getData().get(CODE_CLASSIFY_OID_FIELD.toUpperCase(Locale.ROOT));
-									classOidTOBaseModelMap.put(codeclsfid,baseModel);
-								});
+							newCboList.stream().forEach(baseModel->{
+								String codeclsfid=baseModel.getData().get(CODE_CLASSIFY_OID_FIELD.toLowerCase(Locale.ROOT));
+								classOidTOBaseModelMap.put(codeclsfid,baseModel);
+							});
 							String codeclsfid= classifyFullInfo.getCurrentClassifyVO().getOid();
 							if(classOidTOBaseModelMap.containsKey(codeclsfid)){
 								BaseModel newCbo= classOidTOBaseModelMap.get(codeclsfid);
@@ -2182,7 +2573,7 @@
 						}
 					}
 				});
-				//鍏抽敭鐔熸倝鏇存敼
+				//鍏抽敭灞炴�ф洿鏀�
 				if (!CollectionUtils.isEmpty(editBoList)) {
 					engineService.updateBatchByBaseModel(classifyFullInfo.getTopClassifyVO().getBtmTypeId(),editBoList);//淇濆瓨鏁版嵁
 				}
@@ -2204,6 +2595,7 @@
 
 			List<String>allNeedSaveCboList=new ArrayList<>();
 			List<BaseModel> dataCBOList=new ArrayList<>();
+			final BladeUser user = AuthUtil.getUser();
 			needSaveCboList.stream().forEach(clientBusinessObject -> {
 				BaseModel baseModel=new BaseModel();
 				BeanUtil.convert(clientBusinessObject,baseModel);
@@ -2213,7 +2605,7 @@
 			});
 			try {
 				List<String>applyGroupCodeIdList=new ArrayList<>();
-				productCodeService.productCodeAndSaveData(classifyFullInfo, templateVO, ruleVO, orderDTO.getSecDTOList(), dataCBOList);
+				productCodeService.productCodeAndSaveData(classifyFullInfo, templateVO, ruleVO, orderDTO.getSecDTOList(), dataCBOList,user);
 				//濡傛灉鏄紪鐮佺敓鎴愬け璐ワ紝鍒欑洿鎺ュ氨澶辫触浜嗭紝鍏朵粬鐨勫垽鏂嚭鏉ユ湁閿欒鐨勬垜浠兘缁熶竴杩斿洖鍒癳xcel閲岄潰
 				engineService.batchSaveSelectChar(templateVO, dataCBOList);
 				// if(!isProcess){
@@ -2241,7 +2633,6 @@
 						resultDataObjectDetailDO.setErrorid("0");
 					}
 					resultDataObjectDetailDO.setId(sourceOid);
-
 					resultDataObjectDetailDO.setMsg(msg);
 					resultDataObjectDetailDOs.add(resultDataObjectDetailDO);
 					//澶勭悊浼犻�佺殑鏁版嵁涓叧閿睘鎬ч噸澶嶇殑锛岀洿鎺ユ嬁鍒板凡缁忕敵璇峰埌缂栫爜鐨勬暟鎹紪鐮佺洿鎺ュ皢璧嬬粰鍏抽敭灞炴�ч噸澶嶇殑鏁版嵁
@@ -2365,7 +2756,8 @@
 		//鏍￠獙妯℃澘鏄笉鏄渶鏂扮殑
 		//checkTemplateSync(sheetDataSetList,templateVO);
 		//闄ゅ幓榛樿鐨勫睘鎬�.杩樻湁鍙湁琛ㄥ崟鏄剧ず鐨勫瓧娈垫墠瀵煎叆
-		List<CodeClassifyTemplateAttrVO> attrVOS = templateVO.getAttributes().stream().filter(s -> !DEFAULT_SYNC_ATTR_LIST.contains(s.getId()) && VciBaseUtil.getBoolean(s.getFormDisplayFlag())
+		List<CodeClassifyTemplateAttrVO> attrVOS = templateVO.getAttributes().stream().filter(s -> !DEFAULT_SYNC_ATTR_LIST.contains(s.getId()) &&
+			((Func.isNotEmpty(s.getClassifyInvokeAttr()) || Func.isNotEmpty(s.getClassifyInvokeAttrName())) || VciBaseUtil.getBoolean(s.getFormDisplayFlag()))
 		).collect(Collectors.toList());
 		Map<Integer/**鍒楀彿**/, String/**瀛楁鐨勫悕绉�**/> fieldIndexMap = new HashMap<>();
 		List<String> titleRowData = dataObjectVO.getColName();
@@ -2375,7 +2767,7 @@
 		//cboOidMap.put("id", QueryOptionConstant.IN + "(" + VciBaseUtil.toInSql(codeDataMap.keySet().toArray(new String[0])) + ")");
 		String tableName ="";
 		try {
-			R<BtmTypeVO> r = btmTypeClient.getAllAttributeByBtmId(templateVO.getBtmTypeId());
+			R<BtmTypeVO> r = btmTypeClient.getAllAttributeByBtmId(classifyFullInfo.getTopClassifyVO().getBtmTypeId());
 			if(!r.isSuccess()) {
 				throw new Throwable(r.getMsg());
 			}
@@ -2417,6 +2809,7 @@
 		}
 
 		List<Map<String,String>> dataMapList=commonsMapper.queryByOnlySqlForMap(sb.toString());
+		DefaultAttrAssimtUtil.mapToLowerCase(dataMapList,true);
 		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<>();
@@ -2472,7 +2865,17 @@
 				cbo.setDescription(StringUtils.isBlank(orderDTO.getDescription())?"":orderDTO.getDescription());
 				cbo.setName(orderDTO.getName());
 				try {
-					cbo.setAttributeValueWithNoCheck("description", orderDTO.getDescription());
+					//涓昏澶勭悊澶у皬鍐欓棶棰橈紝灏哾ata閲岄潰鐨勬暟鎹殑key閮借浆涓哄皬鍐�
+					HashMap<String,String> lowerData = new HashMap<>();
+					Iterator<Map.Entry<String, String>> iterator = cbo.getData().entrySet().iterator();
+					while (iterator.hasNext()){
+						Map.Entry<String, String> next = iterator.next();
+						lowerData.put(next.getKey().toLowerCase(Locale.ROOT),next.getValue());
+					}
+					cbo.getData().clear();
+					cbo.getData().putAll(lowerData);
+					cbo.setAttributeValueWithNoCheck("description", (StringUtil.isNotBlank(orderDTO.getData()
+						.get("description")) ? orderDTO.getData().get("description") : orderDTO.getDescription() ));
 				//	cbo.setAttributeValue("name", orderDTO.getName());
 					//  if(finalIsProcess){//鍦ㄦ祦绋嬩腑涓嶅厑璁告洿鏀�
 					//     errorMap.put(code,errorMap.getOrDefault(code, errorMap.getOrDefault(code,"")+";鏁版嵁"+code+"鍦ㄦ祦绋嬩腑锛屼笉鍏佽鏇存敼!"));
@@ -2535,7 +2938,7 @@
 
 					List<CodeAllCode>newCodeAllCodeList= codeAllCodeService.selectByWrapper(Wrappers.<CodeAllCode>query().lambda().eq(CodeAllCode::getCreateCodeOid, cbo.getOid()));
 					if (!CollectionUtils.isEmpty(newCodeAllCodeList)) {
-						CodeAllCode codeCbo = codeAllCodeList.get(0);
+						CodeAllCode codeCbo = newCodeAllCodeList.get(0);
 						log.info("codeCbos code:" + codeCbo.getId());
 						codeCbo.setLcStatus(status);
 						codeAllCodeList.add(codeCbo);
@@ -2573,7 +2976,7 @@
 				engineService.updateBatchByBaseModel(classifyFullInfo.getTopClassifyVO().getBtmTypeId(),updateList);
 				codeAllCodeService.saveOrUpdateBatch(codeAllCodeList);
 				if(deleteList.size()>0) {
-					commonsMapper.deleteByTaleAndOid(tableName, VciBaseUtil.array2String(deleteList.toArray(new String[]{})));
+					commonsMapper.deleteByTaleAndOid(tableName, VciBaseUtil.toInSql(deleteList.toArray(new String[]{})));
 				}
 				//鏄惁璋冪敤闆嗗洟鎺ュ彛鐢宠鎺ュ彛
 				if(isCodeOrGroupCode){
@@ -2693,18 +3096,27 @@
 		//娉ㄦ剰鐨勬槸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));
+		// TODO:2024-02-01 鍏堣幏鍙栭厤缃簡杩戜箟璇嶆煡璇㈣鍒欑殑灞炴�э紝涓嶅悓浜庡叧閿睘鎬э紝璁剧疆浜嗚繎涔夎瘝鏌ヨ瑙勫垯鐨勫睘鎬у彲鑳芥槸澶氭潯涓嶅悓鐨勮繎涔夎瘝鏌ヨ瑙勫垯
+		Map<String, CodeClassifyTemplateAttrVO> sysonymAttrMaps = templateVO.getAttributes().stream().filter(item -> Func.isNotBlank(item.getSysonymRuleOids())).collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t));
+		// 鑾峰彇鏄惁鏈夐厤缃繎涔夎瘝鏌ヨ瑙勫垯灞炴��
+		Map<String, List<CodeSynonym>> codeSynonymMaps = new HashMap<>();
+		if(!sysonymAttrMaps.isEmpty()){
+			// 鏌ヨ杩戜箟璇嶈鍒欙紝瀛樺偍鏂瑰紡key锛氬睘鎬d锛寁alue杩戜箟璇嶆煡璇㈣鍒欏垪琛�
+			codeSynonymMaps = codeSynonymService.getCodeSynonymByOids(sysonymAttrMaps);
+		}
 		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());
+		Map<String, List<CodeSynonym>> finalCodeSynonymMaps = codeSynonymMaps;
 		ketAttrMap.forEach((attrId, attrVO) -> {
 			String value = getValueFromOrderDTO(orderDTO, attrId);
 			if (value == null) {
 				value = "";
 			}
-			engineService.wrapperKeyAttrConditionMap(value, keyRuleVO, attrId, trim, ignoreCase, ignoreWidth, trimAll, conditionMap);
+			engineService.wrapperKeyAttrConditionMap(value, keyRuleVO, finalCodeSynonymMaps.get(attrId), attrId, trim, ignoreCase, ignoreWidth, trimAll, conditionMap);
 		});
 
 		//娌℃湁闄愬埗鍒嗙被锛屼絾鏄竴涓ā鏉垮彧鍙兘鍦ㄤ竴涓笟鍔＄被鍨嬮噷闈紝鎵�浠ョ洿鎺ユ煡璇㈣繖涓笟鍔＄被鍨嬪嵆鍙�
@@ -3248,6 +3660,11 @@
 		rowDataList.stream().forEach(rowData -> {
 			ClientBusinessObject cbo=new ClientBusinessObject();
 			DefaultAttrAssimtUtil.addDefaultAttrAssimt(cbo, classifyFullInfo.getTopClassifyVO().getBtmTypeId());
+			R<List<BtmTypeVO>> listR = btmTypeClient.selectByIdCollection(Collections.singletonList(classifyFullInfo.getTopClassifyVO().getBtmTypeId()));
+			if(!listR.isSuccess() || listR.getData().size() == 0){
+				throw new VciBaseException("浼犲叆涓氬姟绫诲瀷鏈煡璇㈠埌鐩稿簲琛ㄥ崟锛岃妫�鏌ワ紒");
+			}
+			cbo.setRevisionRule("".equals(listR.getData().get(0).getVersionRule())?"1":listR.getData().get(0).getVersionRule());
 			rowData.getData().forEach((index,value)->{
 					String field = fieldIndexMap.get(index);
 				if (StringUtils.isBlank(field)) {
@@ -3287,6 +3704,106 @@
 			cboList.add(cbo);
 		});
 
+	}
+
+	/**
+	 * excel杞崲涓篶bo鐨勫璞�
+	 * @param fieldIndexMap 瀛楁鐨勪綅缃�
+	 * @param rowDataList excel閲岀殑琛屾暟鎹�
+	 * @param orderDTO 鏁寸悊鐨勬暟鎹�
+	 * @param map 鏁版嵁鐨勫垪琛�
+	 */
+	private void excelToCboEdit(Map<Integer,String> fieldIndexMap,SheetRowData rowDataList,
+							CodeOrderDTO orderDTO,
+							Map map){
+		rowDataList.getData().forEach((index,value)->{
+				String field = fieldIndexMap.get(index);
+				if (StringUtils.isBlank(field)) {
+					throw new VciBaseException("绗�" + (index + 1) + "鍒楃殑鏍囬鍦ㄧ郴缁熶腑涓嶅瓨鍦�");
+				}
+				map.put(field.toUpperCase(),value);
+			});
+
+		try {
+//			for (Map map : cbos) {
+//			Object obj = CodeOrderDTO.class.newInstance();
+			BeanInfo beanInfo = Introspector.getBeanInfo(orderDTO.getClass());
+			PropertyDescriptor[] propertyDescriptors = beanInfo.getPropertyDescriptors();
+			for (PropertyDescriptor property : propertyDescriptors) {
+				Method setter = property.getWriteMethod();
+				if (setter != null) {
+					//oracle鐨勬椂闂翠负TIMESTAMP鐨勶紝闇�瑕佽繘琛岃浆鎹㈡垚data锛屽惁鍒欏皢鎶ラ敊
+					if (map.get(property.getName().toUpperCase()) instanceof TIMESTAMP) {
+						LocalDateTime localDateTime = ((TIMESTAMP) map.get(property.getName().toUpperCase())).toLocalDateTime();
+						ZoneId zoneId = ZoneId.systemDefault();
+						ZonedDateTime zdt = localDateTime.atZone(zoneId);
+						Date date = Date.from(zdt.toInstant());
+						setter.invoke(orderDTO, date);
+						map.remove(property.getName().toUpperCase());
+					} //oracle鐨勬暟瀛椾负BigDecimal鐨勶紝闇�瑕佽繘琛岃浆鎹㈡垚Integer锛屽惁鍒欏皢鎶ラ敊
+					else if (map.get(property.getName().toUpperCase()) instanceof BigDecimal
+						&& ("Integer").equals(setter.getParameterTypes()[0].getSimpleName())) {
+						setter.invoke(orderDTO, ((BigDecimal) map.get(property.getName().toUpperCase())).intValue());
+						map.remove(property.getName().toUpperCase());
+					} else if (map.containsKey(property.getName().toUpperCase())) {
+						if(setter.getParameterTypes()[0].getSimpleName().equals("String")){
+							setter.invoke(orderDTO, map.get(property.getName().toUpperCase()) == null ? null:String.valueOf(map.get(property.getName().toUpperCase())));
+						}else{
+							setter.invoke(orderDTO, map.get(property.getName().toUpperCase()));
+						}
+						map.remove(property.getName().toUpperCase());
+					}
+				}
+			}
+			for (Object key : map.keySet()) {
+				map.put(key, map.get(key) == null ? null : String.valueOf(map.get(key)));
+			}
+		} catch (Exception e) {
+			throw new VciBaseException("鏌ヨ澶辫触锛�" + e.getMessage());
+		}
+
+
+
+//		Iterator<Map.Entry<String, String>> iterator = cbos.entrySet().iterator();
+//
+//		Map.Entry<String, String> entry;
+//		while (iterator.hasNext()) {
+//			entry = iterator.next();
+////			if (WebUtil.isDefaultField(entry.getKey())) {
+//				Object obj = BaseModel.class.newInstance();
+//				BeanInfo beanInfo = Introspector.getBeanInfo(obj.getClass());
+//				PropertyDescriptor[] propertyDescriptors = beanInfo.getPropertyDescriptors();
+//				for (PropertyDescriptor property : propertyDescriptors) {
+//					Method setter = property.getWriteMethod();
+//					if (setter != null) {
+//						//oracle鐨勬椂闂翠负TIMESTAMP鐨勶紝闇�瑕佽繘琛岃浆鎹㈡垚data锛屽惁鍒欏皢鎶ラ敊
+//						if (map.get(property.getName().toUpperCase()) instanceof TIMESTAMP) {
+//							LocalDateTime localDateTime = ((TIMESTAMP) map.get(property.getName().toUpperCase())).toLocalDateTime();
+//							ZoneId zoneId = ZoneId.systemDefault();
+//							ZonedDateTime zdt = localDateTime.atZone(zoneId);
+//							Date date = Date.from(zdt.toInstant());
+//							setter.invoke(obj, date);
+//							map.remove(property.getName().toUpperCase());
+//						} //oracle鐨勬暟瀛椾负BigDecimal鐨勶紝闇�瑕佽繘琛岃浆鎹㈡垚Integer锛屽惁鍒欏皢鎶ラ敊
+//						else if (map.get(property.getName().toUpperCase()) instanceof BigDecimal
+//							&& ("Integer").equals(setter.getParameterTypes()[0].getSimpleName())) {
+//							setter.invoke(obj, ((BigDecimal) map.get(property.getName().toUpperCase())).intValue());
+//							map.remove(property.getName().toUpperCase());
+//						} else if (map.containsKey(property.getName().toUpperCase())) {
+//							if(setter.getParameterTypes()[0].getSimpleName().equals("String")){
+//								setter.invoke(obj, map.get(property.getName().toUpperCase()) == null ? null:String.valueOf(map.get(property.getName().toUpperCase())));
+//							}else{
+//								setter.invoke(obj, map.get(property.getName().toUpperCase()));
+//							}
+//							map.remove(property.getName().toUpperCase());
+//						}
+//					}
+//				}
+//				WebUtil.setValueToField(entry.getKey(), orderDTO, entry.getValue());
+//				iterator.remove();
+////			}
+//		}
+		orderDTO.setData(map);
 	}
 
 	/**
@@ -3494,7 +4011,8 @@
 						String sql = "select " + valueField + "," + showText.toLowerCase(Locale.ROOT) +" from " + table + "  where " + showText + " in (%s)";
 						valueCollections.stream().forEach(values->{
 							List<Map<String,String>> dataMapList = commonsMapper.queryByOnlySqlForMap(String.format(sql, VciBaseUtil.toInSql(values.toArray(new String[0]))));
-							List<ClientBusinessObject> cbos=	ChangeMapTOClientBusinessObjects(dataMapList);
+							DefaultAttrAssimtUtil.mapToLowerCase(dataMapList,true);
+							List<ClientBusinessObject> cbos=ChangeMapTOClientBusinessObjects(dataMapList);
 							if(!CollectionUtils.isEmpty(cbos)){
 								valueOidTextMap.putAll(cbos.stream().collect(Collectors.toMap(s->s.getAttributeValue(valueField),t->t.getAttributeValue(showText))));
 							}
@@ -3863,7 +4381,7 @@
 						} else {
 							Map<String, String> classifyDataMap = VciBaseUtil.objectToMapString(classifyVO);
 							String value = classifyDataMap.getOrDefault(attrVO.getClassifyInvokeAttr(), "");
-							log.error("================================褰撳墠鍒嗙被娉ㄥ叆鐨剉alue鍊间负锛�==========================",value);
+//							log.error("================================褰撳墠鍒嗙被娉ㄥ叆鐨剉alue鍊间负锛�==========================",value);
 							cbo.setAttributeValue(attrId, value);
 						}
 					} catch (Throwable e) {
@@ -3873,20 +4391,30 @@
 			});
 		}
 	}
+
 	/**
-	 * 鏍￠獙鍏抽敭灞炴��
+	 * 鏍￠獙鍏抽敭灞炴�э紝鍜岃繎涔夎瘝鏌ヨ瑙勫垯
 	 * @param classifyFullInfo 鍒嗙被鐨勫叏閮ㄤ俊鎭�
 	 * @param templateVO 妯℃澘鐨勫唴瀹癸紝蹇呴』鍖呭惈妯℃澘灞炴��
 	 * @param cboList 鎵归噺鐨勬暟鎹�
 	 */
 	private CodeImportResultVO batchCheckKeyAttrOnOrder(CodeClassifyFullInfoBO classifyFullInfo, CodeClassifyTemplateVO templateVO,
-														List<ClientBusinessObject> cboList,Map<String,String> errorMap) {
+														List<ClientBusinessObject> cboList,boolean isEdit,Map<String,String> errorMap) {
 		//涓嶮dmEngineServiceImpl閲岀殑checkKeyAttrOnOrder鐩镐技
 		//鍏堣幏鍙栧叧閿睘鎬х殑瑙勫垯锛屼篃鍒╃敤缁ф壙鐨勬柟寮�
 		CodeKeyAttrRepeatVO keyRuleVO = keyRuleService.getRuleByClassifyFullInfo(classifyFullInfo);
 		//娉ㄦ剰鐨勬槸keyRuleVO鍙兘涓虹┖锛岃〃绀轰笉浣跨敤瑙勫垯鎺у埗
 		//鑾峰彇鎵�鏈夌殑鍏抽敭灞炴��
-		Map<String/**灞炴�х殑缂栧彿**/, CodeClassifyTemplateAttrVO> ketAttrMap = templateVO.getAttributes().stream().filter(s -> VciBaseUtil.getBoolean(s.getKeyAttrFlag())).collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t));
+		Map<String/**灞炴�х殑缂栧彿**/, CodeClassifyTemplateAttrVO> keyAttrMap = templateVO.getAttributes().stream().filter(s -> VciBaseUtil.getBoolean(s.getKeyAttrFlag())).collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t));
+
+		// TODO:2024-02-01 鍏堣幏鍙栭厤缃簡杩戜箟璇嶆煡璇㈣鍒欑殑灞炴�э紝涓嶅悓浜庡叧閿睘鎬э紝璁剧疆浜嗚繎涔夎瘝鏌ヨ瑙勫垯鐨勫睘鎬у彲鑳芥槸澶氭潯涓嶅悓鐨勮繎涔夎瘝鏌ヨ瑙勫垯
+		Map<String, CodeClassifyTemplateAttrVO> sysonymAttrMaps = templateVO.getAttributes().stream().filter(item -> Func.isNotBlank(item.getSysonymRuleOids())).collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t));
+		// 鑾峰彇鏄惁鏈夐厤缃繎涔夎瘝鏌ヨ瑙勫垯灞炴��
+		Map<String, List<CodeSynonym>> codeSynonymMaps = new HashMap<>();
+		if(!sysonymAttrMaps.isEmpty()){
+			// 鏌ヨ杩戜箟璇嶈鍒欙紝瀛樺偍鏂瑰紡key锛氬睘鎬d锛寁alue杩戜箟璇嶆煡璇㈣鍒欏垪琛�
+			codeSynonymMaps = codeSynonymService.getCodeSynonymByOids(sysonymAttrMaps);
+		}
 
 		boolean trimAll =keyRuleVO ==null?false: VciBaseUtil.getBoolean(keyRuleVO.getIgnoreallspaceflag());
 		//鍏ㄩ儴鍘荤┖鐨勪紭鍏堢骇澶т簬鍘荤┖
@@ -3896,61 +4424,89 @@
 
 		//1. 鎴戜滑闇�瑕佸厛鍒ゆ柇excel瀵煎叆鐨勫唴瀹规槸鍚︽纭�
 		CodeImportResultVO resultVO = new CodeImportResultVO();
-		resultVO.setKeyAttrRuleInfo(String.format(keyRuleVO ==null?"":"鏌ヨ瑙勫垯锛氬幓闄ょ┖鏍�--{0},蹇界暐澶у皬鍐�--{1},蹇界暐鍏ㄥ崐瑙�--{2},蹇界暐鍏ㄩ儴绌烘牸--{3}",
-			new String[]{trim?"鏄�":"鍚�",ignoreCase?"鏄�":"鍚�",ignoreWidth?"鏄�":"鍚�",trimAll?"鏄�":"鍚�"}));
-		//resultVO.setSelfRepeatRowIndexList(getSelfRepeatRowIndex(ketAttrMap,cboList,keyRuleVO));
-		getSelfRepeatRowIndex(ketAttrMap,cboList,keyRuleVO,resultVO);
+		StringBuilder synonymResString = new StringBuilder();
+		if(Func.isNotEmpty(codeSynonymMaps)){
+			codeSynonymMaps.keySet().stream().forEach(item->{
+				synonymResString.append(item);
+				synonymResString.append("锛�");
+			});
+		}
+		resultVO.setSynonymRuleInfo(Func.isEmpty(codeSynonymMaps) ? "":String.format("浠ヤ笅[%s]琚缃簡杩戜箟璇嶆煡璇㈣鍒欑殑鍏抽敭灞炴��,涓嚭鐜颁簡閲嶅锛�",synonymResString));
+		resultVO.setKeyAttrRuleInfo(keyRuleVO == null ? "":String.format("鏌ヨ瑙勫垯锛氬幓闄ょ┖鏍�--{%s},蹇界暐澶у皬鍐�--{%s},蹇界暐鍏ㄥ崐瑙�--{%s},蹇界暐鍏ㄩ儴绌烘牸--{%s}"
+			,trim?"鏄�":"鍚�",ignoreCase?"鏄�":"鍚�",ignoreWidth?"鏄�":"鍚�",trimAll?"鏄�":"鍚�"));
+		//resultVO.setSelfRepeatRowIndexList(getSelfRepeatRowIndex(keyAttrMap,cboList,keyRuleVO));
+		// 鍏堝湪琛ㄦ牸涓煡璇㈠叧閿睘鎬у拰杩戜箟璇嶈浆鎹㈠悗閲嶅鐨勫垪
+		getSelfRepeatRowIndex(keyAttrMap,cboList,keyRuleVO,codeSynonymMaps,resultVO);
+		// 鍐嶅湪琛ㄦ牸涓煡璇㈣繎涔夎瘝鏌ヨ瑙勫垯鐨勫垪
+		//getSelfRepeatSysnomRowIndex(sysonymAttrMaps,cboList,codeSynonymMaps,resultVO);
+
 		if(!CollectionUtils.isEmpty(resultVO.getSelfRepeatRowIndexList())){
 			//鎴戜滑绉婚櫎鏈韩閲嶅鐨勬暟鎹�
 			cboList = cboList.stream().filter(s->!resultVO.getSelfRepeatRowIndexList().contains(s.getAttributeValue(IMPORT_ROW_INDEX))).collect(Collectors.toList());
 		}
 		//2.鍒ゆ柇鍏抽敭灞炴�у湪绯荤粺閲屾槸鍚﹂噸澶�
-		//鍥犱负鏁版嵁閲忓緢澶э紝鎵�浠ュ緱鎯冲姙娉曞苟琛�
-		//SessionInfo sessionInfo = VciBaseUtil.getCurrentUserSessionInfo();
 		Map<String,List<BaseModel>> indexTODataMap=new ConcurrentHashMap<>();
 		// 鏌ヨ涓嶉渶瑕佸弬涓庡叧閿睘鎬ф牎楠岀殑闄よ嚜宸变互澶栫殑鎵�鏈夊垎绫籵id
 		final String isParticipateCheckOids = classifyService.selectLeafByParentClassifyOid(classifyFullInfo.getTopClassifyVO().getOid(), classifyFullInfo.getCurrentClassifyVO().getOid());
-		List<ClientBusinessObject> repeatDataMap = cboList.parallelStream().filter(cbo -> {
-			//姣忚閮藉緱鏌ヨ.濡傛灉鍏朵腑鍑虹幇浜嗛敊璇紝鎴戜滑灏辩洿鎺ユ姏鍑哄紓甯革紝鍏朵綑鐨勬樉绀�
-			//VciBaseUtil.setCurrentUserSessionInfo(sessionInfo);
-			Map<String, String> conditionMap = new HashMap<>();
-			ketAttrMap.forEach((attrId, attrVO) -> {
-				String value =cbo.getAttributeValue(attrId.toLowerCase(Locale.ROOT));
-				if (value == null) {
-					value = "";
-				}
-				value= value.replace(REQUIRED_CHAR,SPECIAL_CHAR);
-				engineService.wrapperKeyAttrConditionMap(value, keyRuleVO, attrId, trim, ignoreCase, ignoreWidth, trimAll, conditionMap);
-			});
-			if (!CollectionUtils.isEmpty(ketAttrMap)) {
-				// 娣诲姞涓嶅弬涓庡叧閿睘鎬ф牎楠岀殑鍒嗙被oid鍒ゆ柇
-				if(Func.isNotBlank(isParticipateCheckOids)){
-					conditionMap.put("t.codeclsfid",QueryOptionConstant.NOTIN+isParticipateCheckOids);
-				}
-				CodeTemplateAttrSqlBO sqlBO = engineService.getSqlByTemplateVO(classifyFullInfo.getTopClassifyVO().getBtmTypeId(), templateVO, conditionMap, null);
-				List<String> repeatData = commonsMapper.selectList(sqlBO.getSqlId());
-				if(!repeatData.isEmpty()){
-					final List<Map<String,String>> newDataList = commonsMapper.queryByOnlySqlForMap(sqlBO.getSqlUnPage());
-					//List<ClientBusinessObject> newCboList=ChangeMapTOClientBusinessObjects(newDataList);
-					List<BaseModel> newCboList = new ArrayList<>();
-					newDataList.stream().forEach(stringStringMap -> {
-						BaseModel baseModel=new BaseModel();
-						DefaultAttrAssimtUtil.copplyDefaultAttrAssimt(stringStringMap,baseModel);
-						baseModel.setData(stringStringMap);
-						newCboList.add(baseModel);
-					});
-					// 娣诲姞閿欒鍊�
-					String rowIndex = cbo.getAttributeValue(IMPORT_ROW_INDEX);
-					errorMap.put(rowIndex, "閲嶅鐨勮褰曠紪鍙蜂负:"+repeatData.stream().collect(Collectors.joining(",")));
-					if(!CollectionUtils.isEmpty(newCboList)) {
-						indexTODataMap.put(cbo.getAttributeValue(IMPORT_ROW_INDEX), newCboList);
+		final BladeUser user = AuthUtil.getUser();
+		// TODO:Thread limit exceeded replacing blocked 寮傚父鏄繖閮ㄥ垎浠ｇ爜鎶涘嚭鐨�
+		//  ,鎵�浠ユ殏鏃跺皢parallelStream鏀规垚浜唖tream锛屾敼鎴愪簡stream涔嬪悗鍙戠幇宸ㄦ參
+		// customForkJoinPool鎺у埗骞跺彂搴�
+		List<ClientBusinessObject> finalCboList = cboList;
+		Map<String, List<CodeSynonym>> finalCodeSynonymMaps = codeSynonymMaps;
+		List<ClientBusinessObject> repeatDataMap = (List<ClientBusinessObject>) customForkJoinPool.submit(()->{
+			finalCboList.parallelStream().filter(cbo -> {
+				//姣忚閮藉緱鏌ヨ.濡傛灉鍏朵腑鍑虹幇浜嗛敊璇紝鎴戜滑灏辩洿鎺ユ姏鍑哄紓甯革紝鍏朵綑鐨勬樉绀�
+				//VciBaseUtil.setCurrentUserSessionInfo(sessionInfo);
+				Map<String, String> conditionMap = new HashMap<>();
+				keyAttrMap.forEach((attrId, attrVO) -> {
+					String value =cbo.getAttributeValue(attrId.toLowerCase(Locale.ROOT));
+					if (value == null) {
+						value = "";
 					}
+					value= value.replace(REQUIRED_CHAR,SPECIAL_CHAR);
+					// 鍏抽敭灞炴�ф煡璇㈡潯浠秏ap鑾峰彇
+					engineService.wrapperKeyAttrConditionMap(value, keyRuleVO, finalCodeSynonymMaps.get(attrId), attrId, trim, ignoreCase, ignoreWidth, trimAll, conditionMap);
+				});
+
+				if (!CollectionUtils.isEmpty(keyAttrMap)) {
+					// 娣诲姞涓嶅弬涓庡叧閿睘鎬ф牎楠岀殑鍒嗙被oid鍒ゆ柇
+					if(Func.isNotBlank(isParticipateCheckOids)){
+						conditionMap.put("t.codeclsfid",QueryOptionConstant.NOTIN+isParticipateCheckOids);
+					}
+					//濡傛灉鏄洿鏀瑰垯闇�鎺掗櫎绯荤粺鏈韩
+					if(isEdit){
+						conditionMap.put("t.id",QueryOptionConstant.NOTEQUAL+cbo.getId());
+					}
+					conditionMap.put("t.lastr", "1");
+					conditionMap.put("t.lastv", "1");
+
+					CodeTemplateAttrSqlBO sqlBO = engineService.getSqlByTemplateVO(classifyFullInfo.getTopClassifyVO().getBtmTypeId(), templateVO, conditionMap, null);
+					List<String> repeatData = commonsMapper.selectList(sqlBO.getSqlId());
+					if(!repeatData.isEmpty()){
+						final List<Map<String,String>> newDataList = commonsMapper.queryByOnlySqlForMap(sqlBO.getSqlUnPage());
+						DefaultAttrAssimtUtil.mapToLowerCase(newDataList,true);
+						//List<ClientBusinessObject> newCboList=ChangeMapTOClientBusinessObjects(newDataList);
+						List<BaseModel> newCboList = new ArrayList<>();
+						newDataList.stream().forEach(stringStringMap -> {
+							BaseModel baseModel=new BaseModel();
+							DefaultAttrAssimtUtil.copplyDefaultAttrAssimt(stringStringMap,baseModel,false,user);
+							baseModel.setData(stringStringMap);
+							newCboList.add(baseModel);
+						});
+						// 娣诲姞閿欒鍊�
+						String rowIndex = cbo.getAttributeValue(IMPORT_ROW_INDEX);
+						errorMap.put(rowIndex, "閲嶅鐨勮褰曠紪鍙蜂负:"+repeatData.stream().collect(Collectors.joining(",")));
+						if(!CollectionUtils.isEmpty(newCboList)) {
+							indexTODataMap.put(cbo.getAttributeValue(IMPORT_ROW_INDEX), newCboList);
+						}
+					}
+					return !repeatData.isEmpty();
+				}else{
+					return false;
 				}
-				return !repeatData.isEmpty();
-			}else{
-				return false;
-			}
-		}).collect(Collectors.toList());
+			}).collect(Collectors.toList());
+		}).join();
 		if(!CollectionUtils.isEmpty(repeatDataMap)){
 			resultVO.setKeyAttrRepeatRowIndexList(repeatDataMap.stream().map(s->s.getAttributeValue(IMPORT_ROW_INDEX)).collect(Collectors.toSet()));
 		}
@@ -4064,16 +4620,16 @@
 	}
 
 	/**
-	 * 鑾峰彇瀵煎叆鐨勫唴瀹逛腑鍏抽敭灞炴�ч噸澶嶇殑琛屽彿
+	 * 鑾峰彇瀵煎叆鐨勫唴瀹逛腑鍏抽敭灞炴�ц繎涔夎瘝杞崲鍚庨噸澶嶇殑琛屽彿
 	 * @param ketAttrMap 鍏抽敭灞炴�х殑鏄犲皠
 	 * @param dataList 瀵煎叆鐨勬暟鎹�
 	 * @param keyRuleVO 鍏抽敭灞炴�ф帶鍒惰鍒�
 	 * @return 閲嶅鐨勮鍙�
 	 */
 	private void getSelfRepeatRowIndex(Map<String/**灞炴�х殑缂栧彿**/, CodeClassifyTemplateAttrVO> ketAttrMap,
-									   List<ClientBusinessObject> dataList,CodeKeyAttrRepeatVO keyRuleVO,CodeImportResultVO resultVO){
+									   List<ClientBusinessObject> dataList,CodeKeyAttrRepeatVO keyRuleVO,/*杩戜箟璇嶆煡璇㈣鍒�*/Map<String,List<CodeSynonym>> codeSynonymMaps, CodeImportResultVO resultVO){
 		Set<String> selfRepeatRowIndexList = new CopyOnWriteArraySet<>();
-		Map<String,List<String>> keyAttrOkOidTORepeatOidMap=new HashMap<>();
+		Map<String,List<String>> keyAttrOkOidTORepeatOidMap=new ConcurrentHashMap<>();
 		boolean trimAll =keyRuleVO ==null?false: VciBaseUtil.getBoolean(keyRuleVO.getIgnoreallspaceflag());
 		//鍏ㄩ儴鍘荤┖鐨勪紭鍏堢骇澶т簬鍘荤┖
 		boolean trim =keyRuleVO ==null?false:  VciBaseUtil.getBoolean(keyRuleVO.getIgnorespaceflag());
@@ -4081,16 +4637,16 @@
 		boolean ignoreWidth = keyRuleVO ==null?false: VciBaseUtil.getBoolean(keyRuleVO.getIgnorewidthflag());
 		//蹇呴』灏嗗睘鎬ф寜鐓ч『搴忔帓搴忓ソ
 		List<CodeClassifyTemplateAttrVO> attrVOList = ketAttrMap.values().stream().sorted(((o1, o2) -> o1.getOrderNum().compareTo(o2.getOrderNum()))).collect(Collectors.toList());
-		Map<String/**琛屽彿**/,String/**鍏抽敭灞炴�х殑缁勫悎鍐呭**/> rowIndexKeyStringMap = new HashMap<>();
-		Map<String/**鍏抽敭灞炴�х殑缁勫悎鍐呭**/,String/**绗竴涓叧閿睘鎬х殑鏁版嵁oid**/> okOidKeyStringMap = new HashMap<>();
-		dataList.parallelStream().forEach(cbo-> {
+		Map<String/**琛屽彿**/,String/**鍏抽敭灞炴�х殑缁勫悎鍐呭**/> rowIndexKeyStringMap = new ConcurrentHashMap<>();
+		Map<String/**鍏抽敭灞炴�х殑缁勫悎鍐呭**/,String/**绗竴涓叧閿睘鎬х殑鏁版嵁oid**/> okOidKeyStringMap = new ConcurrentHashMap<>();
+		dataList.stream().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);
-				String attrId = attrVO.getId().toLowerCase(Locale.ROOT);
-				String value = cbo.getAttributeValue( attrId);
+			// TODO锛� 2024-02-25鏀归�犲疄鐜拌繎涔夎瘝鏌ヨ瑙勫垯鍔熻兘锛涘叧閿睘鎬ч噸澶嶆牎楠屽�煎鐞�
+			attrVOList.stream().forEach(item->{
+				String attrId = item.getId().toLowerCase(Locale.ROOT);
+				String value = cbo.getAttributeValue(attrId);
 				if (value == null) {
 					value = "";
 				}
@@ -4106,8 +4662,9 @@
 				if(ignoreWidth){
 					value = VciBaseUtil.toDBC(value);
 				}
+				value = mdmEngineService.getValueToSynony(codeSynonymMaps.get(attrId),value);
 				sb.append(value).append("${ks}");
-			}
+			});
 			String keyString = sb.toString();
 			if(rowIndexKeyStringMap.containsValue(keyString) && StringUtils.isNotBlank(keyString)){
 				selfRepeatRowIndexList.add(rowIndex);
@@ -4118,17 +4675,17 @@
 					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());
+				rowIndexKeyStringMap.put(rowIndex, keyString);
 			}
 		});
 		//鍥犱负鍙槸鍏抽敭灞炴�ч噸澶嶏紝鎵�浠ユ垜浠笉鑳介噸澶嶇殑澶氭潯閫変竴鏉℃潵鎶ラ敊
-		resultVO.setKeyAttrRepeatRowIndexList(selfRepeatRowIndexList);
+//		resultVO.setKeyAttrRepeatRowIndexList(selfRepeatRowIndexList);
+		resultVO.setSelfRepeatRowIndexList(selfRepeatRowIndexList);
 		resultVO.setKeyAttrOkOidTORepeatOidMap(keyAttrOkOidTORepeatOidMap);
 	}
 
@@ -4157,11 +4714,14 @@
 			}
 		}
 	}
+
 	private List<ClientBusinessObject> ChangeMapTOClientBusinessObjects(List<Map<String,String>> oldDataMap){
 		List<ClientBusinessObject> clientBusinessObjectList=new ArrayList<>();
+		DefaultAttrAssimtUtil.mapToLowerCase(oldDataMap,true);
+		final BladeUser user = AuthUtil.getUser();
 		oldDataMap.stream().forEach(dataMap->{
 			ClientBusinessObject clientBusinessObject=new ClientBusinessObject();
-			DefaultAttrAssimtUtil.copplyDefaultAttrAssimt(dataMap,clientBusinessObject);
+			DefaultAttrAssimtUtil.copplyDefaultAttrAssimt(dataMap,clientBusinessObject,false,user);
 			for (String key:dataMap.keySet()){
 				Object value= dataMap.getOrDefault(key,"");
 				clientBusinessObject.setAttributeValue(key.toLowerCase(Locale.ROOT),value==null?"":value.toString());
@@ -4256,7 +4816,8 @@
 	private void createExeclClassData(List<String> titleRowData, CodeClassifyTemplateVO newTemplateVO, Map<Integer, String> execlData, CodeImprotDataVO codeImprotDataVO){
 		//闄ゅ幓榛樿鐨勫睘鎬�.杩樻湁鍙湁琛ㄥ崟鏄剧ず鐨勫瓧娈垫墠瀵煎叆
 		List<CodeClassifyTemplateAttrVO> attrVOS = newTemplateVO.getAttributes().stream().filter(s ->
-			!DEFAULT_ATTR_LIST.contains(s.getId()) && VciBaseUtil.getBoolean(s.getFormDisplayFlag())
+			!DEFAULT_ATTR_LIST.contains(s.getId()) &&
+				((Func.isNotEmpty(s.getClassifyInvokeAttr()) || Func.isNotEmpty(s.getClassifyInvokeAttrName())) || VciBaseUtil.getBoolean(s.getFormDisplayFlag()))
 		).collect(Collectors.toList());
 		Map<String/**涓枃鍚嶇О**/, String/**鑻辨枃鍚嶇О**/> attrNameIdMap = attrVOS.stream().collect(Collectors.toMap(s -> s.getName(), t -> t.getId()));
 		List<String> fields=new ArrayList<>();
@@ -4451,6 +5012,7 @@
 					pageHelper.addDefaultDesc("id");
 					CodeTemplateAttrSqlBO sqlBO = engineService.getSqlByTemplateVO(btmtypeid, templateVO, conditionMap, pageHelper);
 					List<Map<String,String>> dataMapList=commonsMapper.queryByOnlySqlForMap(sqlBO.getSqlUnPage());
+					DefaultAttrAssimtUtil.mapToLowerCase(dataMapList,true);
 					List<ClientBusinessObject> resembleCboList=	ChangeMapTOClientBusinessObjects(dataMapList);
 					if(!CollectionUtils.isEmpty(resembleCboList)) {
 						List<Map<String, String>> finalDataMap = dataMap;
@@ -4556,6 +5118,7 @@
 			bladeRedis.expire(uuid, BATCHADD_REDIS_TIME);//redis杩囨湡鏃堕棿
 		}
 	}
+
 	/**
 	 * 鎷疯礉涓氬姟绫诲瀷鍒癿ap
 	 * @param cbo 涓氬姟鏁版嵁
@@ -4613,7 +5176,7 @@
 	 * @return
 	 */
 	@Override
-	public String exportGroupCodeExcel(String codeClassifyOid) throws ServiceException {
+	public String exportGroupCodeExcel(String codeClassifyOid) throws VciBaseException {
 		VciBaseUtil.alertNotNull(codeClassifyOid,"涓婚搴撳垎绫荤殑涓婚敭");
 		CodeClassifyFullInfoBO classifyFullInfo = classifyService.getClassifyFullInfo(codeClassifyOid);
 		CodeClassifyVO codeClassifyVO= classifyFullInfo.getCurrentClassifyVO();
@@ -4624,8 +5187,8 @@
 
 		ExecGroupCodePortDataDTO execGroupCodePortDataDTO=new ExecGroupCodePortDataDTO();
 		createExportGroupCodeMapConfig(templateVO,execGroupCodePortDataDTO);//缁勭粐鏁版嵁
-		if(!CollectionUtils.isEmpty(execGroupCodePortDataDTO.getCodeAttrMapGroupAttrDTOS())){
-			throw new ServiceException("闆嗗洟灞炴�ф槧灏勬湭閰嶇疆");
+		if(CollectionUtils.isEmpty(execGroupCodePortDataDTO.getCodeAttrMapGroupAttrDTOS())){
+			throw new VciBaseException("闆嗗洟灞炴�ф槧灏勬湭閰嶇疆");
 		}
 		fieldList=execGroupCodePortDataDTO.getFieldList();
 		List<Map<String,String>>dataList=new ArrayList<>();
@@ -4645,9 +5208,7 @@
 		List<WriteExcelData> excelDataList = new ArrayList<>();
 		Workbook workbook = new HSSFWorkbook();
 		List<CodeAndGroupCodeAttrMappingDTO>  codeAndGroupCodeAttrMappingDTOList=	execGroupCodePortDataDTO.getCodeAttrMapGroupAttrDTOS();
-
 		Map<String, CodeAndGroupCodeAttrMappingDTO> jAttrVOMap = codeAndGroupCodeAttrMappingDTOList.stream().filter(s-> finalFieldList.contains(s.getTargetAttrKey().toLowerCase(Locale.ROOT))).collect(Collectors.toMap(s -> s.getTargetAttrKey().toLowerCase(Locale.ROOT), t -> t));
-
 		WriteExcelData codeExcelData = new WriteExcelData(0, 0, "浼佷笟缂栫爜");
 		WriteExcelData groupExcelData = new WriteExcelData(0, 1, "闆嗗洟鐮�");
 		excelDataList.add(codeExcelData);
@@ -4725,7 +5286,9 @@
 	 * @param file
 	 * @return
 	 */
-	public String improtGroupCode(String codeClassifyOid, File file) throws ServiceException {
+	@Transactional(rollbackFor = VciBaseException.class)
+	@Override
+	public String importGroupCode(String codeClassifyOid, File file) throws Throwable {
 		VciBaseUtil.alertNotNull(codeClassifyOid,"鍒嗙被鐨勪富閿�");
 		ReadExcelOption reo = new ReadExcelOption();
 		reo.setReadAllSheet(true);
@@ -4735,14 +5298,15 @@
 			throw new ServiceException("涓轰簡淇濊瘉绯荤粺鐨勭ǔ瀹氭�э紝璇蜂竴娆′笉瑕佸鍏ヨ秴杩�1涓囨潯鐨勬暟鎹�");
 		}
 		CodeClassifyFullInfoBO classifyFullInfo = classifyService.getClassifyFullInfo(codeClassifyOid);
-		CodeClassifyTemplateVO templateVO = new CodeClassifyTemplateVO();
-		//闄ゅ幓榛樿鐨勫睘鎬�.杩樻湁鍙湁琛ㄥ崟鏄剧ず鐨勫瓧娈垫墠瀵煎叆
-		List<CodeClassifyTemplateAttrVO> attrVOS = templateVO.getAttributes().stream().filter(s ->!DEFAULT_SYNC_ATTR_LIST.contains(s.getId()) && VciBaseUtil.getBoolean(s.getFormDisplayFlag())
+		//鑾峰彇鏈�鏂扮殑妯℃澘
+		CodeClassifyTemplateVO templateVO = engineService.getUsedTemplateByClassifyOid(codeClassifyOid);		//闄ゅ幓榛樿鐨勫睘鎬�.杩樻湁鍙湁琛ㄥ崟鏄剧ず鐨勫瓧娈垫墠瀵煎叆
+		List<CodeClassifyTemplateAttrVO> attrVOS = templateVO.getAttributes().stream().filter(s ->!DEFAULT_SYNC_ATTR_LIST.contains(s.getId()) &&
+			((Func.isNotEmpty(s.getClassifyInvokeAttr()) || Func.isNotEmpty(s.getClassifyInvokeAttrName())) || VciBaseUtil.getBoolean(s.getFormDisplayFlag()))
 		).collect(Collectors.toList());
 		ExecGroupCodePortDataDTO execGroupCodePortDataDTO=new ExecGroupCodePortDataDTO();
 		createExportGroupCodeMapConfig(templateVO,execGroupCodePortDataDTO);//缁勭粐鏁版嵁
 		List<CodeAndGroupCodeAttrMappingDTO> codeAttrMapGroupAttrDTOS=execGroupCodePortDataDTO.getCodeAttrMapGroupAttrDTOS();
-		if(!CollectionUtils.isEmpty(codeAttrMapGroupAttrDTOS)){
+		if(CollectionUtils.isEmpty(codeAttrMapGroupAttrDTOS)){
 			throw new ServiceException("闆嗗洟灞炴�ф槧灏勬湭閰嶇疆");
 		}
 		Map<String, CodeAndGroupCodeAttrMappingDTO> codeSystemObjectMap = codeAttrMapGroupAttrDTOS.stream().filter(codeAttrMappingDTO -> codeAttrMappingDTO != null && StringUtils.isNotBlank(codeAttrMappingDTO.getSourceAttrName())).collect(Collectors.toList()).stream().collect(Collectors.toMap(s -> s.getSourceAttrName(), t -> t));
@@ -4751,26 +5315,223 @@
 		Map<Integer/**鍒楀彿**/,String/**瀛楁鐨勫悕绉�**/> fieldIndexMap = new HashMap<>();
 		getGroupCodeFieldIndexMap(titleRowData,codeAttrMapGroupAttrDTOS,fieldIndexMap);
 		//闇�瑕佸垽鏂槸鍚︽墍鏈夌殑灞炴�ч兘鍦ㄦā鏉夸笂浜�
-		List<CodeClassifyTemplateAttrVO> unExistAttrVOs = attrVOS.stream().filter(s -> !fieldIndexMap.containsValue(s.getId().toLowerCase(Locale.ROOT))
+	/**	List<CodeClassifyTemplateAttrVO> unExistAttrVOs = attrVOS.stream().filter(s -> !fieldIndexMap.containsValue(s.getId().toLowerCase(Locale.ROOT))
 			&& com.alibaba.cloud.commons.lang.StringUtils.isBlank(s.getComponentRule()) && com.alibaba.cloud.commons.lang.StringUtils.isBlank(s.getClassifyInvokeAttr())//缁勫悎瑙勫垯鍜屽垎绫绘敞鍏ョ‘瀹炴病缁欑敤鎴峰鍑哄幓
 		).collect(Collectors.toList());
 		if(!CollectionUtils.isEmpty(unExistAttrVOs)){
 			String message=unExistAttrVOs.stream().map(CodeClassifyTemplateAttrVO::getName).collect(Collectors.joining(SERIAL_UNIT_SPACE));
 			throw new VciBaseException("銆�" + message + "銆戣繖浜涘睘鎬у湪excel涓病鏈夋壘鍒�");
-		}
+		}**/
 		List<ClientBusinessObject> cboList = new ArrayList<>();
 		List<SheetRowData> rowDataList = dataSet.getRowData();
 
 		getExportGroupCodeDatas(fieldIndexMap,rowDataList,cboList);//鏋勫缓鏁版嵁瀵硅薄
+
 		List<String> codeList= cboList.stream().map(ClientBusinessObject::getId).collect(Collectors.toList());
 		List<Map<String,String>>dataList=new ArrayList<>();
-		getDatas(classifyFullInfo,templateVO,execGroupCodePortDataDTO.getFieldList(),dataList,codeList);
-		//鏌ヨ绯荤粺涓瓨鍦�
-		if(!CollectionUtils.isEmpty(dataList)){
+		Map<String,String> errorMap=new HashMap<>();
+		batchSwitchCheckExist(errorMap,cboList,classifyFullInfo,templateVO,execGroupCodePortDataDTO,fieldIndexMap);
+		//鍒ゆ柇蹇呰緭椤�
+		batchCheckRequiredAttrOnOrder(templateVO, cboList, errorMap);
+	//	//浼樺厛鏍￠獙缂栫爜鏄惁瀛樺湪
+	//	batchCheckIdExistOnOrder(templateVO, cboList, errorMap);
+		//boolean
+		reSwitchBooleanAttrOnOrder(attrVOS, cboList);
 
+		// 鏋氫妇鐨勫唴瀹归渶瑕佹牴鎹悕绉拌浆鎹负鏋氫妇鐨勫��
+		batchSwitchEnumAttrOnOrder(attrVOS, cboList, errorMap);
 
+		batchSwitchReferAttrOnOrder(attrVOS, cboList, errorMap);
+		//6.澶勭悊鍒嗙被娉ㄥ叆
+		batchSwitchClassifyAttrOnOrder(attrVOS, cboList, classifyFullInfo,false);
+
+		//璁剧疆榛樿鍊�
+		batchSwitchAttrDefault(attrVOS, cboList);
+
+		//7.澶勭悊缁勫悎瑙勫垯
+		batchSwitchComponentAttrOnOrder(attrVOS, cboList);
+		//4.鏍￠獙瑙勫垯
+		batchCheckVerifyOnOrder(attrVOS, cboList, errorMap);
+		//6.鏃堕棿鐨勶紝蹇呴』缁熶竴涓簓yyy-MM-dd HH:mm:ss
+		batchSwitchDateAttrOnOrder(attrVOS, cboList, errorMap);
+		//3.鍒ゆ柇鍏抽敭灞炴��
+		CodeImportResultVO keyResultVO = batchCheckKeyAttrOnOrder(classifyFullInfo, templateVO, cboList,true,errorMap);
+		Set<String> selfRepeatRowIndexList = keyResultVO.getSelfRepeatRowIndexList();
+		Set<String> keyAttrRepeatRowIndexList = keyResultVO.getKeyAttrRepeatRowIndexList();
+		if (!CollectionUtils.isEmpty(selfRepeatRowIndexList)) {
+			selfRepeatRowIndexList.stream().forEach(rowIndex -> {
+				errorMap.put(rowIndex, errorMap.getOrDefault(rowIndex, "") + String.format(";浼犲叆鐨勬暟鎹腑鍏抽敭灞炴�ч噸澶峓%s],[%s];",keyResultVO.getKeyAttrRuleInfo(),keyResultVO.getSynonymRuleInfo()));
+				// errorMap.put(rowIndex, errorMap.getOrDefault(rowIndex, "") + ";鍦ㄥ綋鍓峞xcel鏂囦欢涓叧閿睘鎬ч噸澶�");
+			});
 		}
-		return "";
+		if (!CollectionUtils.isEmpty(keyAttrRepeatRowIndexList)) {
+			keyAttrRepeatRowIndexList.stream().forEach(rowIndex -> {
+				errorMap.put(rowIndex, errorMap.getOrDefault(rowIndex, "") + String.format("鍏抽敭灞炴�т笌绯荤粺涓殑閲嶅[%s],[%s];",keyResultVO.getKeyAttrRuleInfo(),keyResultVO.getSynonymRuleInfo()));
+				// errorMap.put(rowIndex, "鍏抽敭灞炴�т笌绯荤粺涓殑閲嶅;" + errorMap.getOrDefault(rowIndex, ""));
+			});
+		}
+		Map<String,List<WriteExcelData>> shetNameMap=new HashMap<>();
+		createWriteExcelData(rowDataList, errorMap, new ArrayList<>(), titleRowData, shetNameMap, templateVO);
+		String excelFileName="";
+		if(errorMap.size()==0) {
+			try {
+				String btmTypeId = classifyFullInfo.getTopClassifyVO().getBtmTypeId();
+				List<BaseModel>oldCbos= execGroupCodePortDataDTO.getOldList();
+				List<BaseModel>newCbos=new ArrayList<>();
+				// 淇敼鐗堟鍙�
+				engineService.updateBatchByBaseModel(btmTypeId,oldCbos);
+				List<CodeAllCode> codeAllCodeList=new ArrayList<>();
+				final BladeUser user = AuthUtil.getUser();
+				cboList.stream().forEach(clientBusinessObject -> {
+					BaseModel newBaseModel=new BaseModel();
+					DefaultAttrAssimtUtil.copplyDefaultAttrAssimt(clientBusinessObject.getData(),newBaseModel,false,user);
+					newCbos.add(newBaseModel);
+				});
+				// 鎻掑叆鏂扮殑鏁版嵁
+				engineService.insertBatchByType(btmTypeId, newCbos);
+				codeAllCodeService.saveOrUpdateBatch(execGroupCodePortDataDTO.getCodeAllCodeList());
+				engineService.batchSaveSelectChar(templateVO, newCbos);
+				// 璁板綍鏁版嵁鏇存敼鏃ュ織
+				saveLogUtil.operateLog("鏁版嵁鏇存敼", false, StringUtil.format("{}\n淇敼涓�:\n{}", JSON.toJSONString(oldCbos), JSON.toJSONString(newCbos)));
+			} catch (Exception vciError) {
+				// 璁板綍鏁版嵁鏇存敼鎶ラ敊鏃剁殑鏃ュ織
+				saveLogUtil.operateLog("鏁版嵁鏇存敼", true, vciError.toString());
+				throw new VciBaseException("鏁版嵁鏇存敼淇濆瓨鍑洪敊浜�", new String[0], vciError);
+			}
+		}else{
+			excelFileName = LocalFileUtil.getDefaultTempFolder() + File.separator + "閿欒淇℃伅.xls";
+			WriteExcelOption eo = new WriteExcelOption();
+			shetNameMap.forEach((shetName, errorDataList) -> {
+				eo.addSheetDataList(shetName, errorDataList);
+			});
+			try {
+				new File(excelFileName).createNewFile();
+			} catch (IOException e) {
+				throw new VciBaseException(LangBaseUtil.getErrorMsg(e));
+			}
+			ExcelUtil.writeDataToFile(excelFileName, eo);
+		}
+		return excelFileName;
+	}
+
+	public void batchSwitchCheckExist(Map<String,String> errorMap,List<ClientBusinessObject> cboList,CodeClassifyFullInfoBO classifyFullInfo,CodeClassifyTemplateVO templateVO,ExecGroupCodePortDataDTO execGroupCodePortDataDTO,Map<Integer/**鍒楀彿**/,String/**瀛楁鐨勫悕绉�**/> fieldIndexMap){
+		List<BaseModel> oldBaseModelList=new ArrayList<>();
+		List<CodeAllCode> codeAllCodeList=new ArrayList<>();
+		final BladeUser user = AuthUtil.getUser();
+		cboList.stream().forEach(clientBusinessObject -> {
+			String code=clientBusinessObject.getId();
+			String rowIndex=clientBusinessObject.getAttributeValue(IMPORT_ROW_INDEX);
+			List<Map<String,String>>dataList=new ArrayList<>();
+			List<String> fieldList= execGroupCodePortDataDTO.getFieldList();
+			getDatas(classifyFullInfo,templateVO,execGroupCodePortDataDTO.getFieldList(),dataList,Arrays.asList(code));
+			DefaultAttrAssimtUtil.mapToLowerCase(dataList,true);
+			if(!CollectionUtils.isEmpty(dataList)){
+				Map<String,String> newDataMap=new HashMap<>();//灏嗘柊瀵硅薄灞炴�ф殏鏃跺瓨鍌ㄥ湪Map<>
+				newDataMap.putAll(clientBusinessObject.getData());
+				Map<String,String> dataMap=dataList.get(0);
+				BaseModel oldBaseModel=new BaseModel();
+				DefaultAttrAssimtUtil.copplyDefaultAttrAssimt(dataMap,oldBaseModel,false,user);
+				String oldOid=oldBaseModel.getOid();
+
+				clientBusinessObject.setCopyFromVersion(oldOid);
+				clientBusinessObject.setAttributeValueWithNoCheck("copyfromversion",oldOid);
+				String oid=VciBaseUtil.getPk();
+				clientBusinessObject.setOid(oid);
+				clientBusinessObject.setAttributeValueWithNoCheck("oid",oid);
+				clientBusinessObject.setBtmname(oldBaseModel.getBtmname());
+				clientBusinessObject.setAttributeValueWithNoCheck("btmname",oldBaseModel.getBtmname());
+				clientBusinessObject.setLastR("1");
+				clientBusinessObject.setAttributeValueWithNoCheck("lastr","1");
+				clientBusinessObject.setFirstR("1");
+				clientBusinessObject.setAttributeValueWithNoCheck("firstr","1");
+				clientBusinessObject.setFirstV("1");
+				clientBusinessObject.setAttributeValueWithNoCheck("firstv","1");
+				clientBusinessObject.setLastV("1");
+				clientBusinessObject.setAttributeValueWithNoCheck("lastv","1");
+				clientBusinessObject.setRevisionSeq(1);
+				clientBusinessObject.setAttributeValueWithNoCheck("revisionseq","1");
+				clientBusinessObject.setVersionSeq(1);
+				clientBusinessObject.setAttributeValueWithNoCheck("versionseq","1");
+				clientBusinessObject.setRevisionRule(oldBaseModel.getRevisionRule());
+				clientBusinessObject.setAttributeValueWithNoCheck("revisionrule",oldBaseModel.getRevisionRule());
+				clientBusinessObject.setVersionRule(oldBaseModel.getRevisionRule());
+				clientBusinessObject.setAttributeValueWithNoCheck("versionrule",oldBaseModel.getVersionRule());
+				clientBusinessObject.setVersionValue(oldBaseModel.getVersionValue());
+				clientBusinessObject.setAttributeValueWithNoCheck("versionvalue",oldBaseModel.getVersionValue());
+				clientBusinessObject.setLctid(oldBaseModel.getLctid());
+				clientBusinessObject.setAttributeValueWithNoCheck("lctid",oldBaseModel.getLctid());
+				clientBusinessObject.setId(oldBaseModel.getId());
+				clientBusinessObject.setAttributeValueWithNoCheck("id",oldBaseModel.getId());
+				clientBusinessObject.setName(oldBaseModel.getName());
+				clientBusinessObject.setAttributeValueWithNoCheck("name",oldBaseModel.getName());
+				clientBusinessObject.setLcStatus(CodeDefaultLC.RELEASED.getValue());
+				clientBusinessObject.setAttributeValueWithNoCheck("lcstatus",CodeDefaultLC.RELEASED.getValue());
+				clientBusinessObject.setDescription("瀵煎叆闆嗗洟鐮�");
+				clientBusinessObject.setAttributeValueWithNoCheck("description","瀵煎叆闆嗗洟鐮�");
+				clientBusinessObject.setOwner("1");
+				clientBusinessObject.setAttributeValueWithNoCheck("owner","1");
+				clientBusinessObject.setTenantId(AuthUtil.getTenantId());
+				clientBusinessObject.setAttributeValueWithNoCheck("tenant_id",AuthUtil.getTenantId());
+				clientBusinessObject.setCreator(oldBaseModel.getCreator());
+				clientBusinessObject.setAttributeValueWithNoCheck("creator",oldBaseModel.getCreator());
+				SimpleDateFormat formatter= new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
+				clientBusinessObject.setCreateTime(oldBaseModel.getCreateTime());
+				clientBusinessObject.setAttributeValueWithNoCheck("createtime", formatter.format(oldBaseModel.getCreateTime()));
+				clientBusinessObject.setLastModifier(AuthUtil.getUserAccount());
+				clientBusinessObject.setAttributeValueWithNoCheck("lastmodifier",AuthUtil.getUserAccount());
+				clientBusinessObject.setCreateTime(new Date());
+				clientBusinessObject.setAttributeValueWithNoCheck("lastmodifytime", formatter.format(new Date()));
+				clientBusinessObject.setRevisionValue(String.valueOf(Integer.parseInt(oldBaseModel.getRevisionValue())+1));
+				clientBusinessObject.setRevisionOid(oldBaseModel.getRevisionOid());
+				clientBusinessObject.setAttributeValueWithNoCheck("revisionoid",oldBaseModel.getRevisionOid());
+				clientBusinessObject.setAttributeValueWithNoCheck("revisionvalue",String.valueOf(Integer.parseInt(oldBaseModel.getRevisionValue())+1));
+
+				clientBusinessObject.setNameOid(oldBaseModel.getNameOid());
+				clientBusinessObject.setAttributeValueWithNoCheck("nameoid",oldBaseModel.getNameOid());
+
+				clientBusinessObject.setAttributeValueWithNoCheck(CODE_CLASSIFY_OID_FIELD,oldBaseModel.getData().getOrDefault(CODE_CLASSIFY_OID_FIELD,""));
+				clientBusinessObject.setAttributeValueWithNoCheck(CODE_FULL_PATH_FILED,oldBaseModel.getData().getOrDefault(CODE_FULL_PATH_FILED,""));
+				clientBusinessObject.setAttributeValueWithNoCheck(CODE_TEMPLATE_OID_FIELD,oldBaseModel.getData().getOrDefault(CODE_TEMPLATE_OID_FIELD,""));
+				clientBusinessObject.setTs(new Date());
+				clientBusinessObject.setAttributeValueWithNoCheck("ts",formatter.format(new Date()));
+				oldBaseModel.setLastV("0");
+				oldBaseModel.getData().put("lastv","0");
+				oldBaseModelList.add(oldBaseModel);
+				List<CodeAllCode> oldCodeAllCodeList= codeAllCodeService.selectByWrapper(Wrappers.<CodeAllCode>query().lambda().eq(CodeAllCode::getId,code));
+				CodeAllCode codeAllCode=new CodeAllCode();
+				if(!CollectionUtils.isEmpty(oldCodeAllCodeList)){
+					codeAllCode=oldCodeAllCodeList.get(0);
+					codeAllCode.setId(code);
+					codeAllCode.setLcStatus(CodeDefaultLC.RELEASED.getValue());
+					codeAllCode.setCreateCodeOid(clientBusinessObject.getOid());
+					codeAllCode.setCreateCodeBtm(clientBusinessObject.getBtmname());
+					codeAllCode.setLastModifyTime(new Date());
+					codeAllCode.setLastModifier(AuthUtil.getUserAccount());
+					codeAllCodeList.add(codeAllCode);
+					if(!oldBaseModel.getLcStatus().equals(CodeDefaultLC.RELEASED.getValue())||!codeAllCode.getLcStatus().equals(CodeDefaultLC.RELEASED.getValue())){
+						errorMap.put(rowIndex,"绗�"+rowIndex+"琛岋紝鍦ㄧ郴缁熶腑鏁版嵁涓嶆槸鍙戝竷鐘舵��");
+					}
+				}else{
+					errorMap.put(rowIndex,"绗�"+rowIndex+"琛岋紝鍦ㄧ郴缁熶腑鏈煡璇㈠埌鐩稿簲鐨勭爜鍊兼暟鎹�");
+				}
+				//闄ゅ幓榛樿鐨勫睘鎬�.杩樻湁鍙湁琛ㄥ崟鏄剧ず鐨勫瓧娈垫墠瀵煎叆
+				List<CodeClassifyTemplateAttrVO> attrVOS = templateVO.getAttributes().stream().filter(s ->!fieldIndexMap.containsValue(s.getId()) &&
+					((Func.isNotEmpty(s.getClassifyInvokeAttr()) || Func.isNotEmpty(s.getClassifyInvokeAttrName())) || VciBaseUtil.getBoolean(s.getFormDisplayFlag()))
+				).collect(Collectors.toList());
+				attrVOS.stream().forEach(codeClassifyTemplateAttrVO -> {//灏嗕笉闇�瑕佹洿鏀圭殑榛樿瀛楁鎴栬�呬笉鏇存敼鐨勫睘鎬у鍒跺埌鏂扮殑鐗堟湰涓�
+					String arrtibuteKey=codeClassifyTemplateAttrVO.getId();
+					Map<String,String>attrDataMap=oldBaseModel.getData();
+					if(attrDataMap.containsKey(arrtibuteKey)){
+						String arrtibuteValue=attrDataMap.get(arrtibuteKey);
+						clientBusinessObject.setAttributeValueWithNoCheck(arrtibuteKey,arrtibuteValue);
+					}
+				});
+			}else{
+				errorMap.put(rowIndex,"绗�"+rowIndex+"琛岋紝鍦ㄧ郴缁熶腑鏈煡璇㈠埌鐩稿簲鐨勬渶鏂扮増鏁版嵁");
+			}
+		});
+		execGroupCodePortDataDTO.setOldList(oldBaseModelList);
+		execGroupCodePortDataDTO.setCodeAllCodeList(codeAllCodeList);
 	}
 
 	/**
@@ -4781,8 +5542,10 @@
 	 */
 	private void getExportGroupCodeDatas(Map<Integer,String> fieldIndexMap,List<SheetRowData> rowDataList,List<ClientBusinessObject>cboList){
 		rowDataList.stream().forEach(sheetRowData -> {
+			String rowIndex= sheetRowData.getRowIndex();
+			ClientBusinessObject cbo=new ClientBusinessObject();
+			cbo.setAttributeValue(IMPORT_ROW_INDEX,rowIndex);
 			sheetRowData.getData().forEach((index,value)->{
-				ClientBusinessObject cbo=new ClientBusinessObject();
 				String field = fieldIndexMap.get(index);
 				if (StringUtils.isBlank(field)) {
 					throw new VciBaseException("绗�" + (index + 1) + "鍒楃殑鏍囬鍦ㄧ郴缁熶腑涓嶅瓨鍦�");
@@ -4795,10 +5558,11 @@
 				} catch (VciBaseException e) {
 					log.error("璁剧疆灞炴�х殑鍊奸敊璇�", e);
 				}
-				cboList.add(cbo);
 			});
+			cboList.add(cbo);
 		});
 	}
+
 	/***
 	 * 闆嗗洟瀵煎嚭妯℃澘灞炴�ф槧灏勪俊鎭幏鍙�
 	 * @param templateVO
@@ -4844,21 +5608,25 @@
 		Map<String, CodeAndGroupCodeAttrMappingDTO> codeSystemObjectMap = codeAttrMapGroupAttrDTOS.stream().filter(codeAttrMappingDTO -> codeAttrMappingDTO != null && StringUtils.isNotBlank(codeAttrMappingDTO.getSourceAttrName())).collect(Collectors.toList()).stream().collect(Collectors.toMap(s -> s.getSourceAttrName(), t -> t));
 		for (int i = 0; i < titleRowData.size(); i++) {
 			String title = titleRowData.get(i);
-			CodeAndGroupCodeAttrMappingDTO codeAndGroupCodeAttrMappingDTO =codeSystemObjectMap.get(title.replace(KEY_ATTR_CHAR,"").replace(REQUIRED_CHAR,""));
-			String id=codeAndGroupCodeAttrMappingDTO.getTargetAttrKey();
-			if(com.alibaba.cloud.commons.lang.StringUtils.isBlank(id) && "闆嗗洟鐮�".equalsIgnoreCase(title)){
+			String id = "";
+			if ("闆嗗洟鐮�".equalsIgnoreCase(title)) {
 				id = CODE_GROUP_FIELD;
 			}
-			if(com.alibaba.cloud.commons.lang.StringUtils.isBlank(id) && "浼佷笟缂栫爜".equalsIgnoreCase(title)){
+			if ("浼佷笟缂栫爜".equalsIgnoreCase(title)) {
 				id = CODE_FIELD;
 			}
-			if(com.alibaba.cloud.commons.lang.StringUtils.isNotBlank(id)){
-				fieldIndexMap.put(i,id);
+			if(codeSystemObjectMap.containsKey(title)) {
+				CodeAndGroupCodeAttrMappingDTO codeAndGroupCodeAttrMappingDTO = codeSystemObjectMap.get(title.replace(KEY_ATTR_CHAR, "").replace(REQUIRED_CHAR, ""));
+				id = codeAndGroupCodeAttrMappingDTO.getTargetAttrKey();
+			}
+			if (com.alibaba.cloud.commons.lang.StringUtils.isNotBlank(id)) {
+				fieldIndexMap.put(i, id);
 			}
 		}
 
 
 	}
+
 	/***
 	 * 鏌ヨ鏈湁闆嗗洟鐮佺殑鏁版嵁
 	 * @param classifyFullInfo
@@ -4866,7 +5634,7 @@
 	 * @param selectFieldList
 	 * @param dataList
 	 */
-	private void getDatas(CodeClassifyFullInfoBO classifyFullInfo,CodeClassifyTemplateVO templateVO,LinkedList<String> selectFieldList,List<Map<String,String>>dataList,List<String> codeList ){
+	private void getDatas(CodeClassifyFullInfoBO classifyFullInfo,CodeClassifyTemplateVO templateVO,LinkedList<String> selectFieldList,List<Map<String,String>>dataList,List<String> codeList){
 		//鍏堟煡璇㈡暟鎹�
 		String btmTypeId = classifyFullInfo.getTopClassifyVO().getBtmTypeId();
 		String codeClassifyOid=classifyFullInfo.getCurrentClassifyVO().getOid();

--
Gitblit v1.9.3