Source/UBCS/ubcs-service/ubcs-code/src/main/java/com/vci/ubcs/code/service/impl/CodeClassifyServiceImpl.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,1559 @@
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.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.baomidou.mybatisplus.extension.toolkit.SqlHelper;
import com.sun.org.apache.bcel.internal.generic.NEW;
import com.vci.ubcs.code.bo.CodeClassifyFullInfoBO;
import com.vci.ubcs.code.entity.*;
import com.vci.ubcs.code.enumpack.FrameworkDataLCStatus;
import com.vci.ubcs.code.mapper.*;
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.pagemodel.CodeAllCodeVO;
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.omd.cache.EnumCache;
import com.vci.ubcs.omd.enums.EnumEnum;
import com.vci.ubcs.omd.feign.IBtmTypeClient;
import com.vci.ubcs.omd.vo.BtmTypeAttributeVO;
import com.vci.ubcs.omd.feign.IBtmTypeClient;
import com.vci.ubcs.omd.vo.BtmTypeVO;
import com.vci.ubcs.starter.bo.WriteExcelData;
import com.vci.ubcs.starter.exception.VciBaseException;
import com.vci.ubcs.starter.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.model.TreeQueryObject;
import com.vci.ubcs.starter.revision.model.TreeWrapperOptions;
import com.vci.ubcs.starter.revision.service.RevisionModelUtil;
import com.vci.ubcs.starter.util.BladeTreeQueryObject;
import com.vci.ubcs.starter.util.DefaultAttrAssimtUtil;
import com.vci.ubcs.starter.util.LocalFileUtil;
import com.vci.ubcs.starter.util.MdmBtmTypeConstant;
import com.vci.ubcs.starter.web.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 com.vci.ubcs.system.cache.NacosConfigCache;
import com.vci.ubcs.system.dto.ClassifyAuthDTO;
import com.vci.ubcs.system.feign.ISysClient;
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.launch.constant.AppConstant;
import org.springblade.core.log.exception.ServiceException;
import org.springblade.core.mp.support.Condition;
import org.springblade.core.secure.utils.AuthUtil;
import org.springblade.core.tool.api.R;
import org.springblade.core.tool.utils.Func;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils;

