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

@@ -1,14 +1,46 @@
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.code.bo.TreeWrapperOptions;
import com.vci.ubcs.code.entity.CodeClassify;
import com.vci.ubcs.code.entity.CodeClstemplateEntity;
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.service.ICodeClassifyService;
import com.vci.ubcs.code.service.ICodeKeyattrrepeatService;
import com.vci.ubcs.code.service.ICodeRuleService;
import com.vci.ubcs.code.vo.CodeClstemplateVO;
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.code.vo.pagemodel.TreeQueryObject;
import com.vci.ubcs.com.vci.starter.revision.service.RevisionModelUtil;
import com.vci.ubcs.com.vci.starter.web.pagemodel.Tree;
import com.vci.ubcs.com.vci.starter.web.util.BeanUtilForVCI;
import com.vci.ubcs.com.vci.starter.web.util.VciBaseUtil;
import com.vci.ubcs.core.log.exception.ServiceException;
import jodd.bean.BeanUtil;
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.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;

import javax.annotation.Resource;
import java.util.List;
import java.io.File;
import java.util.*;
import java.util.stream.Collectors;

import static com.vci.ubcs.code.constant.FrameWorkDefaultValueConstant.*;
import static org.springblade.core.cache.constant.CacheConstant.SYS_CACHE;

@Service
public class ICodeClassifyServiceImpl extends ServiceImpl<CodeClassifyMapper, CodeClassify> implements ICodeClassifyService {
@@ -16,6 +48,23 @@
   @Resource
   private CodeClassifyMapper codeClassifyMapper;

   @Resource
   private CodeClstemplateMapper codeClstemplateMapper;

   @Resource
   private ICodeRuleService codeRuleService;
   /**
    * 对象的操作
    */
   @Resource
   private RevisionModelUtil revisionModelUtil;

   @Resource
   private ICodeKeyattrrepeatService iCodeKeyattrrepeatService;
   /**
    * 上级节点的属性名称
    */
   public static  final String PARENT_FIELD_NAME = "parentCodeClassifyOid";
   /**
    * 使用查询封装器来查询
    * @param wrapper 查询封装器
@@ -26,5 +75,485 @@
      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.setLastModifier(AuthUtil.getUser().getUserName());
      codeClassifyEntity.setLastModifyTime(new Date());
      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("传入数据不能为空！");
      }
      //检查ts
      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和ts属性
    * @return 执行结果 success为true为可以删除，false表示有数据引用，obj为true表示有下级
    */
   @Override
   public R checkIsCanDelete(CodeClassify codeClassifyEntity) {
      if(codeClassifyEntity == null || codeClassifyEntity.getOid() == null){
         return R.fail("传入数据不能为空！");
      }
      codeClassifyEntity = selectByOid(codeClassifyEntity.getOid());
      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为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(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和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<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){

      //查询修改前ts
      CodeClassify codeClassify = codeClassifyMapper.selectById(oid);//主要是为了查询ts
      codeClassify.setLcStatus(lcStatus);
      //启用、停用
//      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);
         //如果有lcstatus的类的话
         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 -> org.apache.commons.lang3.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);
//            ruleVOMap.putAll( Optional.ofNullable(ruleVOS).orElseGet(()->new ArrayList<>()).stream().collect(Collectors.toMap(s->s.getOid(),t->t)));
//         });
//      }
//      //找关键属性规则
//      List<String> keyRuleOids = codeClassifyVOS.stream().filter(s -> org.apache.commons.lang3.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,"描述"));
//      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, org.apache.commons.lang3.StringUtils.isNotBlank(vo.getCoderuleoid())?ruleVOMap.getOrDefault(vo.getCoderuleoid(),new CodeRuleVO()).getId():""));
//         excelDataList.add(new WriteExcelData(i+1,5, org.apache.commons.lang3.StringUtils.isNotBlank(vo.getCoderuleoid())?ruleVOMap.getOrDefault(vo.getCoderuleoid(),new CodeRuleVO()).getName():""));
//         excelDataList.add(new WriteExcelData(i+1,6, org.apache.commons.lang3.StringUtils.isNotBlank(vo.getCodekeyattrrepeatoid())?keyRuleVOMap.getOrDefault(vo.getCodekeyattrrepeatoid(),new CodeKeyAttrRepeatRuleVO()).getId():""));
//         excelDataList.add(new WriteExcelData(i+1,7, org.apache.commons.lang3.StringUtils.isNotBlank(vo.getCodekeyattrrepeatoid())?keyRuleVOMap.getOrDefault(vo.getCodekeyattrrepeatoid(),new CodeKeyAttrRepeatRuleVO()).getName():""));
//         excelDataList.add(new WriteExcelData(i+1,8,vo.getOid().equalsIgnoreCase(classifyVO.getOid())?vo.getPath():classifyVO.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 null;
//      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{
         //只查询一条，那path就没必要查询了
         Map<String,Object> conditionMap = new HashMap<>();
         conditionMap.put("parentcodeclassifyoid",codeClassifyOid);
         if (enable){
            conditionMap.put("lcstatus",FRAMEWORK_DATA_ENABLED);
         }
         return codeClassifyDO2VOs(codeClassifyMapper.selectByMap(conditionMap));
      }
   }
}