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

@@ -1,14 +1,28 @@
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.entity.CodeClassify;
import com.vci.ubcs.code.mapper.CodeClassifyMapper;
import com.vci.ubcs.code.service.ICodeClassifyService;
import com.vci.ubcs.code.vo.pagemodel.CodeClassifyVO;
import com.vci.ubcs.core.log.exception.ServiceException;
import jodd.bean.BeanUtil;
import org.springblade.core.mp.support.Condition;
import org.springblade.core.secure.utils.AuthUtil;
import org.springblade.core.tool.api.R;
import org.springframework.beans.BeanUtils;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;

import javax.annotation.Resource;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

@Service
public class ICodeClassifyServiceImpl extends ServiceImpl<CodeClassifyMapper, CodeClassify> implements ICodeClassifyService {
@@ -26,5 +40,213 @@
      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);

      //先简称是否有关联模板，有模板要先删除
//      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;
   }

}