import javax.annotation.Resource;
import java.awt.event.ItemEvent;
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 CodeClassifyTemplateMapper codeClassifyTemplateMapper;

   @Resource
   private ICodeRuleService codeRuleService;

   @Resource
   private IBtmTypeClient btmTypeClient;

   @Resource
   private ISysClient sysClient;

   /**
    * æ—¥å¿—
    */
   private Logger logger = LoggerFactory.getLogger(getClass());
   /**
    * å¯¹è±¡çš„操作
    */
   @Resource
   private RevisionModelUtil revisionModelUtil;

   @Resource
   private ICodeKeyAttrRepeatService iCodeKeyattrrepeatService;

   @Resource
   private CodeAllCodeMapper codeAllCodeMapper;

   @Resource
   private CodeSerialValueMapper codeSerialValueMapper;

   @Resource
   private CodeBasicSecMapper codeBasicSecMapper;

   /**
    * ä¸Šçº§èŠ‚点的属性名称
    */
   public static  final String PARENT_FIELD_NAME = "parentCodeClassifyOid";

   /**
    * ä½¿ç”¨æŸ¥è¯¢å°è£…器来查询
    * @param wrapper æŸ¥è¯¢å°è£…器
    * @return æ•°æ®å¯¹è±¡
    */
   @Override
   public List<CodeClassify> selectByWrapper(Wrapper wrapper) {
      return codeClassifyMapper.selectList(wrapper);
   }

   /**
    * æŸ¥è¯¢
    * @param wrapper æŸ¥è¯¢å°è£…器
    * @return
    */
   @Override
   public List<String> select1(Wrapper wrapper) {

      return codeClassifyMapper.selectObjs(wrapper);
   }

   @Override
   public IPage<CodeClassifyVO> selectPlCodeClassifyPage(IPage<CodeClassifyVO> page, CodeClassifyVO plCodeClassify) {
      return page.setRecords(codeClassifyMapper.selectPlCodeClassifyPage(page, plCodeClassify,AuthUtil.getTenantId()
         .equals(
            NacosConfigCache
               .getAdminUserInfo()
               .getTenantId()
         ) ? null:AuthUtil.getTenantId()));
   }

   /**
    * ä¸»é¢˜åº“定义表 æ–°å¢ž
    * @param
    */
   @Override
   @Transactional(rollbackFor = Exception.class)
   public R addSave(CodeClassify codeClassifyEntity) {
      try {
         VciBaseUtil.alertNotNull(codeClassifyEntity.getId(),"主题库编号不能为空！",codeClassifyEntity.getName(),"主题库名称不能为空！");
      }catch (VciBaseException e){
         return R.fail(e.getMessage());
      }
      if(StringUtils.isNotBlank(codeClassifyEntity.getParentCodeClassifyOid()) && StringUtils.isNotBlank(codeClassifyEntity.getBtmTypeId())){
         return R.fail("只有在顶层的主题库分类才能设置业务类型");
      }
      if(StringUtils.isEmpty(codeClassifyEntity.getParentCodeClassifyOid()) && StringUtils.isBlank(codeClassifyEntity.getBtmTypeId())){
         return R.fail("主题库关联的业务类型不能为空！");
      }
      QueryWrapper<CodeClassify> classifyQueryWrapper = new QueryWrapper<>();
      classifyQueryWrapper.eq("parentCodeClassifyOid",codeClassifyEntity.getParentCodeClassifyOid());
      classifyQueryWrapper.eq("id",codeClassifyEntity.getId());
      List<CodeClassify> codeClassifyList = baseMapper.selectList(classifyQueryWrapper);
      if(codeClassifyList.size()!=0){
         return R.fail("当前分类下不允许分类编号重复，请检查！！！");
      }
      if(Func.isNotEmpty(codeClassifyEntity.getParentCodeClassifyOid())){
         CodeClassify codeClassify = baseMapper.selectOne(Wrappers.<CodeClassify>query().lambda().eq(CodeClassify::getOid, codeClassifyEntity.getParentCodeClassifyOid()));
         codeClassifyEntity.setBtmTypeId(codeClassify.getBtmTypeId());
         codeClassifyEntity.setBtmTypeName(codeClassify.getBtmTypeName());
      }
      DefaultAttrAssimtUtil.addDefaultAttrAssimt(codeClassifyEntity, MdmBtmTypeConstant.CODE_CLASSIFY);
      codeClassifyEntity.setLcStatus(FRAMEWORK_DATA_ENABLED);
      boolean resBoolean = SqlHelper.retBool(codeClassifyMapper.insert(codeClassifyEntity));
      if (!resBoolean) {
         return R.status(resBoolean);
      }
      // åˆ†ç±»æ·»åŠ æˆåŠŸï¼Œç»™ç³»ç»Ÿç®¡ç†å‘˜å’Œå½“前角色增加分类权限和数据权限
      ClassifyAuthDTO classifyAuthDTO = new ClassifyAuthDTO();
      classifyAuthDTO.setClassifyId(codeClassifyEntity.getOid());
//      classifyAuthDTO.setClassId(codeClassifyEntity.getId());
      R r = sysClient.saveAddClassifyDefaultAuth(classifyAuthDTO);
      if (!r.isSuccess()) {
         throw new ServiceException("给角色授予默认权限时出现错误，原因："+r.getMsg());
      }
      return R.status(resBoolean);
   }

   /**
    * ä¿®æ”¹ä¸»é¢˜åº“分类
    * @param codeClassifyEntity ä¸»é¢˜åº“分类数据传输对象
    * @return æ‰§è¡Œç»“æžœ
    */
   @Override
   @Transactional(rollbackFor = Exception.class)
   public R editSave(CodeClassify codeClassifyEntity) {
      if(codeClassifyEntity == null || codeClassifyEntity.getOid() == null){
         return R.fail("传入数据不能为空！");
      }
      //检查ts
      CodeClassify detail = codeClassifyMapper.selectById(codeClassifyEntity.getOid());
      if(!detail.getTs().toString().equals(codeClassifyEntity.getTs().toString())){//不是最新的不让改
         return R.fail("当前数据不是最新，请刷新后再修改！");
      }

      if(StringUtils.isNotBlank(codeClassifyEntity.getParentCodeClassifyOid()) && StringUtils.isNotBlank(codeClassifyEntity.getBtmTypeId())){
         return R.fail("只有在顶层的主题库分类才能设置业务类型");
      }
      // codeClassifyEntity.setLastModifier(String.valueOf(AuthUtil.getUser().getUserId()));
      codeClassifyEntity.setLastModifier(String.valueOf(AuthUtil.getUser().getAccount()));
      codeClassifyEntity.setLastModifyTime(new Date());
      codeClassifyEntity.setTs(new Date());
      int updateEntity = codeClassifyMapper.updateById(codeClassifyEntity);
      // å¦‚果不是叶子结点，则需要修改其下所有的子分类，是否参与关键属性校验的值
      String oid = codeClassifyEntity.getOid();
      List<CodeClassify> codeClassifies = codeClassifyMapper.selectStartWithCurrentOid(oid);
      int updateAttr = 0;
      // ä¸ä¸ºç©ºå°±éœ€è¦è¯¥å½“前分类下所有子分类的isParticipateCheck
      if(!codeClassifies.isEmpty()){
         List<String> oids = codeClassifies.stream().map(CodeClassify::getOid).collect(Collectors.toList());
         LambdaUpdateWrapper<CodeClassify> updateWrapper = Wrappers.<CodeClassify>update()
            .lambda().in(CodeClassify::getOid, oids)
            .set(CodeClassify::getIsParticipateCheck, codeClassifyEntity.getIsParticipateCheck());
         // çˆ¶åˆ†ç±»çš„业务类型做了更改，所有子分类的都得进行更改
         if(!codeClassifyEntity.getBtmTypeId().equals(detail.getBtmTypeId())){
            updateWrapper.set(CodeClassify::getBtmTypeId,codeClassifyEntity.getBtmTypeId())
               .set(CodeClassify::getBtmTypeName,codeClassifyEntity.getBtmTypeName());
         }
         updateAttr = codeClassifyMapper.update(null,updateWrapper);

      }

//         //处理数据集成逻辑,成功后执行集成第一步,分类数据特殊处理。只有启用状态的分类才推送
//         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(updateAttr) & SqlHelper.retBool(updateEntity));
   }

   /**
    * æ£€æŸ¥ ä¸»é¢˜åº“分类是否删除
    * @param codeClassifyEntity ä¸»é¢˜åº“分类数据传输对象，必须要有oid和ts属性
    * @return æ‰§è¡Œç»“æžœ success为true为可以删除，false表示有数据引用，obj为true表示有下级
    */
   @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){
      List<CodeClassify> codeClassifyEntityList = codeClassifyMapper.selectClassifyByKeyAndReseRel("'" + oid.trim() + "'");
      if (codeClassifyEntityList.isEmpty() || codeClassifyEntityList.get(0) == null || StringUtils.isBlank(codeClassifyEntityList.get(0).getOid())) {
         throw new ServiceException("dataOidNotExist");//根据主键id未查到相关数据
      }
      return codeClassifyEntityList.get(0);
   }

   /**
    * æ ¡éªŒæ˜¯å¦å¯ä»¥åˆ é™¤ï¼Œå¦‚果存在下级，并且下级有数据引用则不能删除
    * @param codeClassifyEntity æ•°æ®åº“中的数据对象
    * @return success为true为可以删除，false表示有数据引用，obj为true表示有下级
    */
   private R checkIsCanDeleteForDO(CodeClassify codeClassifyEntity) {

      //检查ts
//      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("当前数据不是最新，请刷新后再修改！");
      }
      //校验下级是否有引用
      if(checkChildIsLinked(detail.getOid())){
         return R.fail("dataCascadeLinkedNotDelete");
      }
      if(checkHasChild(detail.getOid())){
         return R.fail("此数据有下级，无法进行删除！");
      }
      return R.status(!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和ts需要传输
    * @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<CodeClassifyTemplate> codeClstemplateEntities = codeClassifyTemplateMapper.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);
               baseMapper.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){

      List<CodeClassify> classifyList = codeClassifyMapper.selectStartWithCurrentOid(oid);
      Date now = new Date();
      // String userId = String.valueOf(AuthUtil.getUserId());
      String account = AuthUtil.getUserAccount();
      classifyList = classifyList.stream().map(s -> {
         s.setLcStatus(lcStatus);
         s.setTs(now);
         s.setLastModifier(account);
         s.setLastModifyTime(now);
         return s;
      }).collect(Collectors.toList());
//      //查询修改前ts
//      CodeClassify codeClassify = codeClassifyMapper.selectById(oid);//主要是为了查询ts
//      codeClassify.setLcStatus(lcStatus);
//      codeClassify.setTs(new Date());
//      codeClassify.setLastModifyTime(new Date());
//      codeClassify.setLastModifier(String.valueOf(AuthUtil.getUser().getUserId()));
      //启用、停用
//      int u = codeClassifyMapper.updateLcStatus(oid,lcStatus);
//      int count = codeClassifyMapper.updateById(codeClassify);
      codeClassifyMapper.batchUpdateLcStatus(classifyList);
//        //处理数据集成逻辑,成功后执行集成第一步,分类数据特殊处理。
//        if(u!=0) {
//            codeDuckingServiceI.insertCache1(lcStatus,lcStatus,DOCKING_DEFAULT_CLASSIFY, DOCKING_DEFAULT_CLASSIFYOID, oid, codeClassifyDO_old.getTs());
//        }
//      return R.data(SqlHelper.retBool(count));
      return R.success("");
   }

   /**
    * ä¸»é”®æ‰¹é‡èŽ·å–主题库分类
    * @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);
         //如果有lcstatus的类的话
         vo.setLcStatusText(FrameworkDataLCStatus.getTextByValue(vo.getLcStatus()));
      }
      return vo;
   }

   /**
    * å‚照树 ä¸»é¢˜åº“分类
    * @param treeQueryObject æ ‘形查询对象
    * @return ä¸»é¢˜åº“分类显示树
    */
   @Override
   public List<Tree> referTree(TreeQueryObject treeQueryObject) throws ServiceException{
      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 oid ä¸»é”®
    * @return  æ•°æ®å¯¹è±¡
    */
   private CodeClassify selectByOidRel(String oid){

      List<CodeClassify> codeClassifyList = codeClassifyMapper.selectClassifyByKeyAndReseRel("'"+oid.trim()+"'");
//      CodeClassify codeClassifyEntity = (CodeClassify) codeClassifyList;
      if(codeClassifyList.size() == 0 ){
         throw new ServiceException("dataNotExist");//根据主键id未查到相关数据
      }
//      if(codeClassifyEntity == null || StringUtils.isBlank(codeClassifyEntity.getOid())){
//         throw new ServiceException("dataOidNotExist");//根据主键id未查到相关数据
//      }
      return codeClassifyList.get(0);
   }

   /**
    * æŸ¥è¯¢ä¸»é¢˜åº“分类 æ ‘
    * @param treeQueryObject æ ‘查询对象
    * @return ä¸»é¢˜åº“分类 æ˜¾ç¤ºæ ‘
    */
   @Override
   public List<Tree> treeCodeClassify(TreeQueryObject treeQueryObject) throws ServiceException{
      List<CodeClassify> doList = null;
      String id = null;
      String lcStatus = null;
      if(!Objects.isNull(treeQueryObject.getConditionMap())){
         id = treeQueryObject.getConditionMap().getOrDefault("id",null);
         lcStatus = treeQueryObject.getConditionMap().getOrDefault("lcStatus",null);
      }
      if(StringUtils.isNotBlank(id) || StringUtils.isNotBlank(lcStatus) ){
         //String tableName = this.getTableName(treeQueryObject.getConditionMap().get("btmTypeId"),treeQueryObject.getConditionMap().get("id"), treeQueryObject.getConditionMap().get("lcStatus"));
         // TODO: 2024-1-24 23:25我去掉了懒加载，因为会影响数据授权过滤和分类搜索功能，而且这儿感觉没必要做懒加载
         doList = codeClassifyMapper
            .selectCodeClassifyDOByTree(
               treeQueryObject.getConditionMap().get("id"),
               treeQueryObject.getConditionMap().get("lcStatus"),
               treeQueryObject.getParentOid(),
               VciBaseUtil.checkAdminTenant() ? null:AuthUtil.getTenantId()
               /*tableName*/
            );
      }else{
         // åªè¦å‰ç«¯ä¼šä¼ å‚数过来就不会出现走这句的情况，所以查询总数没在这儿添加
         doList =codeClassifyMapper.selectCodeClassifyVOByTree(
            treeQueryObject.getParentOid(),
            VciBaseUtil.checkAdminTenant() ? null:AuthUtil.getTenantId()
         );
      }
      List<CodeClassifyVO> voList = codeClassifyDO2VOs(doList);
      TreeWrapperOptions treeWrapperOptions = new TreeWrapperOptions(PARENT_FIELD_NAME);
      treeWrapperOptions.copyFromTreeQuery(treeQueryObject);
      List<Tree> tree = revisionModelUtil.doList2Trees(voList,treeWrapperOptions,(CodeClassifyVO s) ->{
         //可以在这里处理树节点的显示
         return s.getId() + " " + s.getName() + (FrameworkDataLCStatus.DISABLED.getValue().equalsIgnoreCase(s
            .getLcStatus()) ? (" ã€åœç”¨ã€‘ ") : "");
      });
      // éžè¶…管过滤未授权的分类
      if(!VciBaseUtil.checkAdminTenant()){
         // é‚£äº›åˆ†ç±»å…·å¤‡æŸ¥çœ‹æƒé™
         R<List<String>> viewClassByRoleIds = sysClient.getViewClassByRoleIds(
            Arrays.asList(AuthUtil.getUser().getRoleId().split(",")),
            treeQueryObject.getConditionMap().getOrDefault("authType","classify_auth"),
            treeQueryObject.getConditionMap().getOrDefault("buttonCode","classify_view"),
            treeQueryObject.getConditionMap().getOrDefault("menuCode","classifyTree")
         );
         // è¯·æ±‚失败或者请求得到的具备查看权限的分类id集合为空
         if(!viewClassByRoleIds.isSuccess() && viewClassByRoleIds.getData().isEmpty()){
            throw new ServiceException("主数据查看权限未配置，或配置有误！");
         }
         // è¿‡æ»¤
         filterTreeNodes(tree,viewClassByRoleIds.getData());
      }
      // åŠ è½½åˆ†ç±»æ˜¯å¦å…·æœ‰å­åˆ†ç±»
      tree.parallelStream().forEach(item -> {
         boolean checkHasChild = checkHasChild(item.getOid());
         item.setLeaf(!checkHasChild);
      });
      return tree;
   }

   /**
    * åˆ†ç±»æŽˆæƒè¿‡æ»¤æŽ‰æ²¡æœ‰æƒé™çš„分类
    * @param trees
    * @param classifyIds
    */
   private void filterTreeNodes(List<Tree> trees, List<String> classifyIds) {
      Iterator<Tree> iterator = trees.iterator();
      while (iterator.hasNext()) {
         Tree tree = iterator.next();
         /*Boolean checkHasChild = checkHasChild(tree.getOid());
         tree.setLeaf(!checkHasChild);*/
         if (classifyIds.contains(tree.getOid())) {
            // å¦‚果顶层节点存在 classifyIds ï¼Œç›´æŽ¥ä¿ç•™å…¶å­èŠ‚点集合
            continue;
         }
         if (tree.getChildren() != null && !tree.getChildren().isEmpty()) {
            filterTreeNodes(tree.getChildren(), classifyIds);
         }
         if (!hasMatchingChild(tree, classifyIds)) {
            iterator.remove();
         }
      }
   }

   private boolean hasMatchingChild(Tree tree, List<String> classifyIds) {
      if (classifyIds.contains(tree.getOid())) {
         return true;
      }
      if (tree.getChildren() != null) {
         for (Tree child : tree.getChildren()) {
            if (hasMatchingChild(child, classifyIds)) {
               return true;
            }
         }
      }
      return false;
   }

   /**
    * åˆ†ç±»åŠ è½½æ—¶èŽ·å–业务类型id，拼接业务类型表名
    * @return
    */
   private String getTableName(String btmTypeId,String id,String lcStatus){
      if(Func.isNotEmpty(btmTypeId)){
         return VciBaseUtil.getTableName(btmTypeId,true);
      }
      LambdaQueryWrapper<CodeClassify> wrapper = Wrappers.<CodeClassify>query()
         .lambda().select(CodeClassify::getBtmTypeId)
         .eq(CodeClassify::getLcStatus, lcStatus)
         .isNotNull(CodeClassify::getBtmTypeId)
         .last("limit 1")
         .eq(CodeClassify::getId,id).isNull(CodeClassify::getParentCodeClassifyOid);

      CodeClassify codeClassify = codeClassifyMapper.selectOne(wrapper);
      if(Func.isEmpty(codeClassify) || Func.isEmpty(codeClassify.getBtmTypeId())){
         throw new ServiceException("查询主数据总数时，未获取到业务类型ID！");
      }
      return VciBaseUtil.getTableName(codeClassify.getBtmTypeId(),true);
   }

   /**
    * æ ¹æ®æ ‘形查询对象来查询数据对象
    *
    * @param treeQueryObject æ ‘形查询对象
    * @return æŸ¥è¯¢ç»“æžœ,数据对象
    */
   @Override
   public List<CodeClassifyVO> selectCodeClassifyDOByTree(TreeQueryObject treeQueryObject) {
      List<CodeClassify> doList =codeClassifyMapper.selectCodeClassifyVOByTree(treeQueryObject.getParentOid(),AuthUtil.getTenantId());
      List<CodeClassifyVO> voList = codeClassifyDO2VOs(doList);
      return voList;
   }

   /***
    *
    * @param parentOid
    * @return
    */
   @Override
   public List<CodeClassifyVO> selectCodeClassifyVOByParentId(String parentOid) {
      List<CodeClassify> doList =codeClassifyMapper.selectCodeClassifyDOByParentId(parentOid,AuthUtil.getTenantId());
      List<CodeClassifyVO> voList = codeClassifyDO2VOs(doList);
      return voList;
   }

   /**
    * æ ¹æ®åº“节点名称获取分类
    * @param libName
    * @return
    */
   @Override
   public List<CodeClassifyVO> getRMLibByName(String libName) {
      List<String> libNameList=new ArrayList<>();
      if(StringUtils.isNotBlank(libName)){
         libNameList=VciBaseUtil.str2List(libName);
      }
      List<CodeClassify> doList =codeClassifyMapper.getRMLibByName(libNameList,"Enabled",AuthUtil.getTenantId()
         .equals(
            NacosConfigCache
               .getAdminUserInfo()
               .getTenantId()
         ) ? null:AuthUtil.getTenantId());
      List<CodeClassifyVO> voList = codeClassifyDO2VOs(doList);
      return voList;
   }

   /***
    * æ ¹æ®oid获取下面所有的分类信息
    * @param oid
    * @return
    */
   public List<CodeClassifyVO> selectAllClassifyByOid(String oid, String fieldInPath){
      List<CodeClassify>  codeClassifyList=codeClassifyMapper.selectAllClassifyByOid(oid,fieldInPath,AuthUtil.getTenantId());
      List<CodeClassifyVO> voList = codeClassifyDO2VOs(codeClassifyList);
      return voList;

   }

   /**
    * æ ¹æ®é¡¶å±‚节点oid查询所有除当前节点以外所有不参与校验的分类oid
    * @param topOid
    * @param currentOid
    * @return
    */
   @Override
   public String selectLeafByParentClassifyOid(String topOid, String currentOid) {
      List<CodeClassify> codeClassifies = codeClassifyMapper.selectLeafByParentClassifyOid(topOid, currentOid);
      if(codeClassifies.isEmpty()){
         return "";
      }
      String oids = codeClassifies.stream()
         .map(CodeClassify::getOid)
         .map(s -> "'" + s + "'")
         .collect(Collectors.joining(","));;
      return oids;
   }

   /**
    *  æ ¹æ®é¡¶å±‚节点oid查询所有叶子节点分类oid
    * @param pid
    * @return
    */
   @Override
   public String selectLeafByPid(String pid) {
      List<CodeClassify> codeClassifies = codeClassifyMapper.selectLeafByPid(pid);
      if(codeClassifies.isEmpty()){
         return "";
      }
      String oids = codeClassifies.stream()
         .map(CodeClassify::getOid)
         .map(s ->s)
         .collect(Collectors.joining(","));;
      return oids;
   }

   /**
    * æµæ°´ä¾èµ–生成
    */
   @Override
   public R flowingDependencyGen(String classifyOid) {
      //查询此分类下面的所有分类
      List<CodeClassify>  codeClassifyList=codeClassifyMapper.selectAllClassifyByOid(classifyOid,AuthUtil.getTenantId(),null);
      //查询码值表，获取最大流水
      List<CodeAllCode> codeAllCodeVOS = codeAllCodeMapper.selectGroupByClassify("'" + codeClassifyList.stream()
         .map(classfiy -> classfiy.getOid()).collect(Collectors.joining("','")) + "'","'${sav}'");
      //往流水表里面加数据，有则更新，无则添加数据。
      for (CodeAllCode codeAllCodeVO : codeAllCodeVOS) {
         if(Func.isEmpty(codeAllCodeVO.getSerialUnit())){
            throw new ServiceException("编码为：" + codeAllCodeVO.getId() + "的码值数据流水依赖不能为空！");
         }
         try {
            CodeRuleVO codeRuleVO = codeRuleService.getObjectByOid(codeAllCodeVO.getCodeRuleOid());
            if(Func.isEmpty(codeRuleVO)){
               continue;
            }
         }catch (Exception e){
            continue;
         }
         QueryWrapper<CodeBasicSec> secWrapper = new QueryWrapper<>();
         secWrapper.eq("PKCODERULE",codeAllCodeVO.getCodeRuleOid());
         secWrapper.eq("SECTYPE","codeserialsec");
         List<CodeBasicSec> codeBasicSecs = codeBasicSecMapper.selectList(secWrapper);
         if(codeBasicSecs.size() == 0 ){
            throw new ServiceException("根据码值ID：" + codeAllCodeVO.getCodeRuleOid() + ",码段类型为流水码段(codeserialsec),在基础码段中未找到相关数据！");
         }
         QueryWrapper<CodeSerialValue> wrapper = new QueryWrapper<>();
         wrapper.eq("codeRuleOid",codeAllCodeVO.getCodeRuleOid());
         wrapper.eq("serialUnit",codeAllCodeVO.getSerialUnit());
         wrapper.eq("codeSecOid",codeBasicSecs.get(0).getOid());
         List<CodeSerialValue> codeSerialValues = codeSerialValueMapper.selectList(wrapper);
         if(codeSerialValues.size() == 0){
            CodeSerialValue newSerialValue = new CodeSerialValue();
            DefaultAttrAssimtUtil.addDefaultAttrAssimt(newSerialValue,"codeserialvalue");
            newSerialValue.setCodeRuleOid(codeAllCodeVO.getCodeRuleOid());
            newSerialValue.setCodeSecOid(codeBasicSecs.get(0).getOid());
            newSerialValue.setSerialUnit(codeAllCodeVO.getSerialUnit());
            newSerialValue.setMaxSerial(codeAllCodeVO.getUnFillSerial());
            newSerialValue.setLctid("defaultLC");
            newSerialValue.setLcStatus("Exist");
            codeSerialValueMapper.insert(newSerialValue);
         }else{
            codeSerialValues.get(0).setMaxSerial(codeAllCodeVO.getUnFillSerial());
            codeSerialValues.get(0).setLastModifyTime(new Date());
            codeSerialValues.get(0).setLastModifier(String.valueOf(AuthUtil.getUser().getUserId()));
            codeSerialValues.get(0).setTs(new Date());
            codeSerialValueMapper.updateById(codeSerialValues.get(0));
         }
      }
      return R.success("操作成功！");
   }

   /***
    * æ ¹æ®åˆ†ç±»æè¿°å¤‡æ³¨å’Œåº“节点查询分类信息
    * @param desc
    * @param codeLibName
    * @return
    */
   @Override
   public List<CodeClassifyVO> getRMTypeByDescAndLib(String desc, String codeLibName) {
      List<CodeClassify> doList =codeClassifyMapper.getRMTypeByDesc(desc,"Enabled",AuthUtil.getTenantId());
      if (CollectionUtils.isEmpty(doList)) {
         return new LinkedList<CodeClassifyVO>();
      }
      CodeClassify codeClassify=doList.get(0);
      List<CodeClassify>  codeClassifyList=codeClassifyMapper.selectAllParenClassifytByOid(codeClassify.getOid(),AuthUtil.getTenantId());
      CodeClassify currentLib = codeClassifyList.get(codeClassifyList.size() - 1);
      if (!currentLib.getName().equals(codeLibName)) {
         return new ArrayList<>();
      }
      List<CodeClassifyVO> voList = codeClassifyDO2VOs(codeClassifyList);
      return voList;
   }

   /**
    * ä½¿ç”¨ç¼–号的路径获取对象
    *
    * @param fieldPath ç¼–号的路径，一定要从最顶层节点开始，格式为xxx/yyy/zz è¿™æ ·
    * @return åˆ†ç±»çš„显示对象
    */
   @Override
   public CodeClassifyVO getObjectByClsfNamePath(String fieldPath){
      CodeClassifyVO codeClassifyVO=new CodeClassifyVO();
      List<CodeClassify> classifyList = codeClassifyMapper.selectByFieldNamePath(fieldPath,"name");
      if(classifyList.size()>0){
         codeClassifyVO=codeClassifyDO2VO(classifyList.get(0));
      }
      return codeClassifyVO;
   }
   /***
    * æ ¹æ®ä¸Šçº§èŠ‚点获取下级节点代号路径和名称路径
    * @param classifyId
    * @param enable
    * @return
    */
   @Override
   public List<CodeClassifyVO> getIdPathToNamePathByParentId(String classifyId, boolean enable) {
      List<CodeClassify>  doList=   codeClassifyMapper.getIdPathToNamePathByParentId(classifyId);
      List<CodeClassifyVO> voList = codeClassifyDO2VOs(doList);
      return voList;
   }

   //   /**
//    * æ ¹æ®æ ‘形查询对象来查询数据对象
//    *
//    * @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,写excel
      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,"描述"));
      codeClassifyVOS = codeClassifyVOS.stream().sorted(Comparator.comparing(CodeClassifyVO::getDataLevel)).collect(Collectors.toList());
      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,fieldInPath,AuthUtil.getTenantId());
         if(!CollectionUtils.isEmpty(classifyDOS)){
            classifyDOS = classifyDOS.parallelStream().filter(s->FRAMEWORK_DATA_ENABLED.equalsIgnoreCase(s.getLcStatus())).collect(Collectors.toList());
         }
         return codeClassifyDO2VOs(classifyDOS);
      }else{
         //只查询一条，那path就没必要查询了
         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,写excel
      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("导入的excel文件不存在,{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.listCodeRuleByIds(ruleOids,true)
      ).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.getBtmTypeId()))
         .map(CodeClassifyPO::getBtmTypeId).collect(Collectors.toList());
      Map<String, BtmTypeVO> btmVOMap = Optional
         .ofNullable(btmOids.size()==0 ? null: btmTypeClient.selectByIdCollection(btmOids).getData())
         .orElse(new ArrayList<BtmTypeVO>()).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("",null,AuthUtil.getTenantId());
      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())){
            BtmTypeVO typeVO = (BtmTypeVO)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(String.valueOf(AuthUtil.getUser().getUserId()));
               // classifyDO.setCreator(String.valueOf(AuthUtil.getUser().getUserId()));
               // classifyDO.setLastModifier(String.valueOf(AuthUtil.getUser().getUserId()));
               classifyDO.setCreator(String.valueOf(AuthUtil.getUser().getAccount()));
               classifyDO.setLastModifier(String.valueOf(AuthUtil.getUser().getAccount()));
               classifyDO.setLastModifyTime(new Date());
               codeClassifyMapper.insert(classifyDO);
            }
//            codeClassifyMapper.batchInsert(classifyDOs.stream().collect(Collectors.toList()));
         });
      }

   }

   /**
    * èŽ·å–分类关联的属性
    *
    * @param baseQueryObject æŸ¥è¯¢å¯¹è±¡ï¼Œå¿…须有codeClassifyOid，支持id和name两种查询条件
    * @return å±žæ€§çš„信息，包含默认的属性
    */
   @Override
   public DataGrid<BtmTypeAttributeVO> listClassifyLinkAttr(BaseQueryObject baseQueryObject) throws ServiceException{
      if(baseQueryObject == null){
         baseQueryObject = new BaseQueryObject();
      }
      if(baseQueryObject.getConditionMap() == null){
         baseQueryObject.setConditionMap(new HashMap<>());
      }
      String classifyOid = baseQueryObject.getConditionMap().getOrDefault("codeClassifyOid","");
      String btmTypeOid = baseQueryObject.getConditionMap().getOrDefault("btmTypeOid","");
      String id = baseQueryObject.getConditionMap().getOrDefault("id","");
      String name = baseQueryObject.getConditionMap().getOrDefault("name","");
      if(StringUtils.isBlank(classifyOid)){
         return new DataGrid<>();
      }
      if(StringUtils.isBlank(btmTypeOid)){
         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());
      R<BtmTypeVO> btmTypeDetail = btmTypeClient.getDetail(btmTypeOid);
      if(!btmTypeDetail.isSuccess()){
         throw new ServiceException("业务类型feign接口调用出错");
      }
      List<BtmTypeAttributeVO> unDefaultAttributes = btmTypeDetail.getData().getAttributes();
      // List<CodeOsbtmtypeattributeEntity> unDefaultAttributes = codeOsbtmtypeattributeMapper.selectByMap(condition);
      // List<OsBtmTypeAttributeVO> unDefaultAttributes = btmService. (topClassifyVO.getBtmtypeid());
      List<BtmTypeAttributeVO> attributeVOS = new ArrayList<>();
      if(!CollectionUtils.isEmpty(unDefaultAttributes)){
         unDefaultAttributes.stream().forEach(attr->{
            BtmTypeAttributeVO attributeVO = new BtmTypeAttributeVO();
            BeanUtils.copyProperties(attr,attributeVO);
            attributeVO.setAttrDataType(attr.getAttrDataType());
            attributeVO.setAttributeLength(attr.getAttributeLength());
            attributeVO.setBtmTypeId(btmTypeDetail.getData().getId());
            attributeVO.setBtmname(btmTypeDetail.getData().getName());
            attributeVO.setAttrDataTypeText(EnumCache.getValue(EnumEnum.VCI_FIELD_TYPE,attr.getAttrDataType()));
            boolean add = true;
            if(StringUtils.isNotBlank(id) && !attributeVO.getId().contains(id.replace("*",""))){
               add = false;
            }
            if(StringUtils.isNotBlank(name) && !attributeVO.getName().contains(name.replace("*",""))){
               add = false;
            }
            if(add){
               attributeVOS.add(attributeVO);
            }
         });
      }
      R<BtmTypeVO> btmTypeVOR = btmTypeClient.getDefaultAttrByBtmId(topClassifyVO.getBtmTypeId());
      if(!btmTypeVOR.isSuccess()){
         throw new ServiceException("业务类型feign接口调用出错");
      }
      List<BtmTypeAttributeVO> defaultAttrVOS = btmTypeVOR.getData().getAttributes();

      // å–两个集合差集
      List<String> ids = unDefaultAttributes.stream().map(BtmTypeAttributeVO::getId).collect(Collectors.toList());
      defaultAttrVOS.forEach(item->{
         if(!ids.contains(item.getId())){
            BtmTypeAttributeVO attributeVO = new BtmTypeAttributeVO();
            BeanUtils.copyProperties(item,attributeVO);
            attributeVO.setAttrDataType(item.getAttrDataType());
            attributeVO.setAttributeLength(item.getAttributeLength());
            attributeVO.setBtmTypeId(btmTypeDetail.getData().getId());
            attributeVO.setBtmname(btmTypeDetail.getData().getName());
            attributeVO.setAttrDataTypeText(EnumCache.getValue(EnumEnum.VCI_FIELD_TYPE,item.getAttrDataType()));
            boolean add = true;
            if(StringUtils.isNotBlank(id) && !item.getId().contains(id.replace("*",""))){
               add = false;
            }
            if(StringUtils.isNotBlank(name) && !item.getName().contains(name.replace("*",""))){
               add = false;
            }
            if(add){
               attributeVOS.add(attributeVO);
            }
         }
      });

      DataGrid<BtmTypeAttributeVO> 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->{
         // ç”¨key取map值并且不区分大小写
         oidLevelMap.put(cbo.getOrDefault("OID",cbo.get("oid")).toString(),cbo.get("LEVEL").toString());
      });
      if(CollectionUtils.isEmpty(oidLevelMap)){
         return new ArrayList<>();
      }

      //使用主键查询一下
      String oids = "";
      for (String s : oidLevelMap.keySet()) {
         oids += "'"+s+"',";
      }
      List<CodeClassify> classifyDOS = codeClassifyMapper.selectClassifyByKeyAndReseRel(oids.substring(0,oids.length()-1));
      if(!CollectionUtils.isEmpty(classifyDOS)){
         classifyDOS.stream().forEach(classifyDO->{
            classifyDO.setDataLevel(VciBaseUtil.getInt(oidLevelMap.getOrDefault(classifyDO.getOid(),"0")));
            classifyDO.setLcStatusText(EnumCache.getValue("codeLcstatus",classifyDO.getLcStatus()));
         });
      }
      return classifyDOS;
   }

   /**
    * ä¸»é”®èŽ·å–主题库分类
    * @param oid ä¸»é”®
    * @return ä¸»é¢˜åº“分类显示对象
    * @throws VciBaseException å‚数为空，数据不存在时会抛出异常
    */
   @Override
   public CodeClassifyVO getObjectByOid(String oid) throws VciBaseException{
      return codeClassifyDO2VO(selectByOid(oid));
   }

   /**
    * ä½¿ç”¨ç¼–号的路径获取对象
    *
    * @param idPath ç¼–号的路径，一定要从最顶层节点开始，格式为xxx/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.selectByIdRel(idPathValues.get(0).get("OID").toString());
      }
      return codeClassifyDO2VO(classifyDO);
   }

   /**
    * ä¸»é¢˜åº“çš„æ ‘,已联调业务类型查询feign
    * @param treeQueryObject æ ‘形查询对象
    * @return ä¸»é¢˜åº“显示树
    */
   @Override
   public List<Tree> treeTopCodeClassify(TreeQueryObject treeQueryObject) {
      if(treeQueryObject == null){
         treeQueryObject = new TreeQueryObject();
      }
      if(treeQueryObject.getConditionMap() == null){
         treeQueryObject.setConditionMap(new HashMap<String,String>());
      }
      treeQueryObject.getConditionMap().put(PARENT_FIELD_NAME, "=null");
      List<Tree> trees = treeCodeClassify(treeQueryObject);
      treeQueryObject.getConditionMap().put("domain", AppConstant.APPLICATION_NAME_CODE);
      BaseQueryObject baseQueryObject = new BaseQueryObject();
      baseQueryObject.setConditionMap(treeQueryObject.getConditionMap());
      List<BtmTypeVO> btmTypeVOS = btmTypeClient.getRef(baseQueryObject).getData();
      if(Func.isEmpty(btmTypeVOS) || Func.isEmpty(trees)){
         return null;
      }
      List<Tree> treeList = trees.stream().filter(tree -> !CollectionUtils.isEmpty(btmTypeVOS.stream().filter(btmType -> {
               if(Objects.equals(tree.getAttributes().get("btmTypeId"), btmType.getId())){
                  tree.getAttributes().put("btmTypeOid",btmType.getOid());
                  return true;
               }
               return false;
            }).collect(Collectors.toList())))
         .collect(Collectors.toList());
      return treeList;
   }

   /**
    * èŽ·å–这个分类下的业务类型，当前没有就获取上级的第一个业务类型
    * @param oid å½“前分类的oid
    * @return oid,id,name,btmtypeid,btmtypename，没有就返回null
    */
   @Override
   public CodeClassify selectBtmOrParentBtm(String oid){
      List<CodeClassify> oidList = selectAllLevelParents(oid);
      return oidList.size()==0?null:oidList.get(0);
   }

   /**
    * èŽ·å–所有层级上级关联业务类型数据
    * @param oid å½“前分类的oid
    * @return oid,id,name,btmtypeid,btmtypename
    */
   @Override
   public List<CodeClassify> selectAllLevelParents(String oid){
//      String sql = "select oid,id,name,btmtypeid,btmtypename from " + VciBaseUtil.getTableName(MdmBtmTypeConstant.CODE_CLASSIFY) + " where btmtypeid is not null start with oid= :oid connect by prior PARENTCODECLASSIFYOID=oid ";
//      Map< String,String> conditionMap = new HashMap< String,String>();
//      conditionMap.put("oid",oid);
//      List<Map> dataList = boService.queryBySqlForMap(sql,conditionMap);
      List<Map<String, Object>> dataList = codeClassifyMapper.selectAllLevelParents(oid);
      List<CodeClassify> oidList = new ArrayList<CodeClassify>();
      if(!CollectionUtils.isEmpty(dataList)){
         for(Map data:dataList){
            CodeClassify codeClassifyDO = new CodeClassify();
            codeClassifyDO.setOid(VciBaseUtil.getStringValueFromObject(VciBaseUtil.getMapValueIgnoreCase(data,"OID")));
            codeClassifyDO.setId(VciBaseUtil.getStringValueFromObject(VciBaseUtil.getMapValueIgnoreCase(data,"ID")));
            codeClassifyDO.setName(VciBaseUtil.getStringValueFromObject(VciBaseUtil.getMapValueIgnoreCase(data,"NAME")));
            codeClassifyDO.setBtmTypeId(VciBaseUtil.getStringValueFromObject(VciBaseUtil.getMapValueIgnoreCase(data,"BTMTYPEID")));
            codeClassifyDO.setBtmTypeName(VciBaseUtil.getStringValueFromObject(VciBaseUtil.getMapValueIgnoreCase(data,"BTMTYPENAME")));
            oidList.add(codeClassifyDO);
         }
      }
      return oidList;
   }

   /**
    * æŸ¥è¯¢æ‰€æœ‰ä¸Šå±‚父节点的oid
    * @param oid
    * @return
    */
   @Override
   public List<String> selectAllParentOid(String oid){
      if(Func.isBlank(oid)){
         return new ArrayList<>();
      }
      return this.codeClassifyMapper.selectAllParentOid(oid);
   }

   /**
    * ä½¿ç”¨åˆ†ç±»ä¸»é”®èŽ·å–分类相关的所有信息
    *
    * @param codeClassifyOid åˆ†ç±»çš„主键
    * @return åˆ†ç±»ä¸Šçº§ï¼Œä¸‹çº§çš„信息
    */
   @Override
   public CodeClassifyFullInfoBO getClassifyFullInfo(String codeClassifyOid) {
      VciBaseUtil.alertNotNull(codeClassifyOid,"分类的主键");
      CodeClassifyFullInfoBO fullInfo = new CodeClassifyFullInfoBO();
      CodeClassify classifyDO = selectByOidRel(codeClassifyOid);
      //查询上级
      fullInfo.setCurrentClassifyVO(codeClassifyDO2VO(classifyDO));
//      List<Map<String, Object>> maps = codeClassifyMapper.selectAllLevelParentByOid(codeClassifyOid);
//      List<Map<String, Object>> maps = selectAllLevelParentByOid(codeClassifyOid);
      List<CodeClassify> codeClassifyList = selectAllLevelParentByOid(codeClassifyOid);
//      for (Map<String, Object> map : maps) {
//         CodeClassify codeClassify = new CodeClassify();
//         codeClassify.setOid(String.valueOf(map.get("OID")));
//         codeClassify.setDataLevel((Integer) map.get("LEVEL"));
//         codeClassifyList.add(codeClassify);
//      }

      fullInfo.setParentClassifyVOs(codeClassifyDO2VOs(codeClassifyList));
      if(!CollectionUtils.isEmpty(fullInfo.getParentClassifyVOs())){
         fullInfo.setTopClassifyVO(fullInfo.getParentClassifyVOs().stream().filter(s->StringUtils.isBlank(s.getParentCodeClassifyOid())).findFirst().orElseGet(()->null));
      }
      return fullInfo;
   }

   /**
    * ç»Ÿè®¡å­èŠ‚点的个数
    *
    * @param codeClassifyOid åˆ†ç±»çš„主键
    * @return ä¸ªæ•°
    */
   @Override
   public int countChildrenByClassifyOid(String codeClassifyOid) {
//      Map<String,String> conditionMap = new HashMap<>();
//      conditionMap.put("parentCodeClassifyOid",codeClassifyOid);
      QueryWrapper<CodeClassify> wrapper = new QueryWrapper<>();
      wrapper.eq("parentCodeClassifyOid",codeClassifyOid);
      return codeClassifyMapper.selectCount(wrapper).intValue();
   }

}