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

@@ -5,24 +5,42 @@
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.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
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 {
@@ -30,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 查询封装器
@@ -203,50 +238,322 @@
      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(codeClassifyTemplateDOListHaveTemplate.size()>0){
//         return BaseResult.fail("分类关联模板，请先删除!");
//      }
//
//      //处理数据集成逻辑,成功后执行集成第一步,分类数据特殊处理。
//      //1、查询要删除的父类数据
//      List<CodeClassifyDO> deletes = new ArrayList<CodeClassifyDO>();
//      deletes.add(codeClassifyDO);
//
//      if(result.isSuccess()) {
//         //找下级的，这个是可以删除的时候
//         Map<String,String> childrenOids = codeClassifyMapper.selectAllLevelChildOid(codeClassifyDO.getOid().trim());
//         if (!CollectionUtils.isEmpty(childrenOids)) {
//            Collection<Collection<String>> childrenCollections = VciBaseUtil.switchCollectionForOracleIn(childrenOids.keySet());
//            for(Collection<String> s : childrenCollections){
//
//               //处理数据集成逻辑,成功后执行集成第一步,分类数据特殊处理。
//               //2、查询要删除的子类数据
//               List<CodeClassifyDO>  codeClassifyDOList = codeClassifyMapper.selectByPrimaryKeyCollection(s);
//               deletes.addAll(codeClassifyDOList);
//
//               codeClassifyMapper.batchDeleteByOids(s);
//            }
//
//         }
//      }else{
//         return baseResult;
//      }
//
//      //执行删除操作
//      BatchCBO batchCBO = codeClassifyMapper.deleteByPrimaryKey(codeClassifyDO.getOid());
//
//      //处理数据集成逻辑,成功后执行集成第一步
//      for (CodeClassifyDO codeClassifyDO1:deletes){
//         //codeDuckingServiceI.insertCache1(CACHE_TYPE_CLASSIFY_DELETE,FRAMEWORK_DATA_DISABLED,DOCKING_DEFAULT_CLASSIFY, DOCKING_DEFAULT_CLASSIFYOID, codeClassifyDO1.getOid(), DateUtils.addHours(new Date(),1));//这里是当前时间
//
//         //存储要删除的数据
//         codeDuckingServiceI.cacheDeleteData(codeClassifyDO1.getOid(), codeClassifyDO1);
//      }
//      return (batchCBO!=null && batchCBO.getDeleteCbos() !=null &&batchCBO.getDeleteCbos().size() > 0)?BaseResult.successMsg(DELETE_SUCCESS):BaseResult.fail(DELETE_FAIL);
      return null;
      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));
      }
   }
}