From 7f0570d20aac189f1b170942bd7100b281a1c824 Mon Sep 17 00:00:00 2001
From: ludc
Date: 星期三, 26 四月 2023 00:07:37 +0800
Subject: [PATCH] 代码整合，新增codefixedcontroller

---
 Source/UBCS/ubcs-service/ubcs-code/src/main/java/com/vci/ubcs/code/service/impl/CodeClassifyServiceImpl.java |  988 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 files changed, 988 insertions(+), 0 deletions(-)

diff --git a/Source/UBCS/ubcs-service/ubcs-code/src/main/java/com/vci/ubcs/code/service/impl/CodeClassifyServiceImpl.java b/Source/UBCS/ubcs-service/ubcs-code/src/main/java/com/vci/ubcs/code/service/impl/CodeClassifyServiceImpl.java
new file mode 100644
index 0000000..6547785
--- /dev/null
+++ b/Source/UBCS/ubcs-service/ubcs-code/src/main/java/com/vci/ubcs/code/service/impl/CodeClassifyServiceImpl.java
@@ -0,0 +1,988 @@
+package com.vci.ubcs.code.service.impl;
+
+import com.alibaba.nacos.common.utils.StringUtils;
+import com.baomidou.mybatisplus.core.conditions.Wrapper;
+import com.baomidou.mybatisplus.core.metadata.IPage;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.baomidou.mybatisplus.extension.toolkit.SqlHelper;
+import com.vci.ubcs.starter.revision.model.TreeQueryObject;
+import com.vci.ubcs.starter.revision.model.TreeWrapperOptions;
+import com.vci.ubcs.code.entity.CodeClassify;
+import com.vci.ubcs.code.entity.CodeClstemplateEntity;
+import com.vci.ubcs.code.entity.CodeOsbtmtypeEntity;
+import com.vci.ubcs.code.entity.CodeOsbtmtypeattributeEntity;
+import com.vci.ubcs.code.enumpack.FrameworkDataLCStatus;
+import com.vci.ubcs.code.mapper.CodeClassifyMapper;
+import com.vci.ubcs.code.mapper.CodeClstemplateMapper;
+import com.vci.ubcs.code.mapper.CodeOsbtmtypeMapper;
+import com.vci.ubcs.code.mapper.CodeOsbtmtypeattributeMapper;
+import com.vci.ubcs.code.po.CodeClassifyPO;
+import com.vci.ubcs.code.service.ICodeClassifyService;
+import com.vci.ubcs.code.service.ICodeKeyattrrepeatService;
+import com.vci.ubcs.code.service.ICodeRuleService;
+import com.vci.ubcs.code.vo.CodeOsattributeVO;
+import com.vci.ubcs.code.vo.CodeOsbtmtypeVO;
+import com.vci.ubcs.code.vo.pagemodel.CodeClassifyVO;
+import com.vci.ubcs.code.vo.pagemodel.CodeKeyAttrRepeatRuleVO;
+import com.vci.ubcs.code.vo.pagemodel.CodeRuleVO;
+import com.vci.ubcs.starter.revision.model.TreeQueryObject;
+import com.vci.ubcs.starter.bo.WriteExcelData;
+import com.vci.ubcs.starter.exception.VciBaseException;
+import com.vci.ubcs.starter.poi.bo.ReadExcelOption;
+import com.vci.ubcs.starter.poi.bo.WriteExcelOption;
+import com.vci.ubcs.starter.poi.constant.ExcelLangCodeConstant;
+import com.vci.ubcs.starter.poi.util.ExcelUtil;
+import com.vci.ubcs.starter.revision.service.RevisionModelUtil;
+import com.vci.ubcs.starter.util.LocalFileUtil;
+import com.vci.ubcs.starter.web.pagemodel.BaseQueryObject;
+import com.vci.ubcs.starter.web.pagemodel.DataGrid;
+import com.vci.ubcs.starter.web.pagemodel.Tree;
+import com.vci.ubcs.starter.web.util.BeanUtilForVCI;
+import com.vci.ubcs.starter.web.util.LangBaseUtil;
+import com.vci.ubcs.starter.web.util.VciBaseUtil;
+import org.springblade.core.log.exception.ServiceException;
+import org.apache.poi.hssf.util.HSSFColor;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springblade.core.cache.utils.CacheUtil;
+import org.springblade.core.mp.support.Condition;
+import org.springblade.core.secure.utils.AuthUtil;
+import org.springblade.core.tool.api.R;
+import org.springframework.beans.BeanUtils;
+import org.springframework.stereotype.Service;
+import org.springframework.util.CollectionUtils;
+
+import javax.annotation.Resource;
+import java.io.File;
+import java.util.*;
+import java.util.stream.Collectors;
+
+import static com.vci.ubcs.code.constant.FrameWorkDefaultValueConstant.*;
+
+@Service
+public class CodeClassifyServiceImpl extends ServiceImpl<CodeClassifyMapper, CodeClassify> implements ICodeClassifyService {
+
+	@Resource
+	private CodeClassifyMapper codeClassifyMapper;
+
+	@Resource
+	private CodeClstemplateMapper codeClstemplateMapper;
+
+	@Resource
+	private ICodeRuleService codeRuleService;
+
+	@Resource
+	private CodeOsbtmtypeMapper codeOsbtmtypeMapper;
+	@Resource
+	CodeOsbtmtypeattributeMapper codeOsbtmtypeattributeMapper;
+
+	/**
+	 * 鏃ュ織
+	 */
+	private Logger logger = LoggerFactory.getLogger(getClass());
+	/**
+	 * 瀵硅薄鐨勬搷浣�
+	 */
+	@Resource
+	private RevisionModelUtil revisionModelUtil;
+
+	@Resource
+	private ICodeKeyattrrepeatService iCodeKeyattrrepeatService;
+	/**
+	 * 涓婄骇鑺傜偣鐨勫睘鎬у悕绉�
+	 */
+	public static  final String PARENT_FIELD_NAME = "parentCodeClassifyOid";
+	/**
+	 * 浣跨敤鏌ヨ灏佽鍣ㄦ潵鏌ヨ
+	 * @param wrapper 鏌ヨ灏佽鍣�
+	 * @return 鏁版嵁瀵硅薄
+	 */
+	@Override
+	public List<CodeClassify> selectByWrapper(Wrapper wrapper) {
+		return codeClassifyMapper.selectList(wrapper);
+	}
+
+	@Override
+	public IPage<CodeClassifyVO> selectPlCodeClassifyPage(IPage<CodeClassifyVO> page, CodeClassifyVO plCodeClassify) {
+		return page.setRecords(codeClassifyMapper.selectPlCodeClassifyPage(page, plCodeClassify));
+	}
+
+	@Override
+	public R addSave(CodeClassify codeClassifyEntity) {
+
+		if(StringUtils.isNotBlank(codeClassifyEntity.getParentCodeClassifyOid()) && StringUtils.isNotBlank(codeClassifyEntity.getBtmTypeId())){
+			return R.fail("鍙湁鍦ㄩ《灞傜殑涓婚搴撳垎绫绘墠鑳借缃笟鍔＄被鍨�");
+		}
+		codeClassifyEntity.setCreator(AuthUtil.getUser().getUserName());
+		codeClassifyEntity.setCreateTime(new Date());
+		codeClassifyEntity.setTs(new Date());
+		codeClassifyEntity.setOwner(AuthUtil.getUser().getUserName());
+		codeClassifyEntity.setLastModifier(AuthUtil.getUser().getUserName());
+		codeClassifyEntity.setLastModifyTime(new Date());
+		codeClassifyEntity.setRevisionSeq(1);
+		codeClassifyEntity.setVersionSeq(1);
+		int insertNumber = codeClassifyMapper.insert(codeClassifyEntity);
+		return R.status(SqlHelper.retBool(insertNumber));
+	}
+
+	/**
+	 * 淇敼涓婚搴撳垎绫�
+	 * @param codeClassifyEntity 涓婚搴撳垎绫绘暟鎹紶杈撳璞�
+	 * @return 鎵ц缁撴灉
+	 */
+	@Override
+	public R editSave(CodeClassify codeClassifyEntity) {
+		if(codeClassifyEntity == null || codeClassifyEntity.getOid() == null){
+			return R.fail("浼犲叆鏁版嵁涓嶈兘涓虹┖锛�");
+		}
+		//妫�鏌s
+		Map<String,Object> condition = new HashMap<>(2);
+		condition.put("oid",codeClassifyEntity.getOid());
+		condition.put("ts",codeClassifyEntity.getTs());
+		CodeClassify detail = codeClassifyMapper
+			.selectOne(Condition.getQueryWrapper(condition,CodeClassify.class));
+		if(detail == null){//涓嶆槸鏈�鏂扮殑涓嶈鏀�
+			return R.fail("褰撳墠鏁版嵁涓嶆槸鏈�鏂帮紝璇峰埛鏂板悗鍐嶄慨鏀癸紒");
+		}
+
+		if(StringUtils.isNotBlank(codeClassifyEntity.getParentCodeClassifyOid()) && StringUtils.isNotBlank(codeClassifyEntity.getBtmTypeId())){
+			return R.fail("鍙湁鍦ㄩ《灞傜殑涓婚搴撳垎绫绘墠鑳借缃笟鍔＄被鍨�");
+		}
+		codeClassifyEntity.setLastModifier(AuthUtil.getUser().getUserName());
+		codeClassifyEntity.setLastModifyTime(new Date());
+		int insertNumber = codeClassifyMapper.updateById(codeClassifyEntity);
+
+//         //澶勭悊鏁版嵁闆嗘垚閫昏緫,鎴愬姛鍚庢墽琛岄泦鎴愮涓�姝�,鍒嗙被鏁版嵁鐗规畩澶勭悊銆傚彧鏈夊惎鐢ㄧ姸鎬佺殑鍒嗙被鎵嶆帹閫�
+//         if(FRAMEWORK_DATA_ENABLED.equals(codeClassifyDO.getLcStatus()));
+//         {
+//             codeDuckingServiceI.insertCache1(CACHE_TYPE_CLASSIFY_EDIT,FRAMEWORK_DATA_ENABLED,DOCKING_DEFAULT_CLASSIFY, DOCKING_DEFAULT_CLASSIFYOID, codeClassifyDO.getOid(), codeClassifyDTO.getTs());
+//         }
+		return R.status(SqlHelper.retBool(insertNumber));
+//		return BaseResult.success(codeClassifyDO2VO(codeClassifyDO));
+	}
+
+	/**
+	 * 妫�鏌� 涓婚搴撳垎绫绘槸鍚﹀垹闄�
+	 * @param codeClassifyEntity 涓婚搴撳垎绫绘暟鎹紶杈撳璞★紝蹇呴』瑕佹湁oid鍜宼s灞炴��
+	 * @return 鎵ц缁撴灉 success涓簍rue涓哄彲浠ュ垹闄わ紝false琛ㄧず鏈夋暟鎹紩鐢紝obj涓簍rue琛ㄧず鏈変笅绾�
+	 */
+	@Override
+	public R checkIsCanDelete(CodeClassify codeClassifyEntity) {
+		if(codeClassifyEntity == null || codeClassifyEntity.getOid() == null){
+			return R.fail("浼犲叆鏁版嵁涓嶈兘涓虹┖锛�");
+		}
+		CodeClassify codeClassifyNew = selectByOid(codeClassifyEntity.getOid());
+		if(codeClassifyNew == null){
+			return R.fail("鏈煡璇㈠埌鐩稿叧鏁版嵁锛�");
+		}
+		codeClassifyNew.setTs(codeClassifyEntity.getTs());
+		return checkIsCanDeleteForDO(codeClassifyEntity);
+	}
+
+	/**
+	 * 涓婚敭鏌ヨ鏁版嵁瀵硅薄
+	 * @param oid 涓婚敭
+	 * @return  鏁版嵁瀵硅薄
+	 */
+	private CodeClassify selectByOid(String oid){
+
+		CodeClassify codeClassifyEntity = codeClassifyMapper.selectById(oid.trim());
+		if(codeClassifyEntity == null || StringUtils.isBlank(codeClassifyEntity.getOid())){
+			throw new ServiceException("dataOidNotExist");//鏍规嵁涓婚敭id鏈煡鍒扮浉鍏虫暟鎹�
+		}
+		return codeClassifyEntity;
+	}
+
+	/**
+	 * 鏍￠獙鏄惁鍙互鍒犻櫎锛屽鏋滃瓨鍦ㄤ笅绾э紝骞朵笖涓嬬骇鏈夋暟鎹紩鐢ㄥ垯涓嶈兘鍒犻櫎
+	 * @param codeClassifyEntity 鏁版嵁搴撲腑鐨勬暟鎹璞�
+	 * @return success涓簍rue涓哄彲浠ュ垹闄わ紝false琛ㄧず鏈夋暟鎹紩鐢紝obj涓簍rue琛ㄧず鏈変笅绾�
+	 */
+	private R checkIsCanDeleteForDO(CodeClassify codeClassifyEntity) {
+
+		//妫�鏌s
+//		Map<String,Object> condition = new HashMap<>(2);
+//		condition.put("oid",codeClassifyEntity.getOid());
+//		condition.put("ts",codeClassifyEntity.getTs());
+		CodeClassify detail = codeClassifyMapper.selectOne(Condition.getQueryWrapper(codeClassifyEntity));
+//			.selectOne(Condition.getQueryWrapper(condition,CodeClassify.class));
+		if(detail == null){//涓嶆槸鏈�鏂扮殑涓嶈鏀�
+			throw new ServiceException("褰撳墠鏁版嵁涓嶆槸鏈�鏂帮紝璇峰埛鏂板悗鍐嶄慨鏀癸紒");
+//			return R.fail("褰撳墠鏁版嵁涓嶆槸鏈�鏂帮紝璇峰埛鏂板悗鍐嶄慨鏀癸紒");
+		}
+		//鏍￠獙涓嬬骇鏄惁鏈夊紩鐢�
+		if(checkChildIsLinked(detail.getOid())){
+			return R.fail("dataCascadeLinkedNotDelete");
+		}
+		return R.data(checkHasChild(detail.getOid()));
+	}
+
+	/**
+	 * 妫�鏌ユ槸鍚︽湁涓嬬骇鏄惁鍏宠仈浜嗘暟鎹�
+	 *
+	 * @param oid 涓婚敭
+	 * @return true 琛ㄧず鏈夊紩鐢紝false琛ㄧず娌℃湁寮曠敤
+	 */
+	@Override
+	public boolean checkChildIsLinked(String oid) {
+
+		Map<String,String> childOids = codeClassifyMapper.selectAllLevelChildOid(oid.trim());
+		if(!CollectionUtils.isEmpty(childOids)){
+			for(String childOid: childOids.keySet()){
+				if(!checkIsLinked(childOid)){
+					return false;
+				}
+			}
+			return true;
+		}
+		return false;
+	}
+
+	/**
+	 * 鏍￠獙鏄惁琚紩鐢�
+	 * @param oid 涓婚敭
+	 */
+	private boolean checkIsLinked(String oid) {
+		//TODO 娣诲姞闇�瑕佹牎楠屽紩鐢ㄧ殑鍦版柟
+		return false;
+	}
+
+	@Override
+	public boolean checkHasChild(String oid) {
+		if(StringUtils.isBlank(oid)){
+			throw new ServiceException("oid涓嶈兘涓虹┖锛�");
+		}
+		return codeClassifyMapper.checkHasChild(oid.trim());
+	}
+
+
+	/**
+	 * 鍒犻櫎涓婚搴撳垎绫�
+	 * @param codeClassify 涓婚搴撳垎绫绘暟鎹紶杈撳璞★紝oid鍜宼s闇�瑕佷紶杈�
+	 * @return 鍒犻櫎缁撴灉鍙嶉锛氾細success锛氭垚鍔燂紝fail锛氬け璐�
+	 */
+	@Override
+	public R deleteCodeClassify(CodeClassify codeClassify) {
+
+		if(codeClassify == null || codeClassify.getOid() == null){
+			throw new ServiceException("浼犲叆鍙傛暟涓嶈兘涓虹┖锛�");
+		}
+		codeClassify = codeClassifyMapper.selectById(codeClassify.getOid());
+
+		R result = checkIsCanDeleteForDO(codeClassify);
+
+		//鍏堢畝绉版槸鍚︽湁鍏宠仈妯℃澘锛屾湁妯℃澘瑕佸厛鍒犻櫎
+		Map<String,Object> condition = new HashMap<>(2);
+		condition.put("codeClassifyOid",codeClassify.getOid());
+		List<CodeClstemplateEntity> codeClstemplateEntities = codeClstemplateMapper.selectByMap(condition);
+//		VciQueryWrapperForDO queryWrapper = new VciQueryWrapperForDO(CodeClassifyTemplateDO.class);
+//		queryWrapper.addQueryMap("codeClassifyOid",codeClassifyDTO.getOid());
+//		List<CodeClassifyTemplateDO> codeClassifyTemplateDOListHaveTemplate =  codeClassifyTemplateMapper.selectByWrapper(queryWrapper);
+		if(codeClstemplateEntities.size()>0){
+			return R.fail("鍒嗙被鍏宠仈妯℃澘锛岃鍏堝垹闄�!");
+		}
+
+		//澶勭悊鏁版嵁闆嗘垚閫昏緫,鎴愬姛鍚庢墽琛岄泦鎴愮涓�姝�,鍒嗙被鏁版嵁鐗规畩澶勭悊銆�
+		//1銆佹煡璇㈣鍒犻櫎鐨勭埗绫绘暟鎹�
+		List<CodeClassify> deletes = new ArrayList<CodeClassify>();
+		deletes.add(codeClassify);
+
+		if(result.isSuccess()) {
+			//鎵句笅绾х殑锛岃繖涓槸鍙互鍒犻櫎鐨勬椂鍊�
+			Map<String,String> childrenOids = codeClassifyMapper.selectAllLevelChildOid(codeClassify.getOid().trim());
+			if (!CollectionUtils.isEmpty(childrenOids)) {
+				Collection<Collection<String>> childrenCollections = VciBaseUtil.switchCollectionForOracleIn(childrenOids.keySet());
+				for(Collection<String> s : childrenCollections){
+
+					//澶勭悊鏁版嵁闆嗘垚閫昏緫,鎴愬姛鍚庢墽琛岄泦鎴愮涓�姝�,鍒嗙被鏁版嵁鐗规畩澶勭悊銆�
+					//2銆佹煡璇㈣鍒犻櫎鐨勫瓙绫绘暟鎹�
+					List<CodeClassify>  codeClassifyDOList = codeClassifyMapper.selectBatchIds(s);
+					deletes.addAll(codeClassifyDOList);
+					codeClassifyMapper.deleteBatchIds(s);
+				}
+
+			}
+		}else{
+			return result;
+		}
+
+		//鎵ц鍒犻櫎鎿嶄綔
+		int deleteCount = codeClassifyMapper.deleteById(codeClassify.getOid());
+
+		//澶勭悊鏁版嵁闆嗘垚閫昏緫,鎴愬姛鍚庢墽琛岄泦鎴愮涓�姝�
+		for (CodeClassify codeClassifyTemp:deletes){
+			//codeDuckingServiceI.insertCache1(CACHE_TYPE_CLASSIFY_DELETE,FRAMEWORK_DATA_DISABLED,DOCKING_DEFAULT_CLASSIFY, DOCKING_DEFAULT_CLASSIFYOID, codeClassifyDO1.getOid(), DateUtils.addHours(new Date(),1));//杩欓噷鏄綋鍓嶆椂闂�
+
+			//瀛樺偍瑕佸垹闄ょ殑鏁版嵁
+//			CacheUtil.put();
+			CacheUtil.put("ubcs:code", "bean:id:", codeClassifyTemp.getOid(), codeClassifyTemp);
+//			codeDuckingServiceI.cacheDeleteData(codeClassifyTemp.getOid(), codeClassifyTemp);
+		}
+		return R.data(deleteCount>0);
+//		return null;
+	}
+
+	/**
+	 * 鍚敤銆佸仠鐢�
+	 * @param oid 涓婚敭
+	 * @param lcStatus 鐘舵��
+	 * @return 鎵ц缁撴灉
+	 */
+	@Override
+	public R updateLcStatus(String oid, String lcStatus){
+
+		//鏌ヨ淇敼鍓峵s
+		CodeClassify codeClassify = codeClassifyMapper.selectById(oid);//涓昏鏄负浜嗘煡璇s
+		codeClassify.setLcStatus(lcStatus);
+		codeClassify.setTs(new Date());
+		codeClassify.setLastModifyTime(new Date());
+		codeClassify.setLastModifier(AuthUtil.getUser().getUserName());
+		//鍚敤銆佸仠鐢�
+//		int u = codeClassifyMapper.updateLcStatus(oid,lcStatus);
+		int count = codeClassifyMapper.updateById(codeClassify);
+//        //澶勭悊鏁版嵁闆嗘垚閫昏緫,鎴愬姛鍚庢墽琛岄泦鎴愮涓�姝�,鍒嗙被鏁版嵁鐗规畩澶勭悊銆�
+//        if(u!=0) {
+//            codeDuckingServiceI.insertCache1(lcStatus,lcStatus,DOCKING_DEFAULT_CLASSIFY, DOCKING_DEFAULT_CLASSIFYOID, oid, codeClassifyDO_old.getTs());
+//        }
+		return R.data(SqlHelper.retBool(count));
+	}
+
+	/**
+	 * 涓婚敭鎵归噺鑾峰彇涓婚搴撳垎绫�
+	 * @param oidCollections 涓婚敭闆嗗悎锛屼絾鏄彈鎬ц兘褰卞搷锛屽缓璁竴娆℃煡璇笉瓒呰繃10000涓�
+	 * @return 涓婚搴撳垎绫绘樉绀哄璞�
+	 */
+	@Override
+	public Collection<CodeClassifyVO> listCodeClassifyByOids(Collection<String> oidCollections) {
+		VciBaseUtil.alertNotNull(oidCollections,"鏁版嵁瀵硅薄涓婚敭闆嗗悎");
+		List<CodeClassify> codeClassifyDOList = listCodeClassifyDOByOidCollections(oidCollections);
+		return codeClassifyDO2VOs(codeClassifyDOList);
+	}
+
+
+	/**
+	 * 浣跨敤涓婚敭闆嗗悎鏌ヨ鏁版嵁瀵硅薄
+	 * @param oidCollections 涓婚敭鐨勯泦鍚�
+	 * @return 鏁版嵁瀵硅薄鍒楄〃
+	 */
+	private List<CodeClassify> listCodeClassifyDOByOidCollections(Collection<String> oidCollections){
+		List<CodeClassify> codeClassifyList = new ArrayList<CodeClassify>();
+		if(!CollectionUtils.isEmpty(oidCollections)){
+			Collection<Collection<String>> oidCollectionsList = VciBaseUtil.switchCollectionForOracleIn(oidCollections);
+			for(Collection<String> oids: oidCollectionsList){
+				List<CodeClassify> tempDOList =  codeClassifyMapper.selectBatchIds(oids);
+				if(!CollectionUtils.isEmpty(tempDOList)){
+					codeClassifyList.addAll(tempDOList);
+				}
+			}
+		}
+		return  codeClassifyList;
+	}
+
+
+	/**
+	 * 鎵归噺鏁版嵁瀵硅薄杞崲涓烘樉绀哄璞�
+	 * @param codeClassifys 鏁版嵁瀵硅薄鍒楄〃
+	 * @return 鏄剧ず瀵硅薄
+	 */
+	@Override
+	public List<CodeClassifyVO> codeClassifyDO2VOs(Collection<CodeClassify>  codeClassifys) {
+		List<CodeClassifyVO> voList = new ArrayList<CodeClassifyVO>();
+		if(!CollectionUtils.isEmpty(codeClassifys)){
+			for(CodeClassify s: codeClassifys){
+				CodeClassifyVO vo =  codeClassifyDO2VO(s);
+				if(vo != null){
+					voList.add(vo);
+				}
+			}
+		}
+		return voList;
+	}
+
+	/**
+	 * 鏁版嵁瀵硅薄杞崲涓烘樉绀哄璞�
+	 * @param  codeClassify 鏁版嵁瀵硅薄
+	 * @return 鏄剧ず瀵硅薄
+	 */
+	@Override
+	public  CodeClassifyVO codeClassifyDO2VO(CodeClassify codeClassify) {
+		CodeClassifyVO vo = new CodeClassifyVO();
+		if(codeClassify != null){
+			BeanUtilForVCI.copyPropertiesIgnoreCase(codeClassify,vo);
+			//濡傛灉鏈塴cstatus鐨勭被鐨勮瘽
+			vo.setLcStatusText(FrameworkDataLCStatus.getTextByValue(vo.getLcStatus()));
+		}
+		return vo;
+	}
+
+	/**
+	 * 鍙傜収鏍� 涓婚搴撳垎绫�
+	 * @param treeQueryObject 鏍戝舰鏌ヨ瀵硅薄
+	 * @return 涓婚搴撳垎绫绘樉绀烘爲
+	 */
+	@Override
+	public List<Tree> referTree(TreeQueryObject treeQueryObject) {
+		if(treeQueryObject == null){
+			treeQueryObject = new TreeQueryObject();
+		}
+		if(treeQueryObject.getConditionMap() == null){
+			treeQueryObject.setConditionMap(new HashMap<>());
+		}
+		if(treeQueryObject.getConditionMap().containsKey(LC_STATUS)) {
+			treeQueryObject.getConditionMap().remove(LC_STATUS);
+		}
+		if(treeQueryObject.getExtandParamsMap() ==null || !treeQueryObject.getExtandParamsMap().containsKey(REFER_SHOW_DISABLED_QUERY_KEY)) {
+		}
+		treeQueryObject.getConditionMap().put(LC_STATUS, FRAMEWORK_DATA_ENABLED);
+		return treeCodeClassify(treeQueryObject);
+	}
+
+	/**
+	 * 鏌ヨ涓婚搴撳垎绫� 鏍�
+	 * @param treeQueryObject 鏍戞煡璇㈠璞�
+	 * @return 涓婚搴撳垎绫� 鏄剧ず鏍�
+	 */
+	@Override
+	public List<Tree> treeCodeClassify(TreeQueryObject treeQueryObject) {
+		List<CodeClassify> doList =codeClassifyMapper.selectCodeClassifyVOByTree(treeQueryObject.getParentOid());
+		List<CodeClassifyVO> voList = codeClassifyDO2VOs(doList);
+		TreeWrapperOptions treeWrapperOptions = new TreeWrapperOptions(PARENT_FIELD_NAME.toLowerCase(Locale.ROOT));
+		treeWrapperOptions.copyFromTreeQuery(treeQueryObject);
+		List<Tree> tree= revisionModelUtil.doList2Trees(voList,treeWrapperOptions,(CodeClassifyVO s) ->{
+			//鍙互鍦ㄨ繖閲屽鐞嗘爲鑺傜偣鐨勬樉绀�
+			return s.getId() + " " + s.getName() + (FrameworkDataLCStatus.DISABLED.getValue().equalsIgnoreCase(s
+				.getLcStatus()) ? (" 銆愬仠鐢ㄣ�� ") : "");
+		});
+		Iterator var6 =  tree.listIterator();
+		while(var6.hasNext()){
+			Tree trees = (Tree) var6.next();
+			boolean checkHasChild=codeClassifyMapper.checkHasChild(trees.getOid());
+			if(checkHasChild){
+				trees.setLeaf(false);
+			}else{
+				trees.setLeaf(true);
+			}
+		}
+		return tree;
+	}
+
+
+//	/**
+//	 * 鏍规嵁鏍戝舰鏌ヨ瀵硅薄鏉ユ煡璇㈡暟鎹璞�
+//	 *
+//	 * @param treeQueryObject 鏍戝舰鏌ヨ瀵硅薄
+//	 * @return 鏌ヨ缁撴灉,鏁版嵁瀵硅薄
+//	 */
+//	@Override
+//	public List<CodeClassifyVO> selectCodeClassifyDOByTree(TreeQueryObject treeQueryObject) {
+//		VciQueryWrapperForDO queryWrapperForDO = new VciQueryWrapperForDO(null,CodeClassifyDO.class);
+//		VciParentQueryOption parentQueryOption = new VciParentQueryOption();
+//		parentQueryOption.setParentFieldName(PARENT_FIELD_NAME);
+//		queryWrapperForDO.parentQueryChild(treeQueryObject,parentQueryOption);
+//		if(StringUtils.isBlank(treeQueryObject.getSort())) {
+//			PageHelper pageHelper = new PageHelper(-1);
+//			pageHelper.addDefaultAsc("id");
+//			queryWrapperForDO.setPageHelper(pageHelper);
+//		}
+//		return codeClassifyMapper.selectByWrapper(queryWrapperForDO);
+//	}
+
+	/**
+	 * 瀵煎嚭鍒嗙被
+	 *
+	 * @param oid 鍒嗙被涓婚敭
+	 * @return excel鏂囦欢璺緞
+	 */
+	@Override
+	public String exportClassify(String oid) {
+		VciBaseUtil.alertNotNull(oid,"鍒嗙被鐨勪富閿�");
+		CodeClassify codeClassify = codeClassifyMapper.selectById(oid);
+		codeClassify.setDataLevel(0);
+		codeClassify.setPath(codeClassify.getId());
+		List<CodeClassifyVO> codeClassifyVOS = listChildrenClassify(oid, true, "id", false);
+		if(codeClassifyVOS ==null){
+			codeClassifyVOS = new ArrayList<>();
+		}
+		CodeClassifyVO codeClassifyVO = new CodeClassifyVO();
+		BeanUtils.copyProperties(codeClassify,codeClassifyVO);
+		codeClassifyVOS.add(codeClassifyVO);
+
+		//鏌ヨ涓�涓嬭鍒欑殑缂栧彿锛屽拰鍏抽敭灞炴�ч噸澶嶈鍒�
+		List<String> codeRuleOids = codeClassifyVOS.stream().filter(s -> StringUtils.isNotBlank(s.getCoderuleoid())).map(CodeClassifyVO::getCoderuleoid).collect(Collectors.toList());
+		Map<String, CodeRuleVO> ruleVOMap = new HashMap<>();
+		if(!CollectionUtils.isEmpty(codeRuleOids)){
+			VciBaseUtil.switchCollectionForOracleIn(codeRuleOids).stream().forEach(ruleOids->{
+//				Collection<CodeRuleVO> ruleVOS = codeRuleService.listCodeRuleByOids(ruleOids);
+				Collection<CodeRuleVO> ruleVOS = null;
+				ruleVOMap.putAll( Optional.ofNullable(ruleVOS).orElseGet(()->new ArrayList<>()).stream().collect(Collectors.toMap(s->s.getOid(),t->t)));
+			});
+		}
+		//鎵惧叧閿睘鎬ц鍒�
+		List<String> keyRuleOids = codeClassifyVOS.stream().filter(s -> StringUtils.isNotBlank(s.getCodekeyattrrepeatoid())).map(CodeClassifyVO::getCodekeyattrrepeatoid).collect(Collectors.toList());
+		Map<String, CodeKeyAttrRepeatRuleVO> keyRuleVOMap = new HashMap<>();
+		if(!CollectionUtils.isEmpty(keyRuleOids)){
+			VciBaseUtil.switchCollectionForOracleIn(keyRuleOids).stream().forEach(ruleOids->{
+				Collection<CodeKeyAttrRepeatRuleVO> ruleVOS = iCodeKeyattrrepeatService.listCodeKeyAttrRepeatRuleByOids(ruleOids);
+				keyRuleVOMap.putAll( Optional.ofNullable(ruleVOS).orElseGet(()->new ArrayList<>()).stream().collect(Collectors.toMap(s->s.getOid(),t->t)));
+			});
+		}
+		//ok,鍐檈xcel
+		String excelName = LocalFileUtil.getDefaultTempFolder() + File.separator + "瀵煎嚭鍒嗙被.xls";
+		try {
+			new File(excelName).createNewFile();
+		} catch (Throwable e) {
+			throw new VciBaseException(LangBaseUtil.getErrorMsg(e), new String[]{excelName}, e);
+		}
+		List<WriteExcelData> excelDataList = new ArrayList<>();
+		excelDataList.add(new WriteExcelData(0,0,"鍒嗙被缂栧彿"));
+		excelDataList.add(new WriteExcelData(0,1,"鍒嗙被鍚嶇О"));
+		excelDataList.add(new WriteExcelData(0,2,"涓氬姟绫诲瀷缂栧彿"));
+		excelDataList.add(new WriteExcelData(0,3,"涓氬姟绫诲瀷鍚嶇О"));
+		excelDataList.add(new WriteExcelData(0,4,"缂栫爜瑙勫垯缂栧彿"));
+		excelDataList.add(new WriteExcelData(0,5,"缂栫爜瑙勫垯鍚嶇О"));
+		excelDataList.add(new WriteExcelData(0,6,"鏌ラ噸瑙勫垯缂栧彿"));
+		excelDataList.add(new WriteExcelData(0,7,"鏌ラ噸瑙勫垯鍚嶇О"));
+		excelDataList.add(new WriteExcelData(0,8,"鍒嗙被璺緞"));
+		excelDataList.add(new WriteExcelData(0,9,"鐘舵��"));
+		excelDataList.add(new WriteExcelData(0,10,"鍒嗙被灞傜骇"));
+		excelDataList.add(new WriteExcelData(0,11,"鎻忚堪"));
+		for (int i = 0; i < codeClassifyVOS.size(); i++) {
+			CodeClassifyVO vo = codeClassifyVOS.get(i);
+			excelDataList.add(new WriteExcelData(i+1,0,vo.getId()));
+			excelDataList.add(new WriteExcelData(i+1,1,vo.getName()));
+			excelDataList.add(new WriteExcelData(i+1,2,vo.getBtmtypeid()));
+			excelDataList.add(new WriteExcelData(i+1,3,vo.getBtmtypename()));
+			excelDataList.add(new WriteExcelData(i+1,4, StringUtils.isNotBlank(vo.getCoderuleoid())?ruleVOMap.getOrDefault(vo.getCoderuleoid(),new CodeRuleVO()).getId():""));
+			excelDataList.add(new WriteExcelData(i+1,5, StringUtils.isNotBlank(vo.getCoderuleoid())?ruleVOMap.getOrDefault(vo.getCoderuleoid(),new CodeRuleVO()).getName():""));
+			excelDataList.add(new WriteExcelData(i+1,6, StringUtils.isNotBlank(vo.getCodekeyattrrepeatoid())?keyRuleVOMap.getOrDefault(vo.getCodekeyattrrepeatoid(),new CodeKeyAttrRepeatRuleVO()).getId():""));
+			excelDataList.add(new WriteExcelData(i+1,7, StringUtils.isNotBlank(vo.getCodekeyattrrepeatoid())?keyRuleVOMap.getOrDefault(vo.getCodekeyattrrepeatoid(),new CodeKeyAttrRepeatRuleVO()).getName():""));
+			excelDataList.add(new WriteExcelData(i+1,8,vo.getOid().equalsIgnoreCase(codeClassify.getOid())?vo.getPath():codeClassify.getPath() + vo.getPath()));
+			excelDataList.add(new WriteExcelData(i+1,9,FrameworkDataLCStatus.getTextByValue(vo.getLcStatus())));
+			excelDataList.add(new WriteExcelData(i+1,10,vo.getDataLevel()));
+			excelDataList.add(new WriteExcelData(i+1,11,vo.getDescription()));
+		}
+		WriteExcelOption excelOption = new WriteExcelOption(excelDataList);
+		ExcelUtil.writeDataToFile(excelName, excelOption);
+		return excelName;
+	}
+
+	/**
+	 * 鑾峰彇瀛愮骇鐨勪富棰樺簱鍒嗙被
+	 *
+	 * @param codeClassifyOid 鍒嗙被鐨勪富閿�
+	 * @param allLevel        鏄惁鎵�鏈夌殑灞傜骇
+	 * @param fieldInPath 鍦ㄨ矾寰勪腑鐨勫瓧娈�
+	 * @param enable 鏄惁鍙樉绀哄惎鐢�
+	 * @return 鍒嗙被鐨勬樉绀哄璞�
+	 */
+	@Override
+	public List<CodeClassifyVO> listChildrenClassify(String codeClassifyOid, boolean allLevel, String fieldInPath, boolean enable) {
+		if(allLevel){
+			List<CodeClassify> classifyDOS = codeClassifyMapper.selectAllLevelChildHasPath(codeClassifyOid);
+			if(!CollectionUtils.isEmpty(classifyDOS)){
+				classifyDOS = classifyDOS.stream().filter(s->FRAMEWORK_DATA_ENABLED.equalsIgnoreCase(s.getLcStatus())).collect(Collectors.toList());
+			}
+			return codeClassifyDO2VOs(classifyDOS);
+		}else{
+			//鍙煡璇竴鏉★紝閭ath灏辨病蹇呰鏌ヨ浜�
+			Map<String,Object> conditionMap = new HashMap<>();
+			conditionMap.put("parentcodeclassifyoid",codeClassifyOid);
+			if (enable){
+				conditionMap.put("lcstatus",FRAMEWORK_DATA_ENABLED);
+			}
+			return codeClassifyDO2VOs(codeClassifyMapper.selectByMap(conditionMap));
+		}
+	}
+
+	/**
+	 * 鍒涘缓瀵煎叆妯℃澘
+	 *
+	 * @return excel鏂囦欢璺緞
+	 */
+	@Override
+	public String createImportExcel() {
+		//ok,鍐檈xcel
+		String excelName = LocalFileUtil.getDefaultTempFolder() + File.separator + "鍒嗙被瀵煎叆妯℃澘.xls";
+		try {
+			new File(excelName).createNewFile();
+		} catch (Throwable e) {
+			throw new VciBaseException(LangBaseUtil.getErrorMsg(e), new String[]{excelName}, e);
+		}
+		List<WriteExcelData> excelDataList = new ArrayList<>();
+		WriteExcelData excelData = new WriteExcelData(0, 0, "鍒嗙被缂栧彿");
+		excelData.setFontColor(String.valueOf(HSSFColor.HSSFColorPredefined.RED.getIndex()));
+		excelDataList.add(excelData);
+		WriteExcelData excelData1 = new WriteExcelData(0, 1, "鍒嗙被鍚嶇О");
+		excelData1.setFontColor(String.valueOf(HSSFColor.HSSFColorPredefined.RED.getIndex()));
+		excelDataList.add(excelData1);
+		excelDataList.add(new WriteExcelData(0,2,"涓氬姟绫诲瀷缂栧彿"));
+		excelDataList.add(new WriteExcelData(0,3,"缂栫爜瑙勫垯缂栧彿"));
+		excelDataList.add(new WriteExcelData(0,4,"鏌ラ噸瑙勫垯缂栧彿"));
+		WriteExcelData excelData2 = new WriteExcelData(0, 5, "鍒嗙被璺緞");
+		excelData2.setFontColor(String.valueOf(HSSFColor.HSSFColorPredefined.RED.getIndex()));
+		excelDataList.add(excelData2);
+		excelDataList.add(new WriteExcelData(0,6,"鐘舵��"));
+		WriteExcelOption excelOption = new WriteExcelOption(excelDataList);
+		ExcelUtil.writeDataToFile(excelName, excelOption);
+		return excelName;
+	}
+
+
+	/**
+	 * 瀵煎叆鍒嗙被
+	 *
+	 * @param file1 鏂囦欢鐨勪俊鎭�
+	 * @return 閿欒鏂囦欢鐨勫湴鍧�
+	 */
+	@Override
+	public void importClassify(File file1) {
+		VciBaseUtil.alertNotNull(file1,"excel鏂囦欢");
+		if(!file1.exists()){
+			throw new VciBaseException("瀵煎叆鐨別xcel鏂囦欢涓嶅瓨鍦�,{0}",new String[]{file1.getPath()});
+		}
+		ReadExcelOption excelOption = new ReadExcelOption();
+		List<CodeClassifyPO> poList = null;
+		try{
+			poList = ExcelUtil.readDataObjectFromExcel(file1,CodeClassifyPO.class,excelOption,(value,po,fieldName)->{
+				po.setLcStatus(FrameworkDataLCStatus.getValueByText(po.getLcStatusText()));
+				if(StringUtils.isBlank(po.getLcStatusText())){
+					po.setLcStatus(FrameworkDataLCStatus.ENABLED.getValue());
+				}
+			});
+		}catch (Exception e){
+			if(logger.isErrorEnabled()){
+				logger.error("璇诲彇excel鍐呭鐨勬椂鍊欏嚭鐜颁簡閿欒",e);
+			}
+			throw new VciBaseException(LangBaseUtil.getErrorMsg(e),new String[]{},e);
+		}
+		//鍘婚櫎鏁磋閮芥槸绌虹殑鎯呭喌
+
+		if(CollectionUtils.isEmpty(poList)){
+			throw new VciBaseException(ExcelLangCodeConstant.IMPORT_CONTENT_NULL,new String[]{});
+		}
+
+		poList = poList.stream().filter(s->!(StringUtils.isBlank(s.getId()) && StringUtils.isBlank(s.getName()) && StringUtils.isBlank(s.getPath()))).collect(Collectors.toList());
+
+		List<CodeClassify> codeClassify = new ArrayList<>();
+		//鐪嬬湅璺緞鏄惁鏈夐噸澶�
+		Map<String/**璺緞**/, Long/**涓暟**/> pathCountMap = poList.stream().filter(s->StringUtils.isNotBlank(s.getPath())).collect(Collectors.groupingBy(s -> s.getPath(), Collectors.counting()));
+		List<String> repeatPaths = Optional.ofNullable(pathCountMap).orElse(new HashMap<>()).entrySet().stream().filter(entry -> entry.getValue() > 1).map(entry -> entry.getKey()).collect(Collectors.toList());
+		if(!CollectionUtils.isEmpty(repeatPaths)){
+			//鏈夐噸澶嶇殑鍐呭
+			List<String> rowIndexList = new ArrayList<>();
+			poList.stream().forEach(po->{
+				if(repeatPaths.contains(po.getPath())){
+					rowIndexList.add(po.getRowIndex());
+				}
+			});
+			throw new VciBaseException("璺緞鏈夐噸澶�,{0}",new String[]{rowIndexList.stream().collect(Collectors.joining(","))});
+		}
+		//缂栧彿鑾峰彇涓氬姟绫诲瀷鏈嶅姟
+		List<String> ruleOids = poList.stream().filter(
+				s -> StringUtils.isNotBlank(s.getCodeRuleId()))
+			.map(CodeClassifyPO::getCodeRuleId)
+			.collect(Collectors.toList());
+		Map<String, CodeRuleVO> ruleVOMap = Optional.ofNullable(ruleOids.size()==0 ? null:codeRuleService.listCodeRuleByOids(ruleOids)
+		).orElse(new ArrayList<>()).stream().collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t,(o1,o2)->o2));
+
+		List<String> keyOids = poList.stream().filter(s -> StringUtils.isNotBlank(s.getKeyRepeatRuleId()))
+			.map(CodeClassifyPO::getKeyRepeatRuleId).collect(Collectors.toList());
+		Map<String,CodeKeyAttrRepeatRuleVO> keyRuleVOMap =Optional.ofNullable(keyOids.size()==0 ? null: iCodeKeyattrrepeatService.listCodeKeyAttrRepeatRuleByOids(keyOids)
+		).orElse(new ArrayList<>()).stream().collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t,(o1,o2)->o2));
+
+		List<String> btmOids = poList.stream().filter(s -> StringUtils.isNotBlank(s.getKeyRepeatRuleId()))
+			.map(CodeClassifyPO::getBtmTypeId).collect(Collectors.toList());
+		Map<String, CodeOsbtmtypeEntity> btmVOMap = Optional.ofNullable(btmOids.size()==0 ? null: codeOsbtmtypeMapper.selectBatchIds(btmOids)
+		).orElse(new ArrayList<>()).stream().collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t,(o1,o2)->o2));
+//		Map<String, CodeOsbtmtypeVO> btmVOMap = null;
+		Map<String/**璺緞**/,String/**涓婚敭**/> oidPathMap = new HashMap<>();
+
+		//鎴戜滑闇�瑕佹煡璇㈡墍鏈夊凡缁忓瓨鍦ㄧ殑鍒嗙被锛屼富瑕佹槸璺緞锛岀敤鏉ュ垽鏂垎绫荤殑鏁版嵁
+		List<CodeClassify> existClassifyDOs = codeClassifyMapper.selectAllLevelChildHasPath("");
+		Map<String/**璺緞**/, CodeClassify/**宸茬粡瀛樺湪鐨勬暟鎹�**/> pathDOMap = Optional.ofNullable(existClassifyDOs).orElse(new ArrayList<>()).stream().collect(Collectors.toMap(s -> {
+			String path = s.getPath();
+			if(StringUtils.isNotBlank(path) && path.startsWith("#")){
+				return path.substring(1);
+			}
+			return path;
+		}, t -> t));
+		poList.stream().forEach(po->{
+			CodeClassify classify = new CodeClassify();
+			VciBaseUtil.alertNotNull(po.getId(),"鍒嗙被缂栧彿",po.getName(),"鍒嗙被鍚嶇О",po.getPath(),"鍒嗙被璺緞");
+			if(StringUtils.isNotBlank(po.getBtmTypeId()) && !btmVOMap.containsKey(po.getBtmTypeId().toLowerCase(Locale.ROOT))){
+				throw new VciBaseException("绗瑊0}琛岀殑涓氬姟绫诲瀷{1}鍦ㄧ郴缁熶腑涓嶅瓨鍦�",new String[]{String.valueOf(VciBaseUtil.getInt(po.getRowIndex())+1),po.getBtmTypeId()});
+			}
+			if(StringUtils.isNotBlank(po.getCodeRuleId()) && !ruleVOMap.containsKey(po.getCodeRuleId().toLowerCase(Locale.ROOT))){
+				throw new VciBaseException("绗瑊0}琛岀殑缂栫爜瑙勫垯{1}鍦ㄧ郴缁熶腑涓嶅瓨鍦�",new String[]{String.valueOf(po.getRowIndex()+1),po.getCodeRuleId()});
+			}
+			if(StringUtils.isNotBlank(po.getKeyRepeatRuleId()) && !keyRuleVOMap.containsKey(po.getKeyRepeatRuleId().toLowerCase(Locale.ROOT))){
+				throw new VciBaseException("绗瑊0}琛岀殑鍏抽敭灞炴�ф煡閲嶈鍒檣1}鍦ㄧ郴缁熶腑涓嶅瓨鍦�",new String[]{String.valueOf(po.getRowIndex()+1),po.getKeyRepeatRuleId()});
+			}
+			classify.setOid(VciBaseUtil.getPk());
+			classify.setId(po.getId());
+			classify.setName(po.getName());
+			classify.setDescription(po.getDescription());
+			oidPathMap.put(po.getPath(),classify.getOid());
+			if(StringUtils.isNotBlank(po.getBtmTypeId())){
+				CodeOsbtmtypeVO typeVO = (CodeOsbtmtypeVO)btmVOMap.get(po.getBtmTypeId().toLowerCase(Locale.ROOT));
+				classify.setBtmTypeId(typeVO.getId());
+				classify.setBtmTypeName(typeVO.getName());
+			}
+			if(StringUtils.isNotBlank(po.getCodeRuleId())){
+				CodeRuleVO codeRuleVO = ruleVOMap.get(po.getCodeRuleId().toLowerCase(Locale.ROOT));
+				classify.setCodeRuleOid(codeRuleVO.getOid());
+			}
+			if(StringUtils.isNotBlank(po.getKeyRepeatRuleId())){
+				CodeKeyAttrRepeatRuleVO repeatRuleVO = keyRuleVOMap.get(po.getKeyRepeatRuleId());
+				classify.setCodeKeyAttrRepeatOid(repeatRuleVO.getOid());
+			}
+			classify.setLcStatus(po.getLcStatus());
+			classify.setPath(po.getPath());
+			codeClassify.add(classify);
+		});
+		//瑕佺湅瀛樺湪鐨勶紝淇敼璺緞瀵瑰簲鐨勪富閿�
+		Map<String/**璺緞**/,String/**涓婚敭**/> catchedOidPathMap = new HashMap<>();
+		if(!CollectionUtils.isEmpty(oidPathMap)){
+			oidPathMap.forEach((path,oid)->{
+				if(pathDOMap.containsKey(path)){
+					//璇存槑瀛樺湪
+					catchedOidPathMap.put(path,pathDOMap.get(path).getOid());
+				}else{
+					catchedOidPathMap.put(path,oid);
+				}
+			});
+		}
+		List<CodeClassify> addClassifyDOList = new ArrayList<>();
+		List<CodeClassify> editClassifyDOList = new ArrayList<>();
+		codeClassify.stream().forEach(classifyDO->{
+
+			//瑕佺湅涓婄骇鏄笉鏄瓨鍦ㄥ摝
+			String parentPath = classifyDO.getPath();
+			if(parentPath.contains("#")) {
+				parentPath = parentPath.substring(0, parentPath.lastIndexOf("#"));
+			}
+			if((!catchedOidPathMap.containsKey(parentPath) && !pathDOMap.containsKey(parentPath) )&& !classifyDO.getPath().equalsIgnoreCase(classifyDO.getId())){
+				throw new VciBaseException("鍒嗙被缂栧彿[{0}],鍒嗙被鍚嶇О[{1}]锛岃矾寰勪负[{2}]鐨勪笂绾у垎绫诲湪绯荤粺涓紝鍦ㄦ湰娆″鍏ョ殑鏁版嵁鍜岀郴缁熶腑鍧囨病鏈夋壘鍒�",new String[]{classifyDO.getId(),classifyDO.getName(),classifyDO.getPath()});
+			}
+			if (!classifyDO.getPath().equalsIgnoreCase(classifyDO.getId())){
+				//涓嶆槸椤剁骇鐨勬椂鍊欙紝瑕佽缃笂绾х殑涓婚敭
+
+				classifyDO.setParentCodeClassifyOid(catchedOidPathMap.containsKey(parentPath)?catchedOidPathMap.get(parentPath):pathDOMap.get(parentPath).getOid());
+			}
+			if(classifyDO.getPath().equalsIgnoreCase(classifyDO.getId()) && StringUtils.isBlank(classifyDO.getBtmTypeId())){
+				throw new VciBaseException("鍒嗙被缂栧彿[{0}],鍒嗙被鍚嶇О[{1}]锛屾槸椤跺眰鍒嗙被锛岄渶瑕佽缃笟鍔＄被鍨嬬紪鍙�",new String[]{classifyDO.getId(),classifyDO.getName()});
+			}
+			if(pathDOMap.containsKey(classifyDO.getPath())){
+				//瀛樺湪锛岄渶瑕佷慨鏀瑰璞�
+				classifyDO.setOid(catchedOidPathMap.get(classifyDO.getPath()));
+				CodeClassify classifyDOInDB = pathDOMap.get(classifyDO.getPath());
+				classifyDOInDB.setOid(classifyDO.getOid());
+				classifyDOInDB.setId(classifyDO.getId());
+				classifyDOInDB.setName(classifyDO.getName());
+				classifyDOInDB.setDescription(classifyDO.getDescription());
+				classifyDOInDB.setBtmTypeId(classifyDO.getBtmTypeId());
+				classifyDOInDB.setBtmTypeName(classifyDO.getBtmTypeName());
+				classifyDOInDB.setCodeRuleOid(classifyDO.getCodeRuleOid());
+				classifyDOInDB.setCodeRuleOidName(classifyDO.getCodeRuleOidName());
+				classifyDOInDB.setParentCodeClassifyOid(classifyDO.getParentCodeClassifyOid());
+				classifyDOInDB.setCodeKeyAttrRepeatOid(classifyDO.getCodeKeyAttrRepeatOid());
+				classifyDOInDB.setCodeKeyAttrRepeatOidName(classifyDO.getCodeKeyAttrRepeatOidName());
+				if(classifyDOInDB.getOrderNum() == null){
+					classifyDOInDB.setOrderNum(0);
+				}
+				editClassifyDOList.add(classifyDOInDB);
+			}else{
+				//鏄柊鐨勶紝鐩存帴娣诲姞灏辫浜�
+				//鍒ゆ柇鍙锋�庝箞澶勭悊?
+				classifyDO.setOrderNum(0);
+				addClassifyDOList.add(classifyDO);
+			}
+		});
+		if(!CollectionUtils.isEmpty(editClassifyDOList)){
+			VciBaseUtil.switchCollectionForOracleIn(editClassifyDOList).stream().forEach(
+//				classifyDOs->{codeClassifyMapper..updateById(classifyDOs.stream().collect(Collectors.toList()));
+				classifyDos->{
+					for (CodeClassify classifyDo : classifyDos) {
+						codeClassifyMapper.updateById(classifyDo);
+					}
+//				}
+				});
+		}
+		if(!CollectionUtils.isEmpty(addClassifyDOList)){
+//			revisionModelUtil.wrapperForBatchAdd(addClassifyDOList);
+			VciBaseUtil.switchCollectionForOracleIn(addClassifyDOList).stream().forEach(classifyDOs->{
+				for (CodeClassify classifyDO : classifyDOs) {
+					classifyDO.setCreateTime(new Date());
+					classifyDO.setTs(new Date());
+					classifyDO.setBtmname("codeclassify");
+					classifyDO.setLcStatus("Enabled");
+					classifyDO.setOwner(AuthUtil.getUser().getUserName());
+					classifyDO.setCreator(AuthUtil.getUser().getUserName());
+					classifyDO.setLastModifier(AuthUtil.getUser().getUserName());
+					classifyDO.setLastModifyTime(new Date());
+					codeClassifyMapper.insert(classifyDO);
+				}
+//				codeClassifyMapper.batchInsert(classifyDOs.stream().collect(Collectors.toList()));
+			});
+		}
+
+	}
+
+	/**
+	 * 鑾峰彇鍒嗙被鍏宠仈鐨勫睘鎬�
+	 *
+	 * @param baseQueryObject 鏌ヨ瀵硅薄锛屽繀椤绘湁codeClassifyOid锛屾敮鎸乮d鍜宯ame涓ょ鏌ヨ鏉′欢
+	 * @return 灞炴�х殑淇℃伅锛屽寘鍚粯璁ょ殑灞炴��
+	 */
+	@Override
+	public DataGrid<CodeOsattributeVO> listClassifyLinkAttr(BaseQueryObject baseQueryObject) {
+		if(baseQueryObject == null){
+			baseQueryObject = new BaseQueryObject();
+		}
+		if(baseQueryObject.getConditionMap() == null){
+			baseQueryObject.setConditionMap(new HashMap<>());
+		}
+		String classifyOid = baseQueryObject.getConditionMap().getOrDefault("codeClassifyOid","");
+		String id = baseQueryObject.getConditionMap().getOrDefault("id","");
+		String name = baseQueryObject.getConditionMap().getOrDefault("name","");
+		if(StringUtils.isBlank(classifyOid)){
+			return new DataGrid<>();
+		}
+		CodeClassifyVO topClassifyVO = getTopClassifyVO(classifyOid);
+		if(topClassifyVO == null || StringUtils.isBlank(topClassifyVO.getBtmtypeid())){
+			return new DataGrid<>();
+		}
+
+		Map<String,Object> condition = new HashMap<>(1);
+		condition.put("pkbtmtype",topClassifyVO.getBtmtypeid());
+
+		List<CodeOsbtmtypeattributeEntity> unDefaultAttributes = codeOsbtmtypeattributeMapper.selectByMap(condition);
+//		List<OsBtmTypeAttributeVO> unDefaultAttributes = btmService. (topClassifyVO.getBtmtypeid());
+		List<CodeOsattributeVO> attributeVOS = new ArrayList<>();
+		if(!CollectionUtils.isEmpty(unDefaultAttributes)){
+			unDefaultAttributes.stream().forEach(attr->{
+				CodeOsattributeVO attributeVO = new CodeOsattributeVO();
+				BeanUtils.copyProperties(attr,attributeVO);
+				attributeVO.setAttributedatatype(attr.getAttrdatatype());
+				attributeVO.setAttrlength(Short.valueOf(attr.getAttributelength()));
+				attributeVO.setBtmtypeid(attr.getReferbtmtypeid());
+				attributeVO.setBtmtypename(attr.getReferbtmtypename());
+				boolean add = true;
+				if(StringUtils.isNotBlank(id) && !attributeVO.getId().contains(id.replace("*",""))){
+					add = false;
+				}
+				if(StringUtils.isNotBlank(name) && !attributeVO.getId().contains(name.replace("*",""))){
+					add = false;
+				}
+				if(add){
+					attributeVOS.add(attributeVO);
+				}
+			});
+		}
+//		if(!CollectionUtils.isEmpty(attributeService.getDefaultAttributeVOs())){
+//			attributeService.getDefaultAttributeVOs().stream().forEach(attr->{
+//				boolean add = true;
+//				if(StringUtils.isNotBlank(id) && !attr.getId().contains(id.replace("*",""))){
+//					add = false;
+//				}
+//				if(StringUtils.isNotBlank(name) && !attr.getId().contains(name.replace("*",""))){
+//					add = false;
+//				}
+//				if(add){
+//					attributeVOS.add(attr);
+//				}
+//			});
+//		}
+		DataGrid<CodeOsattributeVO> dataGrid = new DataGrid<>();
+		dataGrid.setData(attributeVOS);
+		dataGrid.setTotal(attributeVOS.size());
+		return dataGrid;
+	}
+
+	/**
+	 * 鑾峰彇褰撳墠鍒嗙被鐨勯《灞傚垎绫�
+	 *
+	 * @param codeClassifyOid 鍒嗙被鐨勪富閿�
+	 * @return 椤跺眰鍒嗙被鐨勪俊鎭�
+	 */
+	@Override
+	public CodeClassifyVO getTopClassifyVO(String codeClassifyOid) {
+		VciBaseUtil.alertNotNull(codeClassifyOid,"鍒嗙被鐨勪富閿�");
+
+//		List<Map<String,Object>> classifyDOS = codeClassifyMapper.selectAllLevelParentByOid(codeClassifyOid);
+		List<CodeClassify> classifyDOS = selectAllLevelParentByOid(codeClassifyOid);
+
+		if(!CollectionUtils.isEmpty(classifyDOS)){
+			CodeClassify classifyDO = classifyDOS.stream().filter(s -> StringUtils.isBlank(s.getParentCodeClassifyOid())).findFirst().orElseGet(() -> null);
+			if(classifyDO!=null){
+				return codeClassifyDO2VO(classifyDO);
+			}
+		}
+		return null;
+	}
+
+	/**
+	 * 鑾峰彇褰撳墠鍒嗙被鐨勬墍鏈変笂绾у垎绫伙紙鍚湰娆℃煡璇㈠眰绾у彿锛�
+	 * @param oid 涓婚敭
+	 * @return 鎵�鏈夌殑涓婄骇
+	 */
+	@Override
+	public List<CodeClassify> selectAllLevelParentByOid(String oid){
+		// String sql = "select oid,level from " + VciBaseUtil.getTableName(MdmBtmTypeConstant.CODE_CLASSIFY) + " start with oid= :oid connect by prior PARENTCODECLASSIFYOID = oid ";
+		// Map< String,String> conditionMap = new HashMap< String,String>();
+		// conditionMap.put("oid",oid);
+
+		List<Map<String,Object>> cbos = codeClassifyMapper.selectAllLevelParentByOid(oid);
+		Map<String,String> oidLevelMap = new HashMap<>();
+		Optional.ofNullable(cbos).orElseGet(()->new ArrayList<>()).stream().forEach(cbo->{
+			oidLevelMap.put(cbo.get("OID").toString(),cbo.get("LEVEL").toString());
+		});
+		if(CollectionUtils.isEmpty(oidLevelMap)){
+			return new ArrayList<>();
+		}
+
+		//浣跨敤涓婚敭鏌ヨ涓�涓�
+		List<CodeClassify> classifyDOS = codeClassifyMapper.selectBatchIds(oidLevelMap.keySet());
+		if(!CollectionUtils.isEmpty(classifyDOS)){
+			classifyDOS.stream().forEach(classifyDO->{
+				classifyDO.setDataLevel(VciBaseUtil.getInt(oidLevelMap.getOrDefault(classifyDO.getOid(),"0")));
+			});
+		}
+		return classifyDOS;
+	}
+
+	/**
+	 * 浣跨敤缂栧彿鐨勮矾寰勮幏鍙栧璞�
+	 *
+	 * @param idPath 缂栧彿鐨勮矾寰勶紝涓�瀹氳浠庢渶椤跺眰鑺傜偣寮�濮嬶紝鏍煎紡涓簒xx/yyy/zz 杩欐牱
+	 * @return 鍒嗙被鐨勬樉绀哄璞�
+	 */
+	@Override
+	public CodeClassifyVO getObjectByIdPath(String idPath) {
+		List<Map<String, Object>> idPathValues = codeClassifyMapper.selectByFieldPath("/" + idPath);
+		CodeClassify classifyDO = null;
+		if (idPathValues != null){
+			classifyDO = codeClassifyMapper.selectById(idPathValues.get(0).get("oid").toString());
+		}
+		return codeClassifyDO2VO(classifyDO);
+	}
+
+	/**
+	 * 涓婚搴撶殑鏍�
+	 *
+	 * @param treeQueryObject 鏍戝舰鏌ヨ瀵硅薄
+	 * @return 涓婚搴撴樉绀烘爲
+	 */
+	@Override
+	public List<Tree> treeTopCodeClassify(TreeQueryObject treeQueryObject) {
+		if(treeQueryObject == null){
+			treeQueryObject = new TreeQueryObject();
+		}
+		if(treeQueryObject.getConditionMap() == null){
+			treeQueryObject.setConditionMap(new HashMap<>());
+		}
+		treeQueryObject.getConditionMap().put(PARENT_FIELD_NAME, "=null");
+		return treeCodeClassify(treeQueryObject);
+	}
+
+}

--
Gitblit v1.9.3