From ffb3d0f1af7e5a93b9a509b0838d9b58a1449bdc Mon Sep 17 00:00:00 2001
From: xiejun <xj@2023>
Date: 星期三, 14 六月 2023 14:27:16 +0800
Subject: [PATCH] 批量申请接口提交

---
 Source/UBCS/ubcs-service-api/ubcs-omd-api/src/main/java/com/vci/ubcs/omd/util/Tool.java                           |   39 +
 Source/UBCS/ubcs-service-api/ubcs-util-api/src/main/java/com/vci/ubcs/starter/web/util/WebUtil.java               |   13 
 Source/UBCS/ubcs-service/ubcs-code/src/main/java/com/vci/ubcs/code/util/AttributeChecker.java                     |  115 ++++
 Source/UBCS/ubcs-service-api/ubcs-util-api/src/main/java/com/vci/ubcs/starter/poi/util/ExcelUtil.java             |    4 
 Source/UBCS/ubcs-service/ubcs-code/src/main/java/com/vci/ubcs/code/service/impl/MdmIOServiceImpl.java             | 1159 ++++++++++++++++++++++++++++++++++++++----
 Source/UBCS/ubcs-service-api/ubcs-code-api/src/main/java/com/vci/ubcs/code/vo/pagemodel/CodeImportTemplateVO.java |   11 
 Source/UBCS/ubcs-service-api/ubcs-util-api/src/main/java/com/vci/ubcs/starter/util/DefaultAttrAssimtUtil.java     |   71 ++
 Source/UBCS/ubcs-service/ubcs-code/src/main/java/com/vci/ubcs/code/util/ClientBusinessObject.java                 |  111 ++++
 Source/UBCS/ubcs-service/ubcs-code/src/main/java/com/vci/ubcs/code/mapper/CommonsMapper.java                      |    3 
 Source/UBCS/ubcs-service-api/ubcs-util-api/src/main/java/com/vci/ubcs/starter/web/util/VciBaseUtil.java           |   33 +
 Source/UBCS/ubcs-service-api/ubcs-code-api/src/main/java/com/vci/ubcs/code/bo/AttributeValue.java                 |   16 
 11 files changed, 1,442 insertions(+), 133 deletions(-)

diff --git a/Source/UBCS/ubcs-service-api/ubcs-code-api/src/main/java/com/vci/ubcs/code/bo/AttributeValue.java b/Source/UBCS/ubcs-service-api/ubcs-code-api/src/main/java/com/vci/ubcs/code/bo/AttributeValue.java
new file mode 100644
index 0000000..a5f00c9
--- /dev/null
+++ b/Source/UBCS/ubcs-service-api/ubcs-code-api/src/main/java/com/vci/ubcs/code/bo/AttributeValue.java
@@ -0,0 +1,16 @@
+package com.vci.ubcs.code.bo;
+
+import org.omg.CORBA.portable.IDLEntity;
+
+public class AttributeValue implements IDLEntity {
+	public String attrName = "";
+	public String attrVal = "";
+
+	public AttributeValue() {
+	}
+
+	public AttributeValue(String attrName, String attrVal) {
+		this.attrName = attrName;
+		this.attrVal = attrVal;
+	}
+}
diff --git a/Source/UBCS/ubcs-service-api/ubcs-code-api/src/main/java/com/vci/ubcs/code/vo/pagemodel/CodeImportTemplateVO.java b/Source/UBCS/ubcs-service-api/ubcs-code-api/src/main/java/com/vci/ubcs/code/vo/pagemodel/CodeImportTemplateVO.java
index 815febf..fb62869 100644
--- a/Source/UBCS/ubcs-service-api/ubcs-code-api/src/main/java/com/vci/ubcs/code/vo/pagemodel/CodeImportTemplateVO.java
+++ b/Source/UBCS/ubcs-service-api/ubcs-code-api/src/main/java/com/vci/ubcs/code/vo/pagemodel/CodeImportTemplateVO.java
@@ -1,13 +1,22 @@
 package com.vci.ubcs.code.vo.pagemodel;
 
+import lombok.Data;
+
 import java.util.ArrayList;
 import java.util.List;
 
+/****
+ * 鎵归噺鐢宠redis缂撳瓨瀵硅薄
+ * @author xiejun
+ * @date 2023-06-14
+ */
+@Data
 public class CodeImportTemplateVO {
     private List<ColumnVO> cloNamesList=new ArrayList<>();
 
-    private CodeClassifyTemplateVO codeClstemplateVO;
+    private CodeClassifyTemplateVO codeClassifyTemplateVO;
 
     private CodeClassifyVO codeClassifyVO;
 
+
 }
diff --git a/Source/UBCS/ubcs-service-api/ubcs-omd-api/src/main/java/com/vci/ubcs/omd/util/Tool.java b/Source/UBCS/ubcs-service-api/ubcs-omd-api/src/main/java/com/vci/ubcs/omd/util/Tool.java
new file mode 100644
index 0000000..7e56809
--- /dev/null
+++ b/Source/UBCS/ubcs-service-api/ubcs-omd-api/src/main/java/com/vci/ubcs/omd/util/Tool.java
@@ -0,0 +1,39 @@
+package com.vci.ubcs.omd.util;
+
+import java.util.ArrayList;
+
+public class Tool {
+
+	public static final String ALLOWNULL = "allowNull";
+	public static final String BTM = "btm";
+	public static final String ISFIXLEN = "isFixLen";
+	public static final String LENGTH = "length";
+	public static final String ENUMNAME = "enumName";
+	public static final String ACCURACY = "accuracy";
+	public static final String LINKTYPENAME = "linkTypeName";
+	public static final String VERSION = "version";
+
+
+	public static ArrayList<String> convertArrayToList(String[] array) {
+		ArrayList<String> list = new ArrayList();
+
+		for(int i = 0; i < array.length; ++i) {
+			list.add(array[i]);
+		}
+
+		return list;
+	}
+
+	public static String getOtherValueByType(String other, String type) {
+		String[] otherArray = other.split(";");
+
+		for(int i = 0; i < otherArray.length; ++i) {
+			String otherValue = otherArray[i];
+			if (otherValue.contains(type)) {
+				return otherValue.substring(otherValue.indexOf("=") + 2, otherValue.length());
+			}
+		}
+
+		return null;
+	}
+}
diff --git a/Source/UBCS/ubcs-service-api/ubcs-util-api/src/main/java/com/vci/ubcs/starter/poi/util/ExcelUtil.java b/Source/UBCS/ubcs-service-api/ubcs-util-api/src/main/java/com/vci/ubcs/starter/poi/util/ExcelUtil.java
index 4d48b36..3ed42a7 100644
--- a/Source/UBCS/ubcs-service-api/ubcs-util-api/src/main/java/com/vci/ubcs/starter/poi/util/ExcelUtil.java
+++ b/Source/UBCS/ubcs-service-api/ubcs-util-api/src/main/java/com/vci/ubcs/starter/poi/util/ExcelUtil.java
@@ -61,6 +61,10 @@
 	private static Logger logger = LoggerFactory.getLogger(ExcelUtil.class);
 	public static final String KEY_ATTR_CHAR = "鈽�";
 	public static final String REQUIRED_CHAR = "*";
+	/**
+	 * 鏇挎崲瀛楃
+	 */
+	public static final String SPECIAL_CHAR  = "VCI";
 
 	public ExcelUtil() {
 	}
diff --git a/Source/UBCS/ubcs-service-api/ubcs-util-api/src/main/java/com/vci/ubcs/starter/util/DefaultAttrAssimtUtil.java b/Source/UBCS/ubcs-service-api/ubcs-util-api/src/main/java/com/vci/ubcs/starter/util/DefaultAttrAssimtUtil.java
index 251eb48..0430da1 100644
--- a/Source/UBCS/ubcs-service-api/ubcs-util-api/src/main/java/com/vci/ubcs/starter/util/DefaultAttrAssimtUtil.java
+++ b/Source/UBCS/ubcs-service-api/ubcs-util-api/src/main/java/com/vci/ubcs/starter/util/DefaultAttrAssimtUtil.java
@@ -1,6 +1,6 @@
 package com.vci.ubcs.starter.util;
 
-import com.alibaba.druid.util.StringUtils;
+import com.baomidou.mybatisplus.core.toolkit.StringUtils;
 import com.vci.ubcs.starter.exception.VciBaseException;
 import com.vci.ubcs.starter.revision.model.BaseModel;
 import com.vci.ubcs.starter.web.util.VciBaseUtil;
@@ -9,8 +9,11 @@
 
 import java.lang.reflect.Field;
 import java.math.BigDecimal;
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
 import java.util.Date;
 import java.util.Locale;
+import java.util.Map;
 
 /**
  * 鏂板鏃堕粯璁ゅ�煎睘鎬ц祴鍊�
@@ -50,7 +53,7 @@
 			baseModel.setVersionSeq(1);
 			baseModel.setVersionRule("0");
 			baseModel.setVersionValue("1");
-			baseModel.setNameOid(VciBaseUtil.getPk());
+			baseModel.setRevisionOid(VciBaseUtil.getPk());
 			baseModel.setLastModifier(userId);
 		}catch (VciBaseException e){
 			e.printStackTrace();
@@ -79,4 +82,68 @@
 		return (T)baseModel;
 	}
 
+
+
+	/**
+	 * 鏂板鏃跺～鍏呴粯璁ゅ��
+	 * @param object 缁ф壙浜咮aseModel鐨勫疄浣撳璞�
+	 * @param <T>   杩斿洖鍊肩殑绫诲瀷
+	 * @return
+	 * @throws VciBaseException
+	 */
+	public static <T extends BaseModel> T copplyDefaultAttrAssimt(Map<String,String> dataMap, T object) throws VciBaseException {
+		BaseModel baseModel = object;
+		try {
+			SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
+			baseModel.setOid(dataMap.getOrDefault("OID",""));
+			String createTime=dataMap.getOrDefault("CREATETIME","");
+			baseModel.setCreateTime(chageStringToDate(createTime));
+			baseModel.setNameOid(dataMap.getOrDefault("NAMEOID",""));
+
+			String lastModifyTime=dataMap.getOrDefault("LASTMODIFYTIME","");
+			baseModel.setLastModifyTime(chageStringToDate(lastModifyTime));
+			String ts=dataMap.getOrDefault("TS","");
+			baseModel.setTs(chageStringToDate(ts));
+			baseModel.setRevisionOid(dataMap.getOrDefault("REVISIONOID",""));
+			//鐢ㄦ埛id
+			String userId = AuthUtil.getUserId().toString();
+			baseModel.setBtmname(dataMap.getOrDefault("BTMNAME",""));
+			baseModel.setCreator(dataMap.getOrDefault("CREATOR",""));
+			baseModel.setFirstR(dataMap.getOrDefault("FIRSTR",""));
+			baseModel.setFirstV(dataMap.getOrDefault("FIRSTV",""));
+			baseModel.setLastR(dataMap.getOrDefault("LASTR",""));
+			baseModel.setLastV(dataMap.getOrDefault("LASTV",""));
+			baseModel.setRevisionSeq(chageStringToInt(dataMap.getOrDefault("REVISIONSEQ","")));
+			baseModel.setOwner(dataMap.getOrDefault("OWNER",""));
+			baseModel.setVersionSeq(chageStringToInt(dataMap.getOrDefault("VERSIONSEQ","")));
+			baseModel.setVersionRule(dataMap.getOrDefault("VERSIONRULE",""));
+			baseModel.setVersionValue(dataMap.getOrDefault("VERSIONVALUE",""));
+			baseModel.setRevisionOid(dataMap.getOrDefault("REVISIONOID",""));
+			baseModel.setLastModifier(userId);
+		}catch (VciBaseException e){
+			e.printStackTrace();
+		}
+		return (T)baseModel;
+	}
+
+	private static int chageStringToInt(String value){
+		int newValue=0;
+		if(StringUtils.isNotBlank(value)){
+			newValue = Integer.parseInt(value);
+		}
+		return newValue;
+	}
+
+	private static Date chageStringToDate(String value){
+		SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
+		Date date=new Date();
+		if(StringUtils.isNotBlank(value)){
+			try {
+				date = format.parse(value);
+			} catch (ParseException e) {
+				e.printStackTrace();
+			}
+		}
+		return date;
+	}
 }
diff --git a/Source/UBCS/ubcs-service-api/ubcs-util-api/src/main/java/com/vci/ubcs/starter/web/util/VciBaseUtil.java b/Source/UBCS/ubcs-service-api/ubcs-util-api/src/main/java/com/vci/ubcs/starter/web/util/VciBaseUtil.java
index 4a3e097..72c68e0 100644
--- a/Source/UBCS/ubcs-service-api/ubcs-util-api/src/main/java/com/vci/ubcs/starter/web/util/VciBaseUtil.java
+++ b/Source/UBCS/ubcs-service-api/ubcs-util-api/src/main/java/com/vci/ubcs/starter/web/util/VciBaseUtil.java
@@ -1143,7 +1143,38 @@
 	public static <T> Collection<Collection<T>> switchCollectionForOracleIn(Collection<T> list) {
 		return switchCollectionForOracleIn(list, 500);
 	}
-
+	/**
+	 * oracle in 鏌ヨ涓嶈兘瓒呰繃1000锛岃浆鎹竴涓嬮泦鍚�
+	 * 鐢变簬SQL璇彞1000涓彲鑳藉緢闀匡紝瓒呰繃oracle10g锛屾墍浠ョ壓鐗叉�ц兘鍒嗛厤涓�500涓暟缁�
+	 * @param list 闇�瑕佽浆鎹㈢殑鍒楄〃鍐呭
+	 * @return 鍒嗙粍鍚庣殑list
+	 */
+	public static <T> List<List<T>> switchListForOracleIn(List<T> list) {
+		List<List<T>> listHasList = new ArrayList<List<T>>();
+		if(list == null){
+			return listHasList;
+		}
+		List<T> newList = new ArrayList<T>();
+		for(Object obj : list){
+			//涓轰簡璁﹍ist杩樺彲浠ユ坊鍔犲唴瀹癸紝鍥犱负浣跨敤sublist鍚庯紝list涓嶈兘鍐岮dd浜�
+			newList.add((T)obj);
+		}
+		int muti = 1;
+		if(newList.size() >500){
+			int balance = newList.size()%500;
+			muti = (newList.size() - balance)/500 + (balance == 0?0:1);
+		}
+		for(int i = 0 ; i < muti; i ++){
+			int start = i*500;
+			int end = start + 500;
+			if(i == muti-1 || end >newList.size() ){
+				end = newList.size();
+			}
+			List subList = newList.subList(start,end);
+			listHasList.add(subList);
+		}
+		return listHasList;
+	}
 	public static <T> Collection<Collection<T>> switchCollectionForOracleIn(Collection<T> collection, int preSize) {
 		Collection<Collection<T>> listHasList = new ArrayList();
 		if (collection == null) {
diff --git a/Source/UBCS/ubcs-service-api/ubcs-util-api/src/main/java/com/vci/ubcs/starter/web/util/WebUtil.java b/Source/UBCS/ubcs-service-api/ubcs-util-api/src/main/java/com/vci/ubcs/starter/web/util/WebUtil.java
index 4eaae34..b26ae59 100644
--- a/Source/UBCS/ubcs-service-api/ubcs-util-api/src/main/java/com/vci/ubcs/starter/web/util/WebUtil.java
+++ b/Source/UBCS/ubcs-service-api/ubcs-util-api/src/main/java/com/vci/ubcs/starter/web/util/WebUtil.java
@@ -724,5 +724,18 @@
 		}
 		return listHasList;
 	}
+	/**
+	 * 鏄惁榛樿鐨勫睘鎬�
+	 * @param fieldNames 灞炴�х殑鍚嶅瓧
+	 * @return true涓洪粯璁�
+	 */
+	public static boolean isDefaultField(String fieldNames){
+		if(VciQueryWrapperForDO.BASIC_FIELD_MAP.containsKey(fieldNames) || VciQueryWrapperForDO.LIFECYCLE_MANAGE_FIELD_MAP.containsKey(fieldNames)
+			|| VciQueryWrapperForDO.REVISION_MANAGE_FIELD_MAP.containsKey(fieldNames) ) {
+			return true;
+		}
+		return false;
+	}
+
 
 }
diff --git a/Source/UBCS/ubcs-service/ubcs-code/src/main/java/com/vci/ubcs/code/mapper/CommonsMapper.java b/Source/UBCS/ubcs-service/ubcs-code/src/main/java/com/vci/ubcs/code/mapper/CommonsMapper.java
index 1de1374..c99ba21 100644
--- a/Source/UBCS/ubcs-service/ubcs-code/src/main/java/com/vci/ubcs/code/mapper/CommonsMapper.java
+++ b/Source/UBCS/ubcs-service/ubcs-code/src/main/java/com/vci/ubcs/code/mapper/CommonsMapper.java
@@ -20,6 +20,9 @@
 
 	List<String> selectById(@Param("inSql") String inSql);
 
+
+	int  queryCountBySql(@Param("inSql") String inSql);
+
 	List<Map> selectBySql(@Param("inSql") String inSql);
 
 	List<Map<String,String>> queryByOnlySqlForMap(@Param("inSql") String inSql);
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 526c013..c1fe797 100644
--- a/Source/UBCS/ubcs-service/ubcs-code/src/main/java/com/vci/ubcs/code/service/impl/MdmIOServiceImpl.java
+++ b/Source/UBCS/ubcs-service/ubcs-code/src/main/java/com/vci/ubcs/code/service/impl/MdmIOServiceImpl.java
@@ -1,11 +1,17 @@
 package com.vci.ubcs.code.service.impl;
 
+import com.alibaba.fastjson.JSONObject;
 import com.alibaba.nacos.common.utils.StringUtils;
+import com.vci.ubcs.code.bo.AttributeValue;
 import com.vci.ubcs.code.bo.CodeClassifyFullInfoBO;
+import com.vci.ubcs.code.bo.CodeTemplateAttrSqlBO;
 import com.vci.ubcs.code.dto.CodeOrderDTO;
-import com.vci.ubcs.code.service.ICodeClassifyService;
-import com.vci.ubcs.code.service.MdmEngineService;
-import com.vci.ubcs.code.service.MdmIOService;
+import com.vci.ubcs.code.enumpack.CodeDefaultLC;
+import com.vci.ubcs.code.enumpack.CodeLevelTypeEnum;
+import com.vci.ubcs.code.mapper.CommonsMapper;
+import com.vci.ubcs.code.service.*;
+import com.vci.ubcs.code.util.ClientBusinessObject;
+import com.vci.ubcs.code.vo.CodeKeyAttrRepeatVO;
 import com.vci.ubcs.code.vo.pagemodel.*;
 import com.vci.ubcs.code.vo.webserviceModel.attrmap.DataObjectVO;
 import com.vci.ubcs.code.vo.webserviceModel.attrmap.RowDatas;
@@ -17,14 +23,19 @@
 import com.vci.ubcs.starter.poi.bo.SheetRowData;
 import com.vci.ubcs.starter.poi.bo.WriteExcelOption;
 import com.vci.ubcs.starter.poi.util.ExcelUtil;
+import com.vci.ubcs.starter.revision.model.BaseModel;
+import com.vci.ubcs.starter.util.DefaultAttrAssimtUtil;
 import com.vci.ubcs.starter.util.LocalFileUtil;
+import com.vci.ubcs.starter.web.enumpck.BooleanEnum;
 import com.vci.ubcs.starter.web.enumpck.VciFieldTypeEnum;
 import com.vci.ubcs.starter.web.pagemodel.DataGrid;
 import com.vci.ubcs.starter.web.pagemodel.KeyValue;
-import com.vci.ubcs.starter.web.util.LangBaseUtil;
-import com.vci.ubcs.starter.web.util.VciBaseUtil;
-import com.vci.ubcs.starter.web.util.VciDateUtil;
+import com.vci.ubcs.starter.web.pagemodel.PageHelper;
+import com.vci.ubcs.starter.web.pagemodel.UIFormReferVO;
+import com.vci.ubcs.starter.web.toolmodel.DateConverter;
+import com.vci.ubcs.starter.web.util.*;
 import lombok.AllArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
 import org.apache.poi.hssf.usermodel.HSSFRichTextString;
 import org.apache.poi.hssf.usermodel.HSSFWorkbook;
 import org.apache.poi.hssf.util.HSSFColor;
@@ -33,6 +44,9 @@
 import org.apache.poi.ss.usermodel.Workbook;
 import org.springblade.core.redis.cache.BladeRedis;
 import org.springframework.beans.BeanUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.data.redis.core.RedisTemplate;
 import org.springframework.stereotype.Service;
 import org.springframework.util.CollectionUtils;
 
@@ -40,23 +54,31 @@
 import java.io.File;
 import java.io.IOException;
 import java.util.*;
+import java.util.concurrent.CopyOnWriteArrayList;
+import java.util.concurrent.CopyOnWriteArraySet;
 import java.util.stream.Collectors;
 
 import static com.alibaba.druid.util.FnvHash.Constants.LIMIT;
 import static com.vci.ubcs.code.constant.MdmEngineConstant.*;
-import static com.vci.ubcs.starter.poi.util.ExcelUtil.KEY_ATTR_CHAR;
-import static com.vci.ubcs.starter.poi.util.ExcelUtil.REQUIRED_CHAR;
+import static com.vci.ubcs.starter.poi.util.ExcelUtil.*;
 
 @AllArgsConstructor
 @Service
+@Slf4j
 public class MdmIOServiceImpl implements MdmIOService {
-
-
+	@Value("${batchadd.redis.time:6000000}")
+	public int BATCHADD_REDIS_TIME;
 	/**
 	 * 涓婚搴撳垎绫荤殑鏈嶅姟
 	 */
 	@Resource
 	private ICodeClassifyService classifyService;
+
+	/**
+	 * 閫氱敤鏌ヨ
+	 */
+	@Resource
+	CommonsMapper commonsMapper;
 
 	/**
 	 * 妯℃澘鐨勬湇鍔�
@@ -69,9 +91,26 @@
 	 */
 	@Resource
 	private MdmEngineService engineService;
-
+	/***
+	 * resdis缂撳瓨鏈嶅姟
+	 */
 	private final BladeRedis bladeRedis;
+	/**
+	 * 鐢熸垚缂栫爜鐨勬湇鍔�
+	 */
+	@Resource
+	private MdmProductCodeService productCodeService;
+	/**
+	 * 鍏抽敭灞炴�х殑閰嶇疆
+	 */
+	@Autowired
+	private ICodeKeyAttrRepeatService keyRuleService;
 
+	/**
+	 * 鍏紡鐨勬湇鍔�
+	 */
+	@Autowired
+	private FormulaServiceImpl formulaService;
 	/**
 	 * 鐢熸垚瀵煎叆鐨勬枃浠�
 	 *
@@ -350,125 +389,140 @@
 	 */
 	private String batchImportCodes(CodeOrderDTO orderDTO,CodeClassifyTemplateVO templateVO,SheetDataSet dataSet,Map<String,String> errorMap,boolean isEnumType){
 		List<String> codeList=new ArrayList<>();
-//		CodeClassifyFullInfoBO classifyFullInfo = classifyService.getClassifyFullInfo(orderDTO.getCodeClassifyOid());
+		CodeClassifyFullInfoBO classifyFullInfo = classifyService.getClassifyFullInfo(orderDTO.getCodeClassifyOid());
 		//瑙勫垯鐨勪富閿渶瑕佸幓鑾峰彇
-//		CodeRuleVO ruleVO = engineService.getCodeRuleByClassifyFullInfo(classifyFullInfo);
-//		//1.鍒ゆ柇瑙勫垯涓櫎浜嗘祦姘寸爜娈碉紝鏄惁鏈夊叾浠栫爜娈�
-//		engineService.checkSecValueOnOrder(ruleVO,orderDTO);
-//		List<SheetRowData> rowDataList = dataSet.getRowData();
-//
-//		//闄ゅ幓榛樿鐨勫睘鎬�.杩樻湁鍙湁琛ㄥ崟鏄剧ず鐨勫瓧娈垫墠瀵煎叆
-//		List<CodeClassifyTemplateAttrVO> attrVOS = templateVO.getAttributes().stream().filter(s ->
-//			!DEFAULT_ATTR_LIST.contains(s.getId()) && VciBaseUtil.getBoolean(s.getFormdisplayflag())
-//		).collect(Collectors.toList());
-//		Map<Integer/**鍒楀彿**/,String/**瀛楁鐨勫悕绉�**/> fieldIndexMap = new HashMap<>();
-//		List<String> titleRowData = dataSet.getColName();
-//		Map<String/**涓枃鍚嶇О**/, String/**鑻辨枃鍚嶇О**/> attrNameIdMap = attrVOS.stream().collect(Collectors.toMap(s -> s.getName(), t -> t.getId().toLowerCase(Locale.ROOT),(o1, o2)->o2));
-//		getFieldIndexMap(titleRowData,attrNameIdMap,fieldIndexMap);
-//
-//		//闇�瑕佸垽鏂槸鍚︽墍鏈夌殑灞炴�ч兘鍦ㄦā鏉夸笂浜�
-//		List<CodeClassifyTemplateAttrVO> unExistAttrVOs = attrVOS.stream().filter(s -> !fieldIndexMap.containsValue(s.getId().toLowerCase(Locale.ROOT))
-//			&& StringUtils.isBlank(s.getComponentrule()) && StringUtils.isBlank(s.getClassifyinvokeattr())//缁勫悎瑙勫垯鍜屽垎绫绘敞鍏ョ‘瀹炴病缁欑敤鎴峰鍑哄幓
-//		).collect(Collectors.toList());
-//		if(!CollectionUtils.isEmpty(unExistAttrVOs)){
-//			throw new VciBaseException("銆�" + unExistAttrVOs.stream().map(CodeClassifyTemplateAttrVO::getName) + "銆戣繖浜涘睘鎬у湪鍒楄〃涓病鏈夋壘鍒�");
-//		}
-//		List<ClientBusinessObject> cboList = new ArrayList<>();
-//		String fullPath = getFullPath(classifyFullInfo);
-//		excelToCbo(classifyFullInfo,fieldIndexMap,rowDataList,templateVO,cboList,fullPath,true);
-//
-//		//閮借浆鎹㈠畬浜嗐�傞渶瑕佹壒閲忔鏌�
-//		//濡傛灉鍑洪敊浜嗭紝鎴戜滑渚濈劧鎵ц鏈夋晥鐨勬暟鎹紝鏃犳晥鐨勬暟鎹啓鍥炲埌excel涓�
-//		//2.鍒ゆ柇蹇呰緭椤广�傘�傞渶瑕佸叏閮ㄧ殑灞炴�э紝濡傛灉鏄繀杈擄紝浣嗘槸琛ㄥ崟閲岄潰涓嶆樉绀虹殑锛屽彧鑳芥槸鍒嗙被娉ㄥ叆鎴栬�呯粍鍚堣鍒�
-//		batchCheckRequiredAttrOnOrder(templateVO,cboList,errorMap);
-//		//3.鍒ゆ柇鍏抽敭灞炴��
-//		CodeImportResultVO keyResultVO = batchCheckKeyAttrOnOrder(classifyFullInfo, templateVO, cboList);
-//		Set<String> selfRepeatRowIndexList = keyResultVO.getSelfRepeatRowIndexList();
-//		Set<String> keyAttrRepeatRowIndexList = keyResultVO.getKeyAttrRepeatRowIndexList();
-//		if(!CollectionUtils.isEmpty(selfRepeatRowIndexList)){
-//			selfRepeatRowIndexList.stream().forEach(rowIndex->{
-//				errorMap.put(rowIndex,errorMap.getOrDefault(rowIndex,"") + ";鍦ㄥ綋鍓嶅鐞嗙殑鏁版嵁鏂囦欢涓叧閿睘鎬ч噸澶�" );
-//			});
-//		}
-//		if(!CollectionUtils.isEmpty(keyAttrRepeatRowIndexList)){
-//			keyAttrRepeatRowIndexList.stream().forEach(rowIndex->{
-//				errorMap.put(rowIndex,errorMap.getOrDefault(rowIndex,"") + ";鍏抽敭灞炴�т笌绯荤粺涓殑閲嶅" );
-//			});
-//		}
-//		//鍒嗙被娉ㄥ叆
-//		batchSwitchClassifyAttrOnOrder(attrVOS,cboList,classifyFullInfo,false);
-//		//boolean
-//		reSwitchBooleanAttrOnOrder(attrVOS,cboList);
-//		//4.鏍￠獙瑙勫垯
-//		batchCheckVerifyOnOrder(attrVOS, cboList,errorMap);
-//		if(isEnumType) {//鏄惁闇�瑕佹牎楠屾灇涓�/鍙傜収
-//			//5.鏍￠獙鏋氫妇鏄惁姝ｇ‘
-//			batchSwitchEnumAttrOnOrder(attrVOS, cboList, errorMap);
-//			//7.澶勭悊鍙傜収鐨勬儏鍐�
-//			batchSwitchReferAttrOnOrder(attrVOS,cboList,errorMap);
-//		}
-//		//6.鏃堕棿鏍煎紡鐨勯獙璇�
-//		//6.鏃堕棿鐨勶紝蹇呴』缁熶竴涓簓yyy-MM-dd HH:mm:ss
-//		batchSwitchDateAttrOnOrder(attrVOS,cboList,errorMap);
-//		//鏈�鍚庡紕缁勫悎瑙勫垯
-//		batchSwitchComponentAttrOnOrder(attrVOS,cboList);
-//		String uuid=redisService.getUUIDEveryDay();
-//		Map<String, ClientBusinessObject> rowIndexCboMap = cboList.stream().filter(cbo -> cbo != null).collect(Collectors.toList()).stream().collect(Collectors.toMap(s -> s.getAttributeValue((IMPORT_ROW_INDEX)), t -> t));
-//
-//		if(errorMap.size()>0) {
-//			createRedisDatas(uuid + "-error",templateVO, rowIndexCboMap, dataSet, fieldIndexMap, errorMap,false);
-//		}
-//		boolean isCreateUUid=false;
-//		List<ClientBusinessObject> needSaveCboList = cboList.stream().filter(cbo -> {
-//			String rowIndex = cbo.getAttributeValue(IMPORT_ROW_INDEX);
-//			return !errorMap.containsKey(rowIndex);
-//		}).collect(Collectors.toList());
-//		//鐩镐技鏍￠獙
-//		Map<String,String>resembleMap=new HashMap<>();
-//		List<DataResembleVO> dataResembleVOS=new ArrayList<>();
-//		String btmtypeid= classifyFullInfo.getTopClassifyVO().getBtmtypeid();
-//		bathcResembleQuery(orderDTO.getCodeClassifyOid(),templateVO,needSaveCboList,resembleMap,btmtypeid,dataResembleVOS);
-//		if(resembleMap.size()>0) {
-//			isCreateUUid=true;
-//			if(!CollectionUtils.isEmpty(dataResembleVOS)) {
-//				redisService.setCacheList(uuid + "-resemble-data", dataResembleVOS);
-//				createRedisDatas(uuid + "-resemble",templateVO, rowIndexCboMap, dataSet, fieldIndexMap, resembleMap, false);
-//			}
-//		}
-//		//鎺掗櫎閿欒鐨勶紝鍓╀笅姝ｇ‘鐨�
-//		Map<String,String> newErrorMap=new HashMap<>();
-//		newErrorMap.putAll(resembleMap);
-//		newErrorMap.putAll(errorMap);
-//		needSaveCboList = cboList.stream().filter(cbo -> {
-//			String rowIndex = cbo.getAttributeValue(IMPORT_ROW_INDEX);
-//			return !newErrorMap.containsKey(rowIndex);
-//		}).collect(Collectors.toList());
-//		if((errorMap.size()>0&&needSaveCboList.size()>0)||resembleMap.size()>0){
-//			isCreateUUid=true;
-//		}
-//		createRedisByCodeClassify(uuid + "-class",templateVO,dataSet,fieldIndexMap,false);
-//		if(newErrorMap.size()>0) {
-//			createRedisDatas(uuid + "-ok",templateVO, rowIndexCboMap, dataSet, fieldIndexMap, newErrorMap,true);
-//		}else {
-//			uuid="";
-//			//瑕佹妸浠ヤ笂鐨勯敊璇殑閮芥姏鍑哄悗锛屽啀缁х画澶勭悊鏃堕棿鍜岀粍鍚堣鍒�
-//			needSaveCboList = cboList.stream().filter(cbo -> {
-//				String rowIndex = cbo.getAttributeValue(IMPORT_ROW_INDEX);
-//				return !newErrorMap.containsKey(rowIndex);
-//			}).collect(Collectors.toList());
-//			if (!CollectionUtils.isEmpty(needSaveCboList)) {
-//				//9.鎴戜滑澶勭悊涓氬姟鏁版嵁
-//				//鐢熸垚缂栫爜鐨勫唴瀹�
-//				codeList = productCodeService.productCodeAndSaveData(classifyFullInfo, templateVO, ruleVO, orderDTO.getSecDTOList(), needSaveCboList);
-//				//濡傛灉鏄紪鐮佺敓鎴愬け璐ワ紝鍒欑洿鎺ュ氨澶辫触浜嗭紝鍏朵粬鐨勫垽鏂嚭鏉ユ湁閿欒鐨勬垜浠兘缁熶竴杩斿洖鍒癳xcel閲岄潰
-//				engineService.batchSaveSelectChar(templateVO, needSaveCboList);
-//			}
-//		}
-//		if(!isCreateUUid){
-//			return uuid="";
-//		}
-//		return uuid;
-		return null;
+		CodeRuleVO ruleVO = engineService.getCodeRuleByClassifyFullInfo(classifyFullInfo);
+		//1.鍒ゆ柇瑙勫垯涓櫎浜嗘祦姘寸爜娈碉紝鏄惁鏈夊叾浠栫爜娈�
+		engineService.checkSecValueOnOrder(ruleVO,orderDTO);
+		List<SheetRowData> rowDataList = dataSet.getRowData();
+
+		//闄ゅ幓榛樿鐨勫睘鎬�.杩樻湁鍙湁琛ㄥ崟鏄剧ず鐨勫瓧娈垫墠瀵煎叆
+		List<CodeClassifyTemplateAttrVO> attrVOS = templateVO.getAttributes().stream().filter(s ->
+			!DEFAULT_ATTR_LIST.contains(s.getId()) && VciBaseUtil.getBoolean(s.getFormDisplayFlag())
+		).collect(Collectors.toList());
+		Map<Integer/**鍒楀彿**/,String/**瀛楁鐨勫悕绉�**/> fieldIndexMap = new HashMap<>();
+		List<String> titleRowData = dataSet.getColName();
+		Map<String/**涓枃鍚嶇О**/, String/**鑻辨枃鍚嶇О**/> attrNameIdMap = attrVOS.stream().collect(Collectors.toMap(s -> s.getName(), t -> t.getId().toLowerCase(Locale.ROOT),(o1, o2)->o2));
+		getFieldIndexMap(titleRowData,attrNameIdMap,fieldIndexMap);
+
+		//闇�瑕佸垽鏂槸鍚︽墍鏈夌殑灞炴�ч兘鍦ㄦā鏉夸笂浜�
+		List<CodeClassifyTemplateAttrVO> unExistAttrVOs = attrVOS.stream().filter(s -> !fieldIndexMap.containsValue(s.getId().toLowerCase(Locale.ROOT))
+			&& StringUtils.isBlank(s.getComponentRule()) && StringUtils.isBlank(s.getClassifyInvokeAttr())//缁勫悎瑙勫垯鍜屽垎绫绘敞鍏ョ‘瀹炴病缁欑敤鎴峰鍑哄幓
+		).collect(Collectors.toList());
+		if(!CollectionUtils.isEmpty(unExistAttrVOs)){
+			throw new VciBaseException("銆�" + unExistAttrVOs.stream().map(CodeClassifyTemplateAttrVO::getName) + "銆戣繖浜涘睘鎬у湪鍒楄〃涓病鏈夋壘鍒�");
+		}
+		List<ClientBusinessObject> cboList = new ArrayList<>();
+		String fullPath = getFullPath(classifyFullInfo);
+		excelToCbo(classifyFullInfo,fieldIndexMap,rowDataList,templateVO,cboList,fullPath,true);
+
+		//閮借浆鎹㈠畬浜嗐�傞渶瑕佹壒閲忔鏌�
+		//濡傛灉鍑洪敊浜嗭紝鎴戜滑渚濈劧鎵ц鏈夋晥鐨勬暟鎹紝鏃犳晥鐨勬暟鎹啓鍥炲埌excel涓�
+		//2.鍒ゆ柇蹇呰緭椤广�傘�傞渶瑕佸叏閮ㄧ殑灞炴�э紝濡傛灉鏄繀杈擄紝浣嗘槸琛ㄥ崟閲岄潰涓嶆樉绀虹殑锛屽彧鑳芥槸鍒嗙被娉ㄥ叆鎴栬�呯粍鍚堣鍒�
+		batchCheckRequiredAttrOnOrder(templateVO,cboList,errorMap);
+		//3.鍒ゆ柇鍏抽敭灞炴��
+		CodeImportResultVO keyResultVO = batchCheckKeyAttrOnOrder(classifyFullInfo, templateVO, cboList);
+		Set<String> selfRepeatRowIndexList = keyResultVO.getSelfRepeatRowIndexList();
+		Set<String> keyAttrRepeatRowIndexList = keyResultVO.getKeyAttrRepeatRowIndexList();
+		if(!CollectionUtils.isEmpty(selfRepeatRowIndexList)){
+			selfRepeatRowIndexList.stream().forEach(rowIndex->{
+				errorMap.put(rowIndex,errorMap.getOrDefault(rowIndex,"") + ";鍦ㄥ綋鍓嶅鐞嗙殑鏁版嵁鏂囦欢涓叧閿睘鎬ч噸澶�" );
+			});
+		}
+		if(!CollectionUtils.isEmpty(keyAttrRepeatRowIndexList)){
+			keyAttrRepeatRowIndexList.stream().forEach(rowIndex->{
+				errorMap.put(rowIndex,errorMap.getOrDefault(rowIndex,"") + ";鍏抽敭灞炴�т笌绯荤粺涓殑閲嶅" );
+			});
+		}
+		//鍒嗙被娉ㄥ叆
+		batchSwitchClassifyAttrOnOrder(attrVOS,cboList,classifyFullInfo,false);
+		//boolean
+		reSwitchBooleanAttrOnOrder(attrVOS,cboList);
+		//4.鏍￠獙瑙勫垯
+		batchCheckVerifyOnOrder(attrVOS, cboList,errorMap);
+		if(isEnumType) {//鏄惁闇�瑕佹牎楠屾灇涓�/鍙傜収
+			//5.鏍￠獙鏋氫妇鏄惁姝ｇ‘
+			batchSwitchEnumAttrOnOrder(attrVOS, cboList, errorMap);
+			//7.澶勭悊鍙傜収鐨勬儏鍐�
+			batchSwitchReferAttrOnOrder(attrVOS,cboList,errorMap);
+		}
+		//6.鏃堕棿鏍煎紡鐨勯獙璇�
+		//6.鏃堕棿鐨勶紝蹇呴』缁熶竴涓簓yyy-MM-dd HH:mm:ss
+		batchSwitchDateAttrOnOrder(attrVOS,cboList,errorMap);
+		//鏈�鍚庡紕缁勫悎瑙勫垯
+		batchSwitchComponentAttrOnOrder(attrVOS,cboList);
+		String uuid=VciBaseUtil.getPk();
+		Map<String, ClientBusinessObject> rowIndexCboMap = cboList.stream().filter(cbo -> cbo != null).collect(Collectors.toList()).stream().collect(Collectors.toMap(s -> s.getAttributeValue((IMPORT_ROW_INDEX)), t -> t));
+
+		if(errorMap.size()>0) {
+			createRedisDatas(uuid + "-error",templateVO, rowIndexCboMap, dataSet, fieldIndexMap, errorMap,false);
+		}
+		boolean isCreateUUid=false;
+		List<ClientBusinessObject> needSaveCboList = cboList.stream().filter(cbo -> {
+			String rowIndex = cbo.getAttributeValue(IMPORT_ROW_INDEX);
+			return !errorMap.containsKey(rowIndex);
+		}).collect(Collectors.toList());
+		//鐩镐技鏍￠獙
+		Map<String,String>resembleMap=new HashMap<>();
+		List<DataResembleVO> dataResembleVOS=new ArrayList<>();
+		String btmtypeid= classifyFullInfo.getTopClassifyVO().getBtmtypeid();
+		bathcResembleQuery(orderDTO.getCodeClassifyOid(),templateVO,needSaveCboList,resembleMap,btmtypeid,dataResembleVOS);
+		if(resembleMap.size()>0) {
+			isCreateUUid=true;
+			if(!CollectionUtils.isEmpty(dataResembleVOS)) {
+				bladeRedis.set(uuid + "-resemble-data", dataResembleVOS);
+				createRedisDatas(uuid + "-resemble",templateVO, rowIndexCboMap, dataSet, fieldIndexMap, resembleMap, false);
+			}
+		}
+		//鎺掗櫎閿欒鐨勶紝鍓╀笅姝ｇ‘鐨�
+		Map<String,String> newErrorMap=new HashMap<>();
+		newErrorMap.putAll(resembleMap);
+		newErrorMap.putAll(errorMap);
+		needSaveCboList = cboList.stream().filter(cbo -> {
+			String rowIndex = cbo.getAttributeValue(IMPORT_ROW_INDEX);
+			return !newErrorMap.containsKey(rowIndex);
+		}).collect(Collectors.toList());
+		if((errorMap.size()>0&&needSaveCboList.size()>0)||resembleMap.size()>0){
+			isCreateUUid=true;
+		}
+		createRedisByCodeClassify(uuid + "-class",templateVO,dataSet,fieldIndexMap,false);
+		if(newErrorMap.size()>0) {
+			createRedisDatas(uuid + "-ok",templateVO, rowIndexCboMap, dataSet, fieldIndexMap, newErrorMap,true);
+		}else {
+			uuid="";
+
+			//瑕佹妸浠ヤ笂鐨勯敊璇殑閮芥姏鍑哄悗锛屽啀缁х画澶勭悊鏃堕棿鍜岀粍鍚堣鍒�
+			/*dataCBOList = cboList.stream().filter(cbo -> {
+				String rowIndex = cbo.getAttributeValue(IMPORT_ROW_INDEX);
+				return !newErrorMap.containsKey(rowIndex);
+			}).collect(Collectors.toList());
+*/			List<String> dataCBOIdList=new ArrayList<>();
+			List<BaseModel> dataCBOList=new ArrayList<>();
+			cboList.stream().forEach(clientBusinessObject -> {
+				BaseModel baseModel=new BaseModel();
+				BeanUtil.convert(clientBusinessObject,baseModel);
+				baseModel.setData(VciBaseUtil.objectToMapString(clientBusinessObject));
+				dataCBOList.add(baseModel);
+				dataCBOIdList.add(baseModel.getOid());
+			});
+
+			if (!CollectionUtils.isEmpty(needSaveCboList)) {
+				//9.鎴戜滑澶勭悊涓氬姟鏁版嵁
+				//鐢熸垚缂栫爜鐨勫唴瀹�
+				try {
+					codeList = productCodeService.productCodeAndSaveData(classifyFullInfo,templateVO,ruleVO, orderDTO.getSecDTOList(),dataCBOList);
+					//濡傛灉鏄紪鐮佺敓鎴愬け璐ワ紝鍒欑洿鎺ュ氨澶辫触浜嗭紝鍏朵粬鐨勫垽鏂嚭鏉ユ湁閿欒鐨勬垜浠兘缁熶竴杩斿洖鍒癳xcel閲岄潰
+					engineService.batchSaveSelectChar(templateVO, dataCBOIdList);
+				} catch (Exception e) {
+					e.printStackTrace();
+					log.error("鎵逛簡鐢宠鏃跺け璐�");
+				}
+			}
+		}
+		if(!isCreateUUid){
+			return uuid="";
+		}
+		return uuid;
 	}
 
 	@Override
@@ -629,6 +683,587 @@
 	}
 
 	/**
+	 * excel杞崲涓篶bo鐨勫璞�
+	 * @param classifyFullInfo 鍒嗙被鐨勫叏閮ㄤ俊鎭�
+	 * @param fieldIndexMap 瀛楁鐨勪綅缃�
+	 * @param rowDataList excel閲岀殑琛屾暟鎹�
+	 * @param templateVO 妯℃澘鐨勬樉绀哄璞�
+	 * @param cboList 鏁版嵁鐨勫垪琛�
+	 * @param fullPath 鍏ㄨ矾寰�
+	 * @param newCode 鏄惁涓烘壒閲忕敵璇�
+	 */
+	private void excelToCbo(CodeClassifyFullInfoBO classifyFullInfo,Map<Integer,String> fieldIndexMap,List<SheetRowData> rowDataList,
+							CodeClassifyTemplateVO templateVO,List<ClientBusinessObject> cboList,
+							String fullPath,boolean newCode){
+		rowDataList.stream().forEach(rowData -> {
+			ClientBusinessObject cbo=new ClientBusinessObject();
+			 DefaultAttrAssimtUtil.addDefaultAttrAssimt(cbo, classifyFullInfo.getTopClassifyVO().getBtmtypeid());
+			rowData.getData().forEach((index,value)->{
+				String field = fieldIndexMap.get(index);
+				if (StringUtils.isBlank(field)) {
+					throw new VciBaseException("绗�" + (index + 1) + "鍒楃殑鏍囬鍦ㄧ郴缁熶腑涓嶅瓨鍦�");
+				}
+				try {
+					cbo.setAttributeValueWithNoCheck(field, value);
+					if (WebUtil.isDefaultField(field)) {
+						WebUtil.setValueToField(field, cbo, value);
+					}
+				} catch (VciBaseException e) {
+					log.error("璁剧疆灞炴�х殑鍊奸敊璇�", e);
+				}
+			});
+			try {
+				cbo.setAttributeValue(CODE_TEMPLATE_OID_FIELD,templateVO.getOid());
+				cbo.setAttributeValue(IMPORT_ROW_INDEX,rowData.getRowIndex());
+				if(newCode){
+					cbo.setAttributeValue(CODE_CLASSIFY_OID_FIELD,classifyFullInfo.getCurrentClassifyVO().getOid());
+					cbo.setAttributeValue(CODE_FULL_PATH_FILED,fullPath);
+					//cbo.setLcStatus(CodeDefaultLC.EDITING.getValue());
+					int secret = VciBaseUtil.getInt(cbo.getAttributeValue(SECRET_FIELD));
+					/*if(secret == 0 || !secretService.checkDataSecret(secret) ){
+						Integer userSecret = VciBaseUtil.getCurrentUserSecret();
+						cbo.setAttributeValue(SECRET_FIELD,String.valueOf((userSecret==null || userSecret ==0)? UserSecretEnum.NONE.getValue():userSecret));
+					}*/
+				}else{
+					//姝ゆ椂杩樻病鏈夎浆鎹㈣矾寰�
+					//cbo.setAttributeValue(CODE_FULL_PATH_FILED, childOidPathMap.getOrDefault(rowData.getData().getOrDefault(CODE_CLASSIFY_OID_FIELD,""),fullPath));
+					cbo.setLcStatus(CodeDefaultLC.RELEASED.getValue());
+				}
+
+			}catch (Throwable e){
+				log.error("璁剧疆榛樿鐨勫睘鎬х殑鍊奸敊璇�",e);
+			}
+			cboList.add(cbo);
+		});
+
+	}
+
+	/**
+	 * 妫�鏌ユ牎楠岃鍒欐病鏈夐�氳繃鐨勫唴瀹�
+	 * @param attrVOS 闇�瑕佹牎楠岀殑灞炴��
+	 * @param dataList 鏁版嵁鐨勫垪琛�
+	 * @param errorMap 閿欒鐨勪俊鎭槧灏�
+	 * @return 鏍￠獙涓嶉�氳繃鐨勮鏁�
+	 */
+	private void batchCheckVerifyOnOrder(Collection<CodeClassifyTemplateAttrVO> attrVOS, List<ClientBusinessObject> dataList,Map<String,String> errorMap) {
+		Map<String, CodeClassifyTemplateAttrVO> verifyAttrVOMap = attrVOS.stream().filter(s -> StringUtils.isNotBlank(s.getVerifyRule()) && StringUtils.isBlank(s.getComponentRule())
+			&&StringUtils.isBlank(s.getClassifyInvokeAttr())
+		).collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t));
+		if(!CollectionUtils.isEmpty(verifyAttrVOMap)){
+			Map<String/**琛屽彿**/,List<String>/**鏍￠獙涓嶉�氳繃鐨勫睘鎬�**/> unPassCheckMap = new HashMap<>();
+			verifyAttrVOMap.forEach((attrId,attrVO)->{
+				dataList.stream().forEach(cbo -> {
+					String value = cbo.getAttributeValue(attrId);
+					if(StringUtils.isNotBlank(value) && !value.matches(attrVO.getVerifyRule())){
+						String rowIndex = cbo.getAttributeValue(IMPORT_ROW_INDEX);
+						List<String> unPassAttrs = unPassCheckMap.getOrDefault(rowIndex, new ArrayList<>());
+						unPassAttrs.add(attrVO.getName());
+						unPassCheckMap.put(rowIndex,unPassAttrs);
+					}
+				});
+			});
+			if(!CollectionUtils.isEmpty(unPassCheckMap)){
+				unPassCheckMap.forEach((rowIndex,unPassAttrs)->{
+					errorMap.put(rowIndex,";灞炴�" + unPassAttrs.stream().collect(Collectors.joining(",")) + "]鍐呭涓嶇鍚堟牎楠岃鍒欑殑瑕佹眰");
+				});
+			}
+		}
+	}
+	/**
+	 * 鎵归噺杞崲鏃堕棿閮戒负鎸囧畾鐨勬牸寮�
+	 * @param attrVOS 妯℃澘灞炴��
+	 * @param cboList 鏁版嵁鐨勫垪琛�
+	 * @param errorMap 閿欒鐨勪俊鎭�
+	 */
+	private void batchSwitchDateAttrOnOrder(Collection<CodeClassifyTemplateAttrVO> attrVOS,List<ClientBusinessObject> cboList,Map<String,String> errorMap){
+		Map<String, CodeClassifyTemplateAttrVO> dateAttrVOMap =attrVOS.stream().filter(s ->
+			StringUtils.isNotBlank(s.getCodeDateFormat()) && VciBaseUtil.getBoolean(s.getCodeDateFormat()) && StringUtils.isBlank(s.getComponentRule())
+				&& StringUtils.isBlank(s.getClassifyInvokeAttr())
+		).collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t));
+		if(!CollectionUtils.isEmpty(dateAttrVOMap)) {
+			dateAttrVOMap.forEach((attrId, attrVO) -> {
+				cboList.stream().forEach(cbo -> {
+					String value = cbo.getAttributeValue(attrId);
+					if (value == null) {
+						value = "";
+					}
+					if (StringUtils.isNotBlank(value)) {
+						boolean formated = false;
+						if(StringUtils.isNotBlank(attrVO.getCodeDateFormat())){
+							try {
+								Date date = VciDateUtil.str2Date(value, attrVO.getCodeDateFormat());
+								if(date!=null){
+									cbo.setAttributeValue(attrId,value);
+									formated = true;
+								}
+							} catch (Exception e) {
+								//璇存槑涓嶆槸杩欎釜鏍煎紡
+							}
+						}
+						if(!formated) {
+							try {
+								DateConverter dateConverter = new DateConverter();
+								dateConverter.setAsText(value);
+								value = VciDateUtil.date2Str(dateConverter.getValue(), VciDateUtil.DateTimeMillFormat);
+								cbo.setAttributeValue(attrId,value);
+							}catch (Throwable e){
+								//杞崲涓嶄簡
+								String rowIndex = cbo.getAttributeValue(IMPORT_ROW_INDEX);
+								errorMap.put(rowIndex,errorMap.getOrDefault(rowIndex,"") + ";灞炴�" + attrVO.getName() + "]鏃堕棿鏍煎紡涓嶆纭�" );
+							}
+						}
+					}
+				});
+			});
+		}
+	}
+	/**
+	 * 杞Щboolean鍨嬬殑灞炴��
+	 * @param attrVOS 灞炴�х殑瀵硅薄
+	 * @param dataList 鏁版嵁
+	 */
+	private void reSwitchBooleanAttrOnOrder(Collection<CodeClassifyTemplateAttrVO> attrVOS,List<ClientBusinessObject> dataList){
+		Map<String, CodeClassifyTemplateAttrVO> booleanAttrMap = attrVOS.stream().filter(
+			s -> VciFieldTypeEnum.VTBoolean.name().equalsIgnoreCase(s.getAttributeDataType())
+		).collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t));
+		if (!CollectionUtils.isEmpty(booleanAttrMap)) {
+			booleanAttrMap.forEach((attrId, attrVO) -> {
+				dataList.stream().forEach(cbo -> {
+					String text = cbo.getAttributeValue(attrId);
+					try {
+						if (BooleanEnum.TRUE.getValue().equalsIgnoreCase(text) || "鏄�".equalsIgnoreCase(text)) {
+							cbo.setAttributeValue(attrId, BooleanEnum.TRUE.getValue());
+						} else {
+							cbo.setAttributeValue(attrId, BooleanEnum.FASLE.getValue());
+						}
+					}catch (Throwable e){
+
+					}
+				});
+			});
+		}
+	}
+
+	/**
+	 * 澶勭悊缁勫悎瑙勫垯
+	 * @param attrVOS 妯℃澘灞炴��
+	 * @param dataList excel鐨勬暟鎹唴瀹�
+	 */
+	private void batchSwitchComponentAttrOnOrder(Collection<CodeClassifyTemplateAttrVO> attrVOS,List<ClientBusinessObject> dataList) {
+		Map<String, CodeClassifyTemplateAttrVO> dateAttrVOMap = attrVOS.stream().filter(s -> StringUtils.isNotBlank(s.getComponentRule())).collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t));
+		if(!CollectionUtils.isEmpty(dateAttrVOMap)) {
+			dateAttrVOMap.forEach((attrId, attrVO) -> {
+				dataList.stream().forEach(cbo -> {
+					//浠巈xcel涓婃妸灞炴�ц浆鎹负map
+					Map<String,String> thisRowDataMap = new HashMap<>();
+					copyValueToMapFromCbos(cbo,thisRowDataMap);
+					//缁勫悎鍐呭
+					String value = formulaService.getValueByFormula(thisRowDataMap,attrVO.getComponentRule());
+					if(value == null){
+						value = "";
+					}
+					try {
+						cbo.setAttributeValue(attrId, value);
+					}catch (Throwable e){
+						log.error("璁剧疆灞炴�х殑閿欒",e);
+					}
+				});
+			});
+		}
+	}
+
+	/**
+	 * 杞崲鍙傜収鐨勫��
+	 * @param attrVOS 灞炴�х殑鏄剧ず瀵硅薄
+	 * @param dataList 鏁版嵁鍒楄〃
+	 * @param errorMap 閿欒鐨勪俊鎭�
+	 */
+	private void batchSwitchReferAttrOnOrder(Collection<CodeClassifyTemplateAttrVO> attrVOS,List<ClientBusinessObject> dataList,Map<String,String> errorMap){
+		Map<String, CodeClassifyTemplateAttrVO> referAttrVOMap = attrVOS.stream().filter(
+			s -> (StringUtils.isNotBlank(s.getReferBtmId()) || StringUtils.isNotBlank(s.getReferConfig()))
+		).collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t));
+		if(!CollectionUtils.isEmpty(referAttrVOMap)){
+			Map<String/**琛ㄦ牸鍜屽�肩殑灞炴��**/,Map<String/**鏄剧ず灞炴�х殑鍊�**/,List<String>/**琛ㄦ牸閲岀殑鍊�**/>> linkValueMap = new HashMap<>();
+			referAttrVOMap.forEach((attrId,attrVO)->{
+				dataList.stream().forEach(cbo -> {
+					String text = cbo.getAttributeValue(attrId);
+					if(StringUtils.isNotBlank(text)){
+						UIFormReferVO referVO = getReferVO(attrVO);
+						String valueField = getValueField(referVO);
+						String showText = getTextField(referVO);
+						String tableAndAttr = VciBaseUtil.getTableName(referVO.getReferType()) + "#" + valueField;
+						Map<String, List<String>> showTextMap = linkValueMap.getOrDefault(tableAndAttr, new HashMap<>());
+						List<String> textList = showTextMap.getOrDefault(showText, new ArrayList<>());
+						if(!textList.contains(text)) {
+							textList.add(text);
+						}
+						showTextMap.put(showText,textList);
+						linkValueMap.put(tableAndAttr,showTextMap);
+					}
+				});
+			});
+			if(!CollectionUtils.isEmpty(linkValueMap)){
+				//闇�瑕侀�愪釜琛ㄧ殑鍊煎瓧娈碉紝閫愪釜鏌ヨ
+				Map<String/**琛ㄦ牸鍜屽�煎睘鎬�**/,Map<String/**鏄剧ず灞炴��**/, Map<String/**鍊�**/,String/**鏄剧ず鐨勫��**/>>> linkCboMap = new HashMap<>();
+				linkValueMap.forEach((tableAndAttr,showValueMap)->{
+					String[] split = tableAndAttr.split("#");
+					String table = split[0];
+					String valueField = split[1].toLowerCase(Locale.ROOT);
+					Map<String,Map<String,String>> dataMap = new HashMap<>();
+					showValueMap.forEach((showText,valueList)->{
+						Map<String,String> valueOidTextMap = new HashMap<>();
+						List<List<String>> valueCollections = VciBaseUtil.switchListForOracleIn(valueList);
+						String sql = "select " + valueField + "," + showText.toLowerCase(Locale.ROOT) +" from " + table + "  where " + showText + " in (%s)";
+						valueCollections.stream().forEach(values->{
+							List<Map<String,String>> dataMapList = commonsMapper.queryByOnlySqlForMap(String.format(sql, VciBaseUtil.toInSql(values.toArray(new String[0]))));
+							List<ClientBusinessObject> cbos=	ChangeMapTOClientBusinessObjects(dataMapList);
+							if(!CollectionUtils.isEmpty(cbos)){
+								valueOidTextMap.putAll(cbos.stream().collect(Collectors.toMap(s->s.getAttributeValue(valueField),t->t.getAttributeValue(showText))));
+							}
+						});
+						dataMap.put(showText,valueOidTextMap);
+					});
+					linkCboMap.put(tableAndAttr,dataMap);
+				});
+				referAttrVOMap.forEach((attrId,attrVO)->{
+					dataList.stream().forEach(cbo -> {
+						String text = cbo.getAttributeValue(attrId);
+						if (StringUtils.isNotBlank(text)) {
+							UIFormReferVO referVO = getReferVO(attrVO);
+							String valueField = getValueField(referVO);
+							String showText = getTextField(referVO);
+							String tableAndAttr = VciBaseUtil.getTableName(referVO.getReferType()) + "#" + valueField;
+							if(!linkCboMap.containsKey(tableAndAttr)){
+								String rowIndex = cbo.getAttributeValue(IMPORT_ROW_INDEX);
+								errorMap.put(rowIndex,errorMap.getOrDefault(rowIndex,"") + ";鍙傛暟灞炴�" + attrVO.getName() + "]鐨勫�煎湪绯荤粺涓笉瀛樺湪" );
+
+							}else{
+								Map<String, Map<String, String>> dataMap = linkCboMap.get(tableAndAttr);
+								if(!dataMap.containsKey(showText)){
+									String rowIndex = cbo.getAttributeValue(IMPORT_ROW_INDEX);
+									errorMap.put(rowIndex,errorMap.getOrDefault(rowIndex,"") + ";鍙傛暟灞炴�" + attrVO.getName() + "]鐨勫�煎湪绯荤粺涓笉瀛樺湪" );
+								}else{
+									Map<String, String> data = dataMap.get(showText);
+									final boolean[] fined = {false};
+									data.forEach((key,value)->{
+										if(value.equalsIgnoreCase(text)){
+											fined[0] = true;
+											try {
+												cbo.setAttributeValue(attrId, key);
+											}catch (Throwable e){
+
+											}
+										}
+									});
+									if(!fined[0]){
+										String rowIndex = cbo.getAttributeValue(IMPORT_ROW_INDEX);
+										errorMap.put(rowIndex,errorMap.getOrDefault(rowIndex,"") + ";鍙傛暟灞炴�" + attrVO.getName() + "]鐨勫�煎湪绯荤粺涓笉瀛樺湪" );
+									}
+								}
+							}
+						}
+					});
+				});
+			}
+		}
+
+	}
+
+	/**
+	 * 浠庡睘鎬т笂鑾峰彇鍙傜収鐨勫唴瀹�
+	 * @param attrVO 灞炴�х殑淇℃伅
+	 * @return 鍙傜収鐨勫唴瀹�
+	 */
+	private UIFormReferVO getReferVO(CodeClassifyTemplateAttrVO attrVO){
+		UIFormReferVO referVO = null;
+		if(StringUtils.isNotBlank(attrVO.getReferConfig())){
+			referVO = JSONObject.parseObject(attrVO.getReferConfig(),UIFormReferVO.class);
+		}else{
+			referVO = new UIFormReferVO();
+			referVO.setReferType(attrVO.getReferBtmId());
+			referVO.setValueField(VciQueryWrapperForDO.OID_FIELD);
+			referVO.setTextField("name");
+		}
+		return referVO;
+	}
+
+	/**
+	 * 鑾峰彇鍙傜収涓殑鍊肩殑瀛楁
+	 * @param referVO 鍙傜収鐨勫璞�
+	 * @return 榛樿涓篛id锛屾湁澶氫釜鐨勬椂鍊欙紝鑾峰彇绗竴涓�
+	 */
+	private String getValueField(UIFormReferVO referVO){
+		String showText = referVO.getValueField();
+		if(StringUtils.isBlank(showText)){
+			return "oid";
+		}
+		if(showText.contains(",")){
+			//闃叉涓囦竴鏈夊涓紝鐪嬬湅鏈夋病鏈塷id
+			List<String> strings = VciBaseUtil.str2List(showText);
+			if(strings.contains("oid")){
+				showText = "oid";
+			}else{
+				showText = strings.get(0);
+			}
+		}
+		return showText;
+	}
+
+	/**
+	 * 鑾峰彇鍙傜収涓殑鏄剧ず鍐呭鐨勫瓧娈�
+	 * @param referVO 鍙傜収鐨勫璞�
+	 * @return 榛樿涓簄ame锛屾湁澶氫釜鐨勬椂鍊欙紝鑾峰彇绗竴涓�
+	 */
+	private String getTextField(UIFormReferVO referVO){
+		String showText = referVO.getTextField();
+		if(StringUtils.isBlank(showText)){
+			return "name";
+		}
+		if(showText.contains(",")){
+			//闃叉涓囦竴鏈夊涓紝鐪嬬湅鏈夋病鏈塶ame
+			List<String> strings = VciBaseUtil.str2List(showText);
+			if(strings.contains("name")){
+				showText = "name";
+			}else{
+				showText = strings.get(0);
+			}
+		}
+		return showText;
+	}
+	/**
+	 * 澶勭悊鏋氫妇鐨勬樉绀哄璞�
+	 * @param attrVOS 妯℃澘灞炴��
+	 * @param dataList excel鐨勬暟鎹唴瀹�
+	 * @param errorMap 閿欒淇℃伅鐨勬槧灏�
+	 */
+	private void batchSwitchEnumAttrOnOrder(Collection<CodeClassifyTemplateAttrVO> attrVOS,List<ClientBusinessObject> dataList,
+											Map<String,String> errorMap ) {
+		Map<String, CodeClassifyTemplateAttrVO> dateAttrVOMap = attrVOS.stream().filter(
+			s -> (StringUtils.isNotBlank(s.getEnumString()) || StringUtils.isNotBlank(s.getEnumId()))
+		).collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t));
+		if (!CollectionUtils.isEmpty(dateAttrVOMap)) {
+			dateAttrVOMap.forEach((attrId, attrVO) -> {
+				dataList.stream().forEach(cbo -> {
+					String text = cbo.getAttributeValue(attrId);
+					if(StringUtils.isNotBlank(text)){
+						List<KeyValue> valueList = engineService.listComboboxItems(attrVO);
+						boolean fined = false;
+						for (int i = 0; i < valueList.size(); i++) {
+							KeyValue keyValue = valueList.get(i);
+							//if(keyValue.getValue().equalsIgnoreCase(text)){
+							if(keyValue.getValue().equalsIgnoreCase(text)||keyValue.getKey().equalsIgnoreCase(text)){
+								try {
+									cbo.setAttributeValue(attrId, keyValue.getKey());
+								}catch (Throwable e){
+									log.error("璁剧疆灞炴�у嚭閿�");
+								}
+								fined = true;
+								break;
+							}
+						}
+						if(!fined){
+							String rowIndex = cbo.getAttributeValue(IMPORT_ROW_INDEX);
+							errorMap.put(rowIndex,errorMap.getOrDefault(rowIndex,"") + ";灞炴�" + attrVO.getName() + "]鐨勫�间笉绗﹀悎涓嬫媺鐨勮姹�");
+						}
+					}
+				});
+			});
+		}
+	}
+
+	/**
+	 * 鎵归噺鏍￠獙鏁版嵁鐨勪俊鎭�
+	 * @param templateVO 妯℃澘鐨勬樉绀哄璞�
+	 * @param cboList 鏁版嵁鐨勫唴瀹�
+	 */
+	private void batchCheckRequiredAttrOnOrder(CodeClassifyTemplateVO templateVO,List<ClientBusinessObject> cboList,Map<String,String> errorMap){
+		Map<String, CodeClassifyTemplateAttrVO> requiredAttrMap = templateVO.getAttributes().stream().filter(s ->
+			VciBaseUtil.getBoolean(s.getRequireFlag()) && StringUtils.isBlank(s.getComponentRule()) && StringUtils.isBlank(s.getClassifyInvokeLevel())//涓嶈兘鏄粍鍚堢殑鍜屽垎绫绘敞鍏ョ殑
+		).collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t));
+		//涓嶮dmEngineServiceImpl閲岄潰鐨刢heckRequiredAttrOnOrder 閫昏緫搴旇鐩镐技
+		if(!CollectionUtils.isEmpty(requiredAttrMap)) {
+			Set<String> nullRowIndex = cboList.stream().filter(cbo -> requiredAttrMap.keySet().stream().anyMatch(attrId -> StringUtils.isBlank(cbo.getAttributeValue(attrId)))).map(cbo -> cbo.getAttributeValue(IMPORT_ROW_INDEX)).collect(Collectors.toSet());
+			if(!CollectionUtils.isEmpty(nullRowIndex)){
+				String checkAttr = requiredAttrMap.values().stream().map(CodeClassifyTemplateAttrVO::getName).collect(Collectors.joining(","));
+				nullRowIndex.stream().forEach(rowIndex->{
+					errorMap.put(rowIndex,errorMap.getOrDefault(rowIndex,"") + ";鏍￠獙瑙勫垯涓嶉�氳繃锛屾湁鏍￠獙鐨勫睘鎬т负" + checkAttr);
+				});
+			}
+		}
+	}
+	/**
+	 * 澶勭悊鍒嗙被娉ㄥ叆
+	 * @param attrVOS 妯℃澘灞炴��
+	 * @param dataList excel鐨勬暟鎹唴瀹�
+	 * @param classifyFullInfo 鍒嗙被鐨勫叏璺緞
+	 */
+	private void batchSwitchClassifyAttrOnOrder(Collection<CodeClassifyTemplateAttrVO> attrVOS,List<ClientBusinessObject> dataList,
+												CodeClassifyFullInfoBO classifyFullInfo,boolean isImPort) {
+		Map<String, CodeClassifyTemplateAttrVO> dateAttrVOMap = attrVOS.stream().filter(
+			s -> StringUtils.isNotBlank(s.getClassifyInvokeAttr()) && StringUtils.isNotBlank(s.getClassifyInvokeAttr())
+		).collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t));
+		Map<String,CodeClassifyFullInfoBO> classifyFullInfoMap=new HashMap<>();
+		classifyFullInfoMap.put(classifyFullInfo.getCurrentClassifyVO().getOid(),classifyFullInfo);
+		if (!CollectionUtils.isEmpty(dateAttrVOMap)) {
+			dataList.stream().forEach(cbo -> {
+				dateAttrVOMap.forEach((attrId, attrVO) -> {
+					//鍒嗙被娉ㄥ叆鐨勭紪鍙锋垨鑰呭悕绉帮紝
+					//灞傜骇鍖呭惈鎸囧畾灞傚拰鏈�灏忓眰
+					CodeClassifyVO classifyVO = null;
+					if(!CodeLevelTypeEnum.MIN.getValue().equalsIgnoreCase(attrVO.getClassifyInvokeLevel()) && !"min".equalsIgnoreCase(attrVO.getClassifyInvokeLevel())) {
+						//鎸囧畾浜嗗眰绾х殑
+						//娉ㄦ剰锛屽洜涓烘煡璇笂绾у垎绫诲嚭鏉ョ殑灞傜骇鏄�掑簭鐨勶紝鍗抽《灞傝妭鐐规槸鏈�澶х殑鍊�
+						if(isImPort){
+							if(!classifyFullInfoMap.containsKey(cbo.getAttributeValue(CODE_CLASSIFY_OID_FIELD))) {
+								CodeClassifyFullInfoBO currentClassifyFullInfo = classifyService.getClassifyFullInfo(cbo.getAttributeValue(CODE_CLASSIFY_OID_FIELD));
+								classifyFullInfoMap.put(currentClassifyFullInfo.getCurrentClassifyVO().getOid(), currentClassifyFullInfo);
+							}
+						}
+						CodeClassifyFullInfoBO newClassifyFullInfo= classifyFullInfoMap.get(cbo.getAttributeValue(CODE_CLASSIFY_OID_FIELD));
+						List<CodeClassifyVO> classifyVOS = newClassifyFullInfo.getParentClassifyVOs().stream().sorted(((o1, o2) -> o2.getDataLevel().compareTo(o1.getDataLevel()))).collect(Collectors.toList());
+						int level = VciBaseUtil.getInt(attrVO.getClassifyInvokeLevel());
+						if (classifyVOS.size()>=level && level > 0 ) {
+							classifyVO = classifyVOS.get(level-1);
+						}
+					}else{
+						//褰撳墠鐨勫垎绫�
+						classifyVO = classifyFullInfo.getCurrentClassifyVO();
+					}
+					try {
+						if (classifyVO == null) {
+							//璇存槑灞傜骇鏈夎
+							cbo.setAttributeValue(attrId, "鍒嗙被鏍戜笂娌℃湁灞傜骇[" + attrVO.getClassifyInvokeLevel() + "]");
+						} else {
+							Map<String, String> classifyDataMap = VciBaseUtil.objectToMapString(classifyVO);
+							String value = classifyDataMap.getOrDefault(attrVO.getClassifyInvokeAttr(), "");
+							cbo.setAttributeValue(attrId, value);
+						}
+					} catch (Throwable e) {
+						log.error("璁剧疆灞炴�ч敊璇�", e);
+					}
+				});
+			});
+		}
+	}
+	/**
+	 * 鏍￠獙鍏抽敭灞炴��
+	 * @param classifyFullInfo 鍒嗙被鐨勫叏閮ㄤ俊鎭�
+	 * @param templateVO 妯℃澘鐨勫唴瀹癸紝蹇呴』鍖呭惈妯℃澘灞炴��
+	 * @param cboList 鎵归噺鐨勬暟鎹�
+	 */
+	private CodeImportResultVO batchCheckKeyAttrOnOrder(CodeClassifyFullInfoBO classifyFullInfo, CodeClassifyTemplateVO templateVO,
+														List<ClientBusinessObject> cboList) {
+		//涓嶮dmEngineServiceImpl閲岀殑checkKeyAttrOnOrder鐩镐技
+		//鍏堣幏鍙栧叧閿睘鎬х殑瑙勫垯锛屼篃鍒╃敤缁ф壙鐨勬柟寮�
+		CodeKeyAttrRepeatVO keyRuleVO = keyRuleService.getRuleByClassifyFullInfo(classifyFullInfo);
+		//娉ㄦ剰鐨勬槸keyRuleVO鍙兘涓虹┖锛岃〃绀轰笉浣跨敤瑙勫垯鎺у埗
+		//鑾峰彇鎵�鏈夌殑鍏抽敭灞炴��
+		Map<String/**灞炴�х殑缂栧彿**/, CodeClassifyTemplateAttrVO> ketAttrMap = templateVO.getAttributes().stream().filter(s -> VciBaseUtil.getBoolean(s.getKeyAttrFlag())).collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t));
+
+		boolean trimAll =keyRuleVO ==null?false: VciBaseUtil.getBoolean(keyRuleVO.getIgnoreallspaceflag());
+		//鍏ㄩ儴鍘荤┖鐨勪紭鍏堢骇澶т簬鍘荤┖
+		boolean trim =keyRuleVO ==null?false:  VciBaseUtil.getBoolean(keyRuleVO.getIgnorespaceflag());
+		boolean ignoreCase = keyRuleVO ==null?false: VciBaseUtil.getBoolean(keyRuleVO.getIgnorecaseflag());
+		boolean ignoreWidth = keyRuleVO ==null?false: VciBaseUtil.getBoolean(keyRuleVO.getIgnorewidthflag());
+
+		//1. 鎴戜滑闇�瑕佸厛鍒ゆ柇excel瀵煎叆鐨勫唴瀹规槸鍚︽纭�
+		CodeImportResultVO resultVO = new CodeImportResultVO();
+		resultVO.setKeyAttrRuleInfo(String.format(keyRuleVO ==null?"":"鏌ヨ瑙勫垯锛氬幓闄ょ┖鏍�--{0},蹇界暐澶у皬鍐�--{1},蹇界暐鍏ㄥ崐瑙�--{2},蹇界暐鍏ㄩ儴绌烘牸--{3}",
+			new String[]{trim?"鏄�":"鍚�",ignoreCase?"鏄�":"鍚�",ignoreWidth?"鏄�":"鍚�",trimAll?"鏄�":"鍚�"}));
+		resultVO.setSelfRepeatRowIndexList(getSelfRepeatRowIndex(ketAttrMap,cboList,keyRuleVO));
+		if(!CollectionUtils.isEmpty(resultVO.getSelfRepeatRowIndexList())){
+			//鎴戜滑绉婚櫎鏈韩閲嶅鐨勬暟鎹�
+			cboList = cboList.stream().filter(s->!resultVO.getSelfRepeatRowIndexList().contains(s.getAttributeValue(IMPORT_ROW_INDEX))).collect(Collectors.toList());
+		}
+		//2.鍒ゆ柇鍏抽敭灞炴�у湪绯荤粺閲屾槸鍚﹂噸澶�
+		//鍥犱负鏁版嵁閲忓緢澶э紝鎵�浠ュ緱鎯冲姙娉曞苟琛�
+		//SessionInfo sessionInfo = VciBaseUtil.getCurrentUserSessionInfo();
+		Map<String,List<ClientBusinessObject>> indexTODataMap=new HashMap<>();
+		List<ClientBusinessObject> repeatDataMap = cboList.parallelStream().filter(cbo -> {
+			//姣忚閮藉緱鏌ヨ.濡傛灉鍏朵腑鍑虹幇浜嗛敊璇紝鎴戜滑灏辩洿鎺ユ姏鍑哄紓甯革紝鍏朵綑鐨勬樉绀�
+			//VciBaseUtil.setCurrentUserSessionInfo(sessionInfo);
+			Map<String, String> conditionMap = new HashMap<>();
+			ketAttrMap.forEach((attrId, attrVO) -> {
+				String value =cbo.getAttributeValue(attrId.toLowerCase(Locale.ROOT));
+				if (value == null) {
+					value = "";
+				}
+				value= value.replace(REQUIRED_CHAR,SPECIAL_CHAR);
+				engineService.wrapperKeyAttrConditionMap(value, keyRuleVO, attrId, trim, ignoreCase, ignoreWidth, trimAll, conditionMap);
+			});
+			if (!CollectionUtils.isEmpty(ketAttrMap)) {
+				CodeTemplateAttrSqlBO sqlBO = engineService.getSqlByTemplateVO(classifyFullInfo.getTopClassifyVO().getBtmtypeid(), templateVO, conditionMap, null);
+				boolean isKeyCheck= commonsMapper.queryCountBySql(sqlBO.getSqlCount()) > 0;
+				if(isKeyCheck){
+					List<Map<String,String>> newDataList=  commonsMapper.queryByOnlySqlForMap(sqlBO.getSqlUnPage());
+					List<ClientBusinessObject> newCboList=	ChangeMapTOClientBusinessObjects(newDataList);
+					indexTODataMap.put(cbo.getAttributeValue(IMPORT_ROW_INDEX),newCboList);
+				}
+				return isKeyCheck;
+			}else{
+				return false;
+			}
+		}).collect(Collectors.toList());
+		if(!CollectionUtils.isEmpty(repeatDataMap)){
+			resultVO.setKeyAttrRepeatRowIndexList(repeatDataMap.stream().map(s->s.getAttributeValue(IMPORT_ROW_INDEX)).collect(Collectors.toSet()));
+		}
+		//resultVO.setIndexTODataMap(indexTODataMap);
+		//resultVO.setSuccess(true);
+		return resultVO;
+	}
+	/**
+	 * 鑾峰彇瀵煎叆鐨勫唴瀹逛腑鍏抽敭灞炴�ч噸澶嶇殑琛屽彿
+	 * @param ketAttrMap 鍏抽敭灞炴�х殑鏄犲皠
+	 * @param dataList 瀵煎叆鐨勬暟鎹�
+	 * @param keyRuleVO 鍏抽敭灞炴�ф帶鍒惰鍒�
+	 * @return 閲嶅鐨勮鍙�
+	 */
+	private Set<String> getSelfRepeatRowIndex(Map<String/**灞炴�х殑缂栧彿**/, CodeClassifyTemplateAttrVO> ketAttrMap,
+											  List<ClientBusinessObject> dataList,CodeKeyAttrRepeatVO keyRuleVO){
+		Set<String> selfRepeatRowIndexList = new CopyOnWriteArraySet<>();
+		boolean trimAll =keyRuleVO ==null?false: VciBaseUtil.getBoolean(keyRuleVO.getIgnoreallspaceflag());
+		//鍏ㄩ儴鍘荤┖鐨勪紭鍏堢骇澶т簬鍘荤┖
+		boolean trim =keyRuleVO ==null?false:  VciBaseUtil.getBoolean(keyRuleVO.getIgnorespaceflag());
+		boolean ignoreCase = keyRuleVO ==null?false: VciBaseUtil.getBoolean(keyRuleVO.getIgnorecaseflag());
+		boolean ignoreWidth = keyRuleVO ==null?false: VciBaseUtil.getBoolean(keyRuleVO.getIgnorewidthflag());
+		//蹇呴』灏嗗睘鎬ф寜鐓ч『搴忔帓搴忓ソ
+		List<CodeClassifyTemplateAttrVO> attrVOList = ketAttrMap.values().stream().sorted(((o1, o2) -> o1.getOrderNum().compareTo(o2.getOrderNum()))).collect(Collectors.toList());
+		Map<String/**琛屽彿**/,String/**鍏抽敭灞炴�х殑缁勫悎鍐呭**/> rowIndexKeyStringMap = new HashMap<>();
+		dataList.parallelStream().forEach(cbo-> {
+			String rowIndex = cbo.getAttributeValue(IMPORT_ROW_INDEX);
+			StringBuilder sb = new StringBuilder();
+			for (int i = 0; i < attrVOList.size(); i++) {
+				CodeClassifyTemplateAttrVO attrVO = attrVOList.get(i);
+				String attrId = attrVO.getId().toLowerCase(Locale.ROOT);
+				String value = cbo.getAttributeValue( attrId);
+				if (value == null) {
+					value = "";
+				}
+				if(trim){
+					value = value.trim();
+				}
+				if(trimAll){
+					value = value.replace(" ","");
+				}
+				if(ignoreCase){
+					value = value.toLowerCase(Locale.ROOT);
+				}
+				if(ignoreWidth){
+					value = VciBaseUtil.toDBC(value);
+				}
+				sb.append(value).append("${ks}");
+			}
+			String keyString = sb.toString();
+			if(rowIndexKeyStringMap.containsValue(keyString) && StringUtils.isNotBlank(keyString)){
+				selfRepeatRowIndexList.add(rowIndex);
+			}else {
+				rowIndexKeyStringMap.put(rowIndex, sb.toString());
+			}
+		});
+		//鍥犱负鍙槸鍏抽敭灞炴�ч噸澶嶏紝鎵�浠ユ垜浠笉鑳介噸澶嶇殑澶氭潯閫変竴鏉℃潵鎶ラ敊
+		return selfRepeatRowIndexList;
+	}
+	/**
 	 * excel鐨勬爣棰樹笂鑾峰彇瀛楁鎵�鍦ㄧ殑浣嶇疆
 	 * @param titleRowData 鏍囬鐨勫唴瀹�
 	 * @param attrNameIdMap 妯℃澘涓睘鎬у悕绉板拰鑻辨枃鐨勬槧灏�
@@ -653,6 +1288,272 @@
 			}
 		}
 	}
+	private List<ClientBusinessObject> ChangeMapTOClientBusinessObjects(List<Map<String,String>> oldDataMap){
+		List<ClientBusinessObject> clientBusinessObjectList=new CopyOnWriteArrayList<>();
+		oldDataMap.parallelStream().forEach(dataMap->{
+			ClientBusinessObject clientBusinessObject=new ClientBusinessObject();
+			DefaultAttrAssimtUtil.copplyDefaultAttrAssimt(dataMap,clientBusinessObject);
+			dataMap.forEach((key,value)->{
+				clientBusinessObject.setAttributeValue(key,value);
+			});
+		});
+		return clientBusinessObjectList;
+	}
 
+	/***
+	 * 姝ｇ‘閿欒鏁版嵁redis缂撳瓨
+	 * @param uuid
+	 * @param templateVO
+	 * @param rowIndexCbo
+	 * @param dataSet
+	 * @param fieldIndexMap
+	 * @param errorMap
+	 * @param isok
+	 */
+	private void createRedisDatas(String uuid,CodeClassifyTemplateVO templateVO,Map<String,ClientBusinessObject> rowIndexCbo, SheetDataSet dataSet, Map<Integer/**鍒楀彿**/,String/**瀛楁鐨勫悕绉�**/> fieldIndexMap,Map<String,String> errorMap,boolean isok){
+		List<SheetRowData>  needsheetRowDataList =new ArrayList<>();
+		if(errorMap.size()>0) {
+			//瑕佹妸浠ヤ笂鐨勯敊璇殑閮芥姏鍑哄悗锛屽啀缁х画澶勭悊鏃堕棿鍜岀粍鍚堣鍒�
+			needsheetRowDataList = dataSet.getRowData().stream().filter(cbo -> {
+				String rowIndex=cbo.getRowIndex();
+				return  isok? !errorMap.containsKey(rowIndex):errorMap.containsKey(rowIndex);
+			}).collect(Collectors.toList());
 
+		}else{
+			needsheetRowDataList= dataSet.getRowData();
+		}
+		Map<String/**涓枃鍚嶇О**/, SheetRowData/**鑻辨枃鍚嶇О**/> rowIdexDataMap = needsheetRowDataList.stream().collect(Collectors.toMap(s -> s.getRowIndex(), t -> t,(o1, o2)->o2));
+		Map<String,CodeImprotDataVO> clsfDataMap=new HashMap<>();
+		rowIndexCbo .forEach((rowIndex, cbo) -> {
+			CodeImprotDataVO codeImprotDataVO = new CodeImprotDataVO();
+			codeImprotDataVO.setTemplateOid(templateVO.getOid());
+			List<Map<String, String>> dataList = new ArrayList<>();
+			if(rowIdexDataMap.containsKey(rowIndex)){
+				SheetRowData sheetRowData=rowIdexDataMap.get(rowIndex);
+				Map<String, String> dataMap = new HashMap<>();
+				Map<Integer, String> data = sheetRowData.getData();
+				fieldIndexMap.forEach((integer, s) -> {
+					String field = fieldIndexMap.get(integer);
+					if (data.containsKey(integer)) {
+						String vlues = data.get(integer);
+						dataMap.put(field, vlues);
+					}
+				});
+				dataMap.put("oid",cbo.getOid());
+				dataList.add(dataMap);
+			}
+			if(clsfDataMap.containsKey(templateVO.getOid())){
+				codeImprotDataVO=clsfDataMap.get(templateVO.getOid());
+				dataList.addAll(codeImprotDataVO.getDatas());
+			}
+			codeImprotDataVO.setColNames(dataSet.getColName());
+			codeImprotDataVO.setDatas(dataList);
+			clsfDataMap.put(templateVO.getOid(),codeImprotDataVO);
+		});
+		if(!CollectionUtils.isEmpty(clsfDataMap)) {
+			Collection codeImprotDataVOS=clsfDataMap.values();
+			List<CodeImprotDataVO> codeImprotDataVOList=new ArrayList<>();
+			codeImprotDataVOList.addAll(codeImprotDataVOS);
+			bladeRedis.set(uuid+"-"+templateVO.getOid(), codeImprotDataVOList);
+			bladeRedis.expire(uuid+"-"+templateVO.getOid(),BATCHADD_REDIS_TIME);//redis杩囨湡鏃堕棿
+		}
+	}
+
+	/****
+	 * 鏁版嵁鐩镐技椤规暟鎹牎楠宺edis缂撳瓨
+	 * @param codeClassifyOid
+	 * @param templateVO
+	 * @param cboList
+	 * @param resembleMap
+	 * @param btmtypeid
+	 * @param dataResembleVOS
+	 */
+	private void bathcResembleQuery(String codeClassifyOid, CodeClassifyTemplateVO templateVO, List<ClientBusinessObject> cboList,Map<String,String>resembleMap,String btmtypeid,List<DataResembleVO> dataResembleVOS){
+		CodeClassifyFullInfoBO fullInfoBO = classifyService.getClassifyFullInfo(codeClassifyOid);
+		Map<String, String> conditionMap = new HashMap<>();
+		CodeResembleRuleVO resembleRuleVO = Optional.ofNullable(engineService.getUseResembleRule(fullInfoBO, fullInfoBO.getCurrentClassifyVO())).orElseGet(() -> new CodeResembleRuleVO());
+		//闇�瑕佽幏鍙栨槸鍚︽湁鐩镐技鏌ヨ灞炴��
+		Map<String, CodeClassifyTemplateAttrVO> attrVOs = templateVO.getAttributes().stream().filter(s -> VciBaseUtil.getBoolean(s.getSameRepeatAttrFlag())).collect(Collectors.toMap(s -> s.getId(), t -> t));
+		if (CollectionUtils.isEmpty(attrVOs)) {
+			return;
+		}
+		Map<String,CodeImprotResembleVO> codeImprotResembleVOMap=new HashMap<>();
+		List<CodeImprotResembleVO> codeImprotResembleVOList=new ArrayList<>();
+		Map<String,String> rowIndePathMap=new HashMap<>();
+		cboList.stream().forEach(clientBusinessObject -> {
+			CodeImprotResembleVO codeImprotResembleVO=new CodeImprotResembleVO();
+			final String[] path = {""};
+			List<String> fieldList=new ArrayList<>();
+			List<String> rowIndeList=new ArrayList<>();
+			String rowIndex = clientBusinessObject.getAttributeValue(IMPORT_ROW_INDEX);
+			attrVOs.forEach((attrId, attrVO) -> {
+				String value="";
+                /*if (VciQueryWrapperForDO.BASIC_FIELD_MAP.containsKey(attrId)) {
+                    value = WebUtil.getStringValueFromObject(WebUtil.getValueFromField(WebUtil.getFieldForObject(attrId, orderDTO.getClass()).getName(), orderDTO));
+                }else {*/
+				value= clientBusinessObject.getAttributeValue(attrId);
+				// }
+				fieldList.add(attrId);
+				value=StringUtils.isBlank(value)?"":value;
+				path[0] +=value+"#";
+				engineService.wrapperResembleConditionMap(value, resembleRuleVO, attrId, conditionMap);
+			});
+			List<Map<String,String>> dataMap=new ArrayList<>();
+			if(codeImprotResembleVOMap.containsKey(path[0])) {
+				codeImprotResembleVO=codeImprotResembleVOMap.get(path[0]);
+				rowIndeList=codeImprotResembleVO.getRownIndex();
+				dataMap=  codeImprotResembleVO.getDataList();
+				resembleMap.put(rowIndex, "瀛樺湪鐩镐技鏁版嵁");
+			}else{
+				if (!CollectionUtils.isEmpty(conditionMap)) {
+					Map<String, String> andConditionMap = new HashMap<>();
+					andConditionMap.put("islastr", "1");
+					andConditionMap.put("islastv", "1");
+					conditionMap.putAll(andConditionMap);
+					PageHelper pageHelper = new PageHelper(-1);
+					pageHelper.addDefaultDesc("id");
+					CodeTemplateAttrSqlBO sqlBO = engineService.getSqlByTemplateVO(btmtypeid, templateVO, conditionMap, pageHelper);
+					List<Map<String,String>> dataMapList=commonsMapper.queryByOnlySqlForMap(sqlBO.getSqlUnPage());
+					List<ClientBusinessObject> resembleCboList=	ChangeMapTOClientBusinessObjects(dataMapList);
+					if(!CollectionUtils.isEmpty(resembleCboList)) {
+						List<Map<String, String>> finalDataMap = dataMap;
+						resembleCboList.stream().forEach(cbo->{
+							Map<String,String> resembDataMap=new HashMap<>();
+							fieldList.stream().forEach(field->{
+								String value=cbo.getAttributeValue(field);
+								value=StringUtils.isBlank(value)?"":value;
+								resembDataMap.put(field,value);
+							});
+							resembDataMap.put("codetemplateoid",templateVO.getOid());
+							resembDataMap.put("id",StringUtils.isBlank(cbo.getAttributeValue("id"))?"":cbo.getAttributeValue("id"));
+							resembDataMap.put("rowIndex","");
+							resembDataMap.put("oid",cbo.getOid());
+							finalDataMap.add(resembDataMap);
+						});
+						resembleMap.put(rowIndex, "瀛樺湪鐩镐技鏁版嵁");
+
+					}
+				}
+			}
+			rowIndePathMap.put(rowIndex,path[0]);
+			rowIndeList.add(rowIndex);
+			codeImprotResembleVO.setPath(path[0]);
+			codeImprotResembleVO.setRownIndex(rowIndeList);
+			codeImprotResembleVO.setConditionMap(conditionMap);
+			codeImprotResembleVO.setFields(fieldList);
+			codeImprotResembleVO.setDataList(dataMap);
+			codeImprotResembleVOMap.put(path[0],codeImprotResembleVO);
+		});
+		Map<String, ClientBusinessObject> cboMap = cboList.stream().filter(cbo -> cbo != null).collect(Collectors.toList()).stream().collect(Collectors.toMap(s -> s.getAttributeValue((IMPORT_ROW_INDEX)), t -> t));
+		if(!CollectionUtils.isEmpty(rowIndePathMap)){
+			rowIndePathMap.forEach((rowIndex, path) -> {
+				if(codeImprotResembleVOMap.containsKey(path)){
+					CodeImprotResembleVO codeImprotResembleVO=  codeImprotResembleVOMap.get(path);
+					List<String> fieldList=codeImprotResembleVO.getFields();
+					List<String> rownIndexList= codeImprotResembleVO.getRownIndex();
+					List<String> newRownIndexList = rownIndexList.stream().filter(cbo -> {
+						return rowIndex!=cbo;
+					}).collect(Collectors.toList());
+					newRownIndexList.stream().forEach(s -> {
+						resembleMap.put(s, "瀛樺湪鐩镐技鏁版嵁");
+					});
+					List<Map<String, String>>newDataList=new ArrayList<>();
+					DataResembleVO dataResembleVO=new DataResembleVO();
+					dataResembleVO.setOid(cboMap.get(rowIndex).getOid());
+					List<ClientBusinessObject> needSaveCboList = cboList.stream().filter(cbo -> {
+						String newRowIndex = cbo.getAttributeValue(IMPORT_ROW_INDEX);
+						return rownIndexList.contains(newRowIndex)&&(!newRowIndex.equalsIgnoreCase(rowIndex));
+					}).collect(Collectors.toList());
+					if(!CollectionUtils.isEmpty(needSaveCboList)) {
+						needSaveCboList.stream().forEach(cbo -> {
+							String newRowIndex = cbo.getAttributeValue(IMPORT_ROW_INDEX);
+							Map<String, String> resembDataMap = new HashMap<>();
+							fieldList.stream().forEach(field -> {
+								String value = cbo.getAttributeValue(field);
+								value = StringUtils.isBlank(value) ? "" : value;
+								resembDataMap.put(field, value);
+							});
+							resembDataMap.put("codetemplateoid",templateVO.getOid());
+							resembDataMap.put("id",StringUtils.isBlank(cbo.getAttributeValue("id"))?"":cbo.getAttributeValue("id"));
+							resembDataMap.put("rowIndex", newRowIndex);
+							resembDataMap.put("oid",cbo.getOid());
+							newDataList.add(resembDataMap);
+						});
+					}
+					List<Map<String, String>>dataList=codeImprotResembleVO.getDataList();
+					newDataList.addAll(dataList);
+					dataResembleVO.setDataList(newDataList);
+					dataResembleVOS.add(dataResembleVO);
+				}
+			});
+		}
+	}
+
+	/***
+	 * 瀛樺偍鍒嗙被瀵硅薄鍙婂叾鍒楀悕
+	 * @param uuid
+	 * @param templateVOList
+	 * @param dataSet
+	 * @param fieldIndexMap
+	 * @param iscContain
+	 */
+	private  void createRedisByCodeClassify(String uuid,CodeClassifyTemplateVO templateVOList,SheetDataSet dataSet, Map<Integer/**鍒楀彿**/,String/**瀛楁鐨勫悕绉�**/> fieldIndexMap,boolean iscContain){
+		List<ColumnVO> columnVOList = new ArrayList<>();
+		List<String> outNameList = dataSet.getColName();
+		fieldIndexMap.forEach((integer, s) -> {
+			ColumnVO columnVOS = new ColumnVO();
+			String field = fieldIndexMap.get(integer);
+			String outName = outNameList.get(integer);
+			columnVOS.setField(field);
+			columnVOS.setTitle(outName);
+			columnVOList.add(columnVOS);
+		});
+		CodeImportTemplateVO codeImportTemplateVO=new CodeImportTemplateVO();
+		codeImportTemplateVO.setCodeClassifyTemplateVO(templateVOList);
+		codeImportTemplateVO.setCloNamesList(columnVOList);
+		List<CodeImportTemplateVO> codeImportTemplateVOs= new ArrayList<>();
+
+		codeImportTemplateVOs.add(codeImportTemplateVO);
+		if(codeImportTemplateVOs.size()>0) {
+			bladeRedis.set(uuid, codeImportTemplateVOs);
+			bladeRedis.expire(uuid, BATCHADD_REDIS_TIME);//redis杩囨湡鏃堕棿
+		}
+	}
+	/**
+	 * 鎷疯礉涓氬姟绫诲瀷鍒癿ap
+	 * @param cbo 涓氬姟鏁版嵁
+	 * @param map map
+	 */
+	public static void copyValueToMapFromCbos(ClientBusinessObject cbo,Map<String,String> map){
+		if(cbo!=null){
+			copyValueToMapFromBos(cbo,map);
+		}
+	}
+
+	/**
+	 * 鎷疯礉涓氬姟绫诲瀷鍒癿ap
+	 * @param bo 涓氬姟鏁版嵁
+	 * @param map map
+	 */
+	public static void copyValueToMapFromBos(ClientBusinessObject bo,Map<String,String> map){
+		if(bo!=null ){
+			//鍏堟妸鎵�鏈夌殑瀛楁鏄犲皠鎵惧埌
+			AttributeValue[] newAList = bo.newAttrValList;
+			AttributeValue[] hisAList = bo.hisAttrValList;
+			if(hisAList!=null&&hisAList.length>0){//
+				for(int i = 0 ; i < hisAList.length;i++){
+					AttributeValue av = hisAList[i];
+					String attrName = av.attrName.toLowerCase();
+					map.put(attrName, av.attrVal);
+				}
+			}
+			if(newAList!=null&&newAList.length>0){//NEW鐨勪紭鍏堢骇楂樹簺
+				for(int i = 0 ; i < newAList.length;i++){
+					AttributeValue av = newAList[i];
+					String attrName = av.attrName.toLowerCase();
+					map.put(attrName, av.attrVal);
+				}
+			}
+		}
+	}
 }
diff --git a/Source/UBCS/ubcs-service/ubcs-code/src/main/java/com/vci/ubcs/code/util/AttributeChecker.java b/Source/UBCS/ubcs-service/ubcs-code/src/main/java/com/vci/ubcs/code/util/AttributeChecker.java
new file mode 100644
index 0000000..6dab7fc
--- /dev/null
+++ b/Source/UBCS/ubcs-service/ubcs-code/src/main/java/com/vci/ubcs/code/util/AttributeChecker.java
@@ -0,0 +1,115 @@
+package com.vci.ubcs.code.util;
+
+import com.vci.ubcs.omd.feign.IAttributeClient;
+import com.vci.ubcs.omd.util.Tool;
+import com.vci.ubcs.omd.vo.AttributeVO;
+import org.springblade.core.tool.api.R;
+import org.springframework.beans.factory.annotation.Autowired;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+
+public class AttributeChecker {
+
+	@Autowired(required = false)
+	private  IAttributeClient attributeClient;
+
+	public static HashMap<String, AttributeVO> attrItemMap = new HashMap();
+	public static List<AttributeVO> attrItems = new ArrayList<AttributeVO>();
+
+	public void getAllAttribute() {
+		if (attrItems == null) {
+			R<List<AttributeVO>> R = attributeClient.getAll();
+			attrItems=R.getData();
+			List<AttributeVO> var4;
+			int var3 = (var4 = attrItems).size();
+
+			for(int var2 = 0; var2 < var3; ++var2) {
+				AttributeVO attrItem = var4.get(var2);
+				attrItemMap.put(attrItem.getName(), attrItem);
+			}
+		}
+
+	}
+
+	public int isAttrValValid(String attrName, String attrVal) {
+//		if (!BusinessConstants.BO_CONSTANTS.containsKey(attrName.toUpperCase())) {
+			if (attrVal != null && !attrVal.trim().equals("")) {
+				this.getAllAttribute();
+				AttributeVO attributeVO = (AttributeVO)attrItemMap.get(attrName);
+				if (attributeVO == null) {
+					return 0;
+				} else {
+					String attrType = attributeVO.getTypeKey();
+					int rs;
+					if (attrType.equals("VTString")) {
+					//	rs = this.checkVTStringValValid(attributeVO, attrName, attrVal);
+						rs = 0;
+					} else if (attrType.equals("VTInteger")) {
+					//	rs = this.checkVTIntegerValValid(attributeVO, attrName, attrVal);
+						rs = 0;
+					} else if (attrType.equals("VTLong")) {
+					//	rs = this.checkVTLongValValid(attributeVO, attrName, attrVal);
+						rs = 0;
+					} else if (attrType.equals("VTDouble")) {
+					//	rs = this.checkVTDoubleValValid(attributeVO, attrName, attrVal);
+						rs = 0;
+					} else if (attrType.equals("VTBoolean")) {
+						rs = 0;
+					} else if (attrType.equals("VTImage")) {
+						rs = 0;
+					} else if (attrType.equals("VTDate")) {
+						rs = 0;
+					} else if (attrType.equals("VTTime")) {
+						rs = 0;
+					} else if (attrType.equals("VTDateTime")) {
+						rs = 0;
+					} else if (attrType.equals("VTNote")) {
+						rs = 0;
+					} else if (attrType.equals("VTFilePath")) {
+						rs = 0;
+					} else {
+						rs = 0;
+					}
+
+					return rs;
+				}
+			} else {
+				return 0;
+			}
+//		} else {
+//			return 0;
+//		}
+	}
+
+	/*private int checkVTStringValValid(AttributeVO attributeVO, String attrName, String attrVal) {
+		String other ="";
+		int maxLength = Integer.valueOf(Tool.getOtherValueByType(other, "length"));
+		int length = attrVal.length();
+		return length > maxLength ? 1 : 0;
+	}
+
+	private int checkVTIntegerValValid(AttributeVO attributeVO, String attrName, String attrVal) {
+		VTInteger obj = new VTInteger(Integer.valueOf(attrVal));
+		return !obj.checkRageValueByRage(attributeVO.rage) ? 2 : 0;
+	}
+
+	private int checkVTLongValValid(AttributeVO attributeVO, String attrName, String attrVal) {
+		VTLong obj = new VTLong(Long.valueOf(attrVal));
+		return !obj.checkRageValueByRage(attributeVO.rage) ? 2 : 0;
+	}
+
+	private int checkVTDoubleValValid(AttributeVO attributeVO, String attrName, String attrVal) {
+		VTDouble obj = new VTDouble(Double.valueOf(attrVal));
+		String other = attributeVO.other;
+		int maxLength = Integer.valueOf(Tool.getOtherValueByType(other, "length"));
+		int length = String.valueOf(attrVal).length() - 1;
+		if (length >= maxLength && !obj.checkRageValueByRage(attributeVO.rage)) {
+			return 3;
+		} else if (!obj.checkRageValueByRage(attributeVO.rage)) {
+			return 2;
+		} else {
+			return length >= maxLength ? 1 : 0;
+		}
+	}*/
+}
diff --git a/Source/UBCS/ubcs-service/ubcs-code/src/main/java/com/vci/ubcs/code/util/ClientBusinessObject.java b/Source/UBCS/ubcs-service/ubcs-code/src/main/java/com/vci/ubcs/code/util/ClientBusinessObject.java
new file mode 100644
index 0000000..a74b470
--- /dev/null
+++ b/Source/UBCS/ubcs-service/ubcs-code/src/main/java/com/vci/ubcs/code/util/ClientBusinessObject.java
@@ -0,0 +1,111 @@
+package com.vci.ubcs.code.util;
+
+import com.vci.ubcs.code.bo.AttributeValue;
+import com.vci.ubcs.code.vo.pagemodel.BaseModelVO;
+import com.vci.ubcs.starter.exception.VciBaseException;
+import com.vci.ubcs.starter.revision.model.BaseModel;
+import lombok.Data;
+
+import java.util.ArrayList;
+
+@Data
+public class ClientBusinessObject extends BaseModel {
+
+	public AttributeValue[] newAttrValList;
+	public AttributeValue[] hisAttrValList;
+
+	public void setAttributeValue(String attributeName, String attributeValue) throws VciBaseException {
+		this.setAttributeValue(attributeName, attributeValue, false);
+	}
+
+	public void setAttributeValue(String attributeName, String attributeValue, boolean isCreate) throws VciBaseException {
+		int isValid = (new AttributeChecker()).isAttrValValid(attributeName, attributeValue);
+		if (isValid == 1) {
+			throw getLocalError("P0010SOF-00017", new String[]{attributeName, attributeValue});
+		} else if (isValid == 2) {
+			throw this.getLocalError("P0010SOF-00018", new String[]{attributeName, attributeValue});
+		} else if (isValid == 3) {
+			throw this.getLocalError("P0010SOF-00019", new String[]{attributeName, attributeValue});
+		} else {
+			this.setAttributeValueWithNoCheck(attributeName, attributeValue, isCreate);
+		}
+	}
+
+	public void setAttributeValueWithNoCheck(String attributeName, String attributeValue) throws VciBaseException {
+		this.setAttributeValueWithNoCheck(attributeName, attributeValue, false);
+	}
+
+	public void setAttributeValueWithNoCheck(String attributeName, String attributeValue, boolean isCreate) throws VciBaseException {
+		/*if (isCreate) {//&& BusinessConstants.BO_CONSTANTS.containsKey(attributeName.toUpperCase())
+			this.setConstantsAttrVal(attributeName, attributeValue);
+		} else {*/
+			AttributeValue[] attrValues = this.newAttrValList;
+			ArrayList<AttributeValue> attrValList = new ArrayList();
+			AttributeValue attrVal;
+			int i;
+			if (attrValues != null && attrValues.length > 0) {
+				AttributeValue[] var9 = attrValues;
+				i = attrValues.length;
+
+				for(int var7 = 0; var7 < i; ++var7) {
+					attrVal = var9[var7];
+					attrValList.add(attrVal);
+				}
+			}
+
+			attrVal = null;
+			boolean isExist = false;
+
+			for(i = 0; i < attrValList.size(); ++i) {
+				attrVal = (AttributeValue)attrValList.get(i);
+				if (attrVal.attrName.toUpperCase().equals(attributeName.toUpperCase())) {
+					attrVal.attrVal = attributeValue;
+					isExist = true;
+					break;
+				}
+			}
+
+			if (!isExist) {
+				attrVal = new AttributeValue();
+				attrVal.attrName = attributeName.toUpperCase();
+				attrVal.attrVal = attributeValue;
+				attrValList.add(attrVal);
+			}
+
+			this.newAttrValList = (AttributeValue[])attrValList.toArray(new AttributeValue[attrValList.size()]);
+	//	}
+	}
+
+	public String getAttributeValue(String attrName) {
+		String res = "";
+		boolean existInNewAttr = false;
+		int i;
+		if (this.newAttrValList != null) {
+			for(i = 0; i < this.newAttrValList.length; ++i) {
+				if (this.newAttrValList[i].attrName.toUpperCase().equals(attrName.toUpperCase())) {
+					existInNewAttr = true;
+					res = this.newAttrValList[i].attrVal;
+				}
+			}
+		}
+
+		if (existInNewAttr) {
+			return res;
+		} else if (this.hisAttrValList == null) {
+			return "";
+		} else {
+			for(i = 0; i < this.hisAttrValList.length; ++i) {
+				if (this.hisAttrValList[i].attrName.toUpperCase().equals(attrName.toUpperCase())) {
+					res = this.hisAttrValList[i].attrVal;
+				}
+			}
+
+			return res;
+		}
+	}
+
+	public VciBaseException getLocalError(String error_code ,String[] error_messages) {
+		return new VciBaseException(error_code, error_messages);
+	}
+
+}

--
Gitblit v1.9.3