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

@@ -16,14 +16,54 @@
 */
package com.vci.ubcs.code.service.impl;

import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.vci.ubcs.code.entity.CodeClstemplateEntity;
import com.vci.ubcs.code.vo.CodeClstemplateVO;
import com.vci.ubcs.code.mapper.CodeClstemplateMapper;
import com.vci.ubcs.code.service.ICodeClstemplateService;
import org.springblade.core.mp.base.BaseServiceImpl;
import org.springframework.stereotype.Service;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.vci.ubcs.code.constant.FrameWorkDefaultValueConstant;
import com.vci.ubcs.code.dto.CodeClassifyTemplateDTO;
import com.vci.ubcs.code.entity.*;
import com.vci.ubcs.code.enumpack.CodeClassifyTemplateLC;
import com.vci.ubcs.code.enumpack.FrameworkDataLCStatus;
import com.vci.ubcs.code.mapper.*;
import com.vci.ubcs.code.service.ICodeClassifyProcessTempService;
import com.vci.ubcs.code.service.ICodeClassifyService;
import com.vci.ubcs.code.service.ICodeClassifyTemplateAttrService;
import com.vci.ubcs.code.service.ICodeClstemplateService;
import com.vci.ubcs.code.vo.pagemodel.CodeClassifyTemplateAttrVO;
import com.vci.ubcs.code.vo.pagemodel.CodeClassifyTemplateVO;
import com.vci.ubcs.common.constant.CommonConstant;
import com.vci.ubcs.flow.core.entity.ProcessTemplate;
import com.vci.ubcs.flow.core.feign.IFlowClient;
import com.vci.ubcs.starter.exception.VciBaseException;
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.DefaultAttrAssimtUtil;
import com.vci.ubcs.starter.util.MdmBtmTypeConstant;
import com.vci.ubcs.starter.web.pagemodel.DataGrid;
import com.vci.ubcs.starter.web.pagemodel.PageHelper;
import com.vci.ubcs.starter.web.pagemodel.Tree;
import com.vci.ubcs.starter.web.util.BeanUtilForVCI;
import com.vci.ubcs.starter.web.util.VciBaseUtil;
import net.logstash.logback.encoder.org.apache.commons.lang3.StringUtils;
import org.springblade.core.mp.support.Condition;
import org.springblade.core.mp.support.Query;
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.factory.annotation.Autowired;
import org.springframework.cglib.beans.BeanMap;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils;

import java.util.*;
import java.util.stream.Collectors;

import static com.vci.ubcs.code.constant.FrameWorkDefaultValueConstant.*;
import static com.vci.ubcs.code.constant.FrameWorkLangCodeConstant.*;
import static com.vci.ubcs.code.service.impl.CodeClassifyServiceImpl.PARENT_FIELD_NAME;

/**
 * 编码库定义-模板管理 服务实现类
@@ -32,10 +72,1097 @@
 * @since 2023-04-10
 */
@Service
public class CodeClstemplateServiceImpl extends ServiceImpl<CodeClstemplateMapper, CodeClstemplateEntity> implements ICodeClstemplateService {
public class CodeClstemplateServiceImpl extends ServiceImpl<CodeClassifyTemplateMapper, CodeClassifyTemplate> implements ICodeClstemplateService {

   /**
    * 模板属性的服务
    */
   @Lazy
   @Autowired(required = false)
   ICodeClassifyTemplateAttrService codeClstempattrService;

   /**
    * 对象的操作
    */
   @Autowired(required = false)
   private RevisionModelUtil revisionModelUtil;

   @Autowired(required = false)
   private CodeClassifyTemplateAttrMapper codeClstempattrMapper;
   @Autowired(required = false)
   private CodeTempphaseServiceImpl codeTempphaseServiceImpl;
   @Autowired(required = false)
   private CodeClassifyTemplateButtonServiceImpl codeTempbuttonServiceImpl;
   @Autowired(required = false)
   private ICodeClassifyProcessTempService codeClsflowtempServiceImpl;
   //   @Autowired(required = false)
//   private CodeClsflowtempMapper codeClsflowtempMapper;
   @Autowired(required = false)
   private CodeTemplatePhaseMapper codeTempphaseMapper;
   @Autowired(required = false)
   private CodeClassifyTemplateButtonMapper codeTempbuttonMapper;
   @Autowired(required = false)
   private CodePhaseAttrMapper codePhaseattrMapper;
   @Autowired(required = false)
   private CodeClassifyMapper codeClassifyMapper;
   @Autowired(required = false)
   private ICodeClassifyService codeClassifyService;
   @Autowired(required = false)
   private CodeClassifyTemplateMapper codeClassifyTemplateMapper;
   @Autowired(required = false)
   private CodePhaseAttrServiceImpl codePhaseattrServiceImpl;
   @Autowired(required = false)
   private IFlowClient iFlowClient;

   @Override
   public IPage<CodeClstemplateVO> selectPlCodeClstemplatePage(IPage<CodeClstemplateVO> page, CodeClstemplateVO plCodeClstemplate) {
   public IPage<CodeClassifyTemplateVO> selectPlCodeClstemplatePage(IPage<CodeClassifyTemplateVO> page, CodeClassifyTemplateVO plCodeClstemplate) {
      return page.setRecords(baseMapper.selectPlCodeClstemplatePage(page, plCodeClstemplate));
   }

   /**
    * 查询分类模板对象 树
    * @param treeQueryObject 树查询对象
    * @return 分类模板对象 显示树
    */
   @Override
   public List<Tree> treeCodeClassifyTemplate(TreeQueryObject treeQueryObject) {
      List<CodeClassifyTemplate> doList =selectCodeClassifyTemplateDOByTree(treeQueryObject);

      List<CodeClassifyTemplateVO> voList = codeClassifyTemplateDO2VOs(doList);
      TreeWrapperOptions treeWrapperOptions = new TreeWrapperOptions(PARENT_FIELD_NAME);
      treeWrapperOptions.copyFromTreeQuery(treeQueryObject);
      return revisionModelUtil.doList2Trees(voList,treeWrapperOptions,(CodeClassifyTemplateVO s) ->{
         //可以在这里处理树节点的显示
         return s.getId() + " " + s.getName() + (FrameworkDataLCStatus.DISABLED.getValue().equalsIgnoreCase(s
            .getLcStatus()) ? (" 【停用】 ") : "");
      });
   }

   /**
    * 根据树形查询对象来查询数据对象
    *
    * @param treeQueryObject 树形查询对象
    * @return 查询结果,数据对象
    */
   @Override
   public List<CodeClassifyTemplate> selectCodeClassifyTemplateDOByTree(TreeQueryObject treeQueryObject) {
//      VciQueryWrapperForDO queryWrapperForDO = new VciQueryWrapperForDO(null,CodeClassifyTemplateDO.class);
//      VciParentQueryOption parentQueryOption = new VciParentQueryOption();
//      parentQueryOption.setParentFieldName(PARENT_FIELD_NAME);
//      queryWrapperForDO.parentQueryChild(treeQueryObject,parentQueryOption);
//      CodeClstemplateEntity codeClstemplateEntity = new CodeClstemplateEntity();
//      codeClstemplateEntity.set
      return baseMapper.selectCodeClassifyTemplateDOByTree(
         treeQueryObject.getConditionMap().get("codeclassifyoid"),
         treeQueryObject.getConditionMap().get("lcStatus"));
//      return baseMapper.selectList(Condition.getQueryWrapper(codeClstemplateEntity));
//      return codeClassifyTemplateMapper.selectByWrapper(queryWrapperForDO);
   }

   /**
    * 批量数据对象转换为显示对象
    * @param codeClassifyTemplateDOs 数据对象列表
    * @return 显示对象
    */
   @Override
   public List<CodeClassifyTemplateVO> codeClassifyTemplateDO2VOs(Collection<CodeClassifyTemplate> codeClassifyTemplateDOs) {
      return codeClassifyTemplateDO2VOs(codeClassifyTemplateDOs,false);
   }

   /**
    * 批量数据对象转换为显示对象
    * @param codeClassifyTemplateDOs 数据对象列表
    * @param hasAttr 是否包含属性
    * @return 显示对象
    */
   @Override
   public List<CodeClassifyTemplateVO> codeClassifyTemplateDO2VOs(Collection<CodeClassifyTemplate>  codeClassifyTemplateDOs, boolean hasAttr) {
      List<CodeClassifyTemplateVO> voList = new ArrayList<CodeClassifyTemplateVO>();
      if(!CollectionUtils.isEmpty(codeClassifyTemplateDOs)){
         for(CodeClassifyTemplate s: codeClassifyTemplateDOs){
            CodeClassifyTemplateVO vo =  codeClassifyTemplateDO2VO(s);
            if(vo != null){
               voList.add(vo);
            }
         }
      }
      if(hasAttr){
         //一个分类里面总不能超过1000个生效的版本吧！！！
         VciBaseUtil.switchCollectionForOracleIn(voList.stream().map(CodeClassifyTemplateVO::getOid).collect(Collectors.toList())).forEach(tempOids->{
            List<CodeClassifyTemplateAttrVO> attrVOList = codeClstempattrService.listCodeClassifyTemplateAttrByTemplateOids(tempOids);

            if(!CollectionUtils.isEmpty(attrVOList)){
               Map<String, List<CodeClassifyTemplateAttrVO>> attrVOMap = attrVOList.stream().collect(Collectors.groupingBy(s -> s.getClassifyTemplateOid()));

               voList.stream().forEach(templateVO->{
                  if(attrVOMap.containsKey(templateVO.getOid())){
                     List<CodeClassifyTemplateAttrVO> codeClstempattrVO = new ArrayList<>();
                     for (CodeClassifyTemplateAttrVO codeClassifyTemplateAttrVO : attrVOMap.get(templateVO.getOid())) {
                        codeClstempattrVO.add(codeClassifyTemplateAttrVO);
                     }
                     templateVO.setAttributes(codeClstempattrVO);
                  }
               });
            }
         });

      }
      return voList;
   }
   /**
    * 数据对象转换为显示对象
    * @param  codeClassifyTemplateDO 数据对象
    * @return 显示对象
    */
   @Override
   public  CodeClassifyTemplateVO codeClassifyTemplateDO2VO(CodeClassifyTemplate codeClassifyTemplateDO) {
      CodeClassifyTemplateVO vo = new CodeClassifyTemplateVO();
      if(codeClassifyTemplateDO != null){
         BeanUtilForVCI.copyPropertiesIgnoreCase(codeClassifyTemplateDO,vo);
         //如果有lcstatus的类的话
         vo.setLcStatusText(CodeClassifyTemplateLC.getTextByValue(vo.getLcStatus()));

      }
      return vo;
   }

   /**
    * 检查 分类模板对象是否删除
    * @param codeClstemplateDTO 分类模板对象数据传输对象，必须要有oid和ts属性
    * @return 执行结果 success为true为可以删除，false表示有数据引用，obj为true表示有下级
    */
   @Override
   public R checkIsCanDelete(CodeClassifyTemplateDTO codeClstemplateDTO) {
      VciBaseUtil.alertNotNull(codeClstemplateDTO,"数据传输对象",codeClstemplateDTO.getOid(),"主键");
      CodeClassifyTemplate codeClassifyTemplate = baseMapper.selectById(codeClstemplateDTO.getOid());
      return checkIsCanDeleteForDO(codeClstemplateDTO, codeClassifyTemplate);
   }

   /**
    * 校验是否可以删除，如果存在下级，并且下级有数据引用则不能删除
    * @param codeClstemplateDTO 数据传输对象
    * @param codeClassifyTemplate 数据库中的数据对象
    * @return success为true为可以删除，false表示有数据引用，obj为true表示有下级
    */
   private R checkIsCanDeleteForDO(CodeClassifyTemplateDTO codeClstemplateDTO, CodeClassifyTemplate codeClassifyTemplate) {
      CodeClassifyTemplate codeClassifyTemplateDOCopyFromDTO = new CodeClassifyTemplate();
      BeanUtilForVCI.copyPropertiesIgnoreCase(codeClstemplateDTO,codeClassifyTemplateDOCopyFromDTO);

      //检查ts
//      Map<String,Object> condition = new HashMap<>(2);
//      condition.put("oid",codeClstemplateDTO.getOid());
//      condition.put("ts",codeClstemplateDTO.getTs());
      CodeClassifyTemplate detail = baseMapper
         .selectById(codeClstemplateDTO.getOid());

      if(!detail.getTs().toString().equals(codeClstemplateDTO.getTs().toString())){//不是最新的不让改
         return R.fail("当前数据不是最新，请刷新后再修改！");
      }
      //校验下级是否有引用
      if(checkChildIsLinked(codeClassifyTemplate.getOid())){
         return R.fail(DATA_CASCADE_LINKED_NOT_DELETE);
      }
      return R.success(String.valueOf(checkHasChild(codeClassifyTemplate.getOid())));
   }

   /**
    * 检查是否有下级是否关联了数据
    *
    * @param oid 主键
    * @return true 表示有引用，false表示没有引用
    */
   @Override
   public boolean checkChildIsLinked(String oid) {
      VciBaseUtil.alertNotNull(oid,"主键");
      List<String> childOids = baseMapper.selectAllLevelChildOid(oid.trim());
      if(!CollectionUtils.isEmpty(childOids)){
         for(String childOid: childOids){
            if(!checkIsLinked(childOid)){
               return false;
            }
         }
         return true;
      }
      return false;
   }

   /**
    * 校验是否被引用
    * @param oid 主键
    */
   private boolean checkIsLinked(String oid){
      //TODO 添加需要校验引用的地方
      return false;
   }

   /**
    * 校验是否有下级节点，不校验是否关联了数据
    *
    * @param oid 主键
    * @return true表示有下级，false表示没有下级
    */
   @Override
   public boolean checkHasChild(String oid) {
      VciBaseUtil.alertNotNull(oid,"主键");
      return baseMapper.countAllLevelChildOid(oid.trim()) > 0;
   }


   /**
    * 删除分类模板对象
    * @param codeClstemplateDTO 分类模板对象数据传输对象，oid和ts需要传输
    * @return 删除结果反馈：：success：成功，fail：失败
    */
   @Transactional
   @Override
   public R deleteCodeClassifyTemplate(CodeClassifyTemplateDTO codeClstemplateDTO) {
      checkIsCanDelete(codeClstemplateDTO);
      VciBaseUtil.alertNotNull(codeClstemplateDTO,"分类模板对象数据对象",codeClstemplateDTO.getOid(),"分类模板对象的主键");

      CodeClassifyTemplate codeClassifyTemplateDO = baseMapper.selectById(codeClstemplateDTO.getOid());

      //只有编辑中才能删
      if(!CodeClassifyTemplateLC.EDITING.getValue().equals(codeClassifyTemplateDO.getLcStatus())){
         return R.fail("只有编辑中的，模板才能删除！");
      }
      R baseResult = checkIsCanDeleteForDO(codeClstemplateDTO,codeClassifyTemplateDO);

      //模板oid
      String templateOid = codeClstemplateDTO.getOid();

      int updateCount = 0;

//      WebUtil.setPersistence(false);//不执行保存
//      BatchCBO batchCBO = new BatchCBO();

      if(baseResult.isSuccess()) {
         //找下级的，这个是可以删除的时候
         List<String> childrenOids = baseMapper.selectAllLevelChildOid(codeClassifyTemplateDO.getOid().trim());
         if (!CollectionUtils.isEmpty(childrenOids)) {
            Collection<Collection<String>> childrenCollections = VciBaseUtil.switchCollectionForOracleIn(childrenOids);
            for (Collection<String> s : childrenCollections) {
               updateCount += baseMapper.deleteBatchIds(s);

//               batchCBO.copyFromOther(batchCBOi);
            }
         }
      }else{
         return baseResult;
      }
      //执行删除操作

      updateCount += baseMapper.deleteById(codeClassifyTemplateDO.getOid());
//      batchCBO.copyFromOther(batchCBO_delete);

      //删除模板属性
//      VciQueryWrapperForDO templateQueryWrapper = new VciQueryWrapperForDO(CodeClassifyTemplateAttrDO.class);
//      templateQueryWrapper.addQueryMap("classifyTemplateOid",templateOid);
      List<CodeClassifyTemplateAttr> codeClstempattrEntityList = codeClstempattrMapper.selectRefByOid(templateOid);

      if(!CollectionUtils.isEmpty(codeClstempattrEntityList)) {
         List<String> templateAttrOids = new ArrayList<String>();
         for (CodeClassifyTemplateAttr codeClstempattrEntity:codeClstempattrEntityList){
            templateAttrOids.add(codeClstempattrEntity.getOid());
         }

         updateCount += codeClstempattrMapper.deleteBatchIds(templateAttrOids);
//         batchCBO.copyFromOther(batchCBO_templateAttr_delete);
      }

      //调用模板阶段方法
      updateCount += codeTempphaseServiceImpl.codeTemplateDeleteTrigger(templateOid);

      //调用模板按钮方法
      updateCount += codeTempbuttonServiceImpl.codeTemplateDeleteTrigger(templateOid);

      //调用模板流程方法
      updateCount += codeClsflowtempServiceImpl.codeTemplateDeleteTrigger(templateOid);

      return updateCount > 0?R.success(DELETE_SUCCESS):R.fail(DELETE_FAIL);
   }


   /**
    * 主键获取分类模板对象
    * @param oid 主键
    * @return 分类模板对象显示对象
    */
   @Override
   public  CodeClassifyTemplateVO getObjectByOid(String oid) {
      return codeClassifyTemplateDO2VO(selectByOid(oid));
   }

   @Override
   public Collection<CodeClassifyTemplateVO> listCodeClassifyTemplateByOids(List<String> oidCollections) {
      VciBaseUtil.alertNotNull(oidCollections,"数据对象主键集合");
      List<CodeClassifyTemplate> codeClassifyTemplateDOList = listCodeClassifyTemplateDOByOidCollections(oidCollections);
      return codeClassifyTemplateDO2VOs(codeClassifyTemplateDOList);
   }

   /**
    * 参照树 分类模板对象
    * @param treeQueryObject 树形查询对象
    * @return 分类模板对象显示树
    */
   @Transactional
   @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);
      }
      treeQueryObject.getConditionMap().put(LC_STATUS,CodeClassifyTemplateLC.RELEASED.getValue());
      return treeCodeClassifyTemplate(treeQueryObject);
   }

   /**
    * 使用主键集合查询数据对象
    * @param oidCollections 主键的集合
    * @return 数据对象列表
    */
   private List<CodeClassifyTemplate> listCodeClassifyTemplateDOByOidCollections(Collection<String> oidCollections){
      List<CodeClassifyTemplate> codeClassifyTemplateDOList = new ArrayList<CodeClassifyTemplate>();
      if(!CollectionUtils.isEmpty(oidCollections)){
         Collection<Collection<String>> oidCollectionsList = VciBaseUtil.switchCollectionForOracleIn(oidCollections);
         for(Collection<String> oids: oidCollectionsList){
            List<CodeClassifyTemplate> tempDOList =  baseMapper.selectBatchIds(oids); //codeClassifyTemplateMapper.selectByPrimaryKeyCollection(oids);
            if(!CollectionUtils.isEmpty(tempDOList)){
               codeClassifyTemplateDOList.addAll(tempDOList);
            }
         }
      }
      return  codeClassifyTemplateDOList;
   }

   /**
    * 主键查询数据对象
    * @param oid 主键
    * @return  数据对象
    */
   private CodeClassifyTemplate selectByOid(String oid) {
      VciBaseUtil.alertNotNull(oid,"主键");
      CodeClassifyTemplate codeClassifyTemplate = baseMapper.selectById(oid.trim());
      if(codeClassifyTemplate == null || StringUtils.isBlank(codeClassifyTemplate.getOid())){
         throw new VciBaseException(DATA_OID_NOT_EXIST);
      }
      return codeClassifyTemplate;
   }

   /**
    * 启用、停用
    * @param oid
    * @param lcStatus
    * @return
    */
   @Transactional
   @Override
   public R updateLcStatus( String oid, String lcStatus){
      CodeClassifyTemplate codeClassifyTemplateDO = baseMapper.selectById(oid);
      //停用的时候，验证模板是否为已发布
      if(CodeClassifyTemplateLC.DISABLED.getValue().equals(lcStatus)){
         if(!CodeClassifyTemplateLC.RELEASED.getValue().equals(codeClassifyTemplateDO.getLcStatus())){
            return R.fail("模板未启用，不能停用！");
         }
      }

      if(lcStatus.equals(CodeClassifyTemplateLC.RELEASED.getValue())){
         QueryWrapper<CodeClassify> classifyQueryWrapper = new QueryWrapper<>();
         classifyQueryWrapper.eq("oid",codeClassifyTemplateDO.getCodeClassifyOid());
         classifyQueryWrapper.eq("lcstatus","Enabled");
         List<CodeClassify> codeClassifyList = codeClassifyService.selectByWrapper(classifyQueryWrapper);
         if(codeClassifyList.size()==0){
            return R.fail("查询到所属分类未启用，请先进行启用！！！");
         }
      }

      //启用、停用
      codeClassifyTemplateDO.setLcStatus(lcStatus);
      int u = baseMapper.updateById(codeClassifyTemplateDO);
      return u==0?R.fail("修改失败！"):R.success("修改成功");
   }

   /**
    * 升版
    * @param codeClassifyDTO
    */
   @Transactional
   @Override
   public R Upgrade(CodeClassifyTemplateDTO codeClassifyDTO) {

      //旧的模板oid
      String templateOldOid = codeClassifyDTO.getOid();
      //只有已发布的才能升版
      CodeClassifyTemplate codeClassifyTemplateDOOld =  baseMapper.selectById(templateOldOid);
      if(!FRAMEWORK_RELEASE_RELEASED.equals(codeClassifyTemplateDOOld.getLcStatus())){
         return R.fail("该模板未发布，不能升版！");
      }

      //需要新增的升级模板
      CodeClassifyTemplate codeCls_template = baseMapper.selectById(templateOldOid);
      CodeClassifyTemplate codeCls_template_insert = new CodeClassifyTemplate();
      codeCls_template_insert.setOid(VciBaseUtil.getPk());
      codeCls_template_insert.setRevisionOid(VciBaseUtil.getPk());
      codeCls_template_insert.setNameOid(codeCls_template.getNameOid());
      codeCls_template_insert.setBtmname(codeCls_template.getBtmname());
      codeCls_template_insert.setLastR(String.valueOf(1));
      codeCls_template_insert.setFirstR(String.valueOf(0));
      codeCls_template_insert.setFirstV(String.valueOf(1));
      codeCls_template_insert.setLastV(String.valueOf(1));
//      codeCls_template_insert.setCreator(String.valueOf(AuthUtil.getUser().getUserId()));
      codeCls_template_insert.setCreator(String.valueOf(AuthUtil.getUser().getAccount()));
      codeCls_template_insert.setCreateTime(new Date());
      codeCls_template_insert.setTs(new Date());
      // codeCls_template_insert.setLastModifier(String.valueOf(AuthUtil.getUser().getUserId()));
      codeCls_template_insert.setLastModifier(String.valueOf(AuthUtil.getUser().getAccount()));
      codeCls_template_insert.setLastModifyTime(new Date());
      codeCls_template_insert.setRevisionRule(codeCls_template.getRevisionRule());
      codeCls_template_insert.setVersionRule(codeCls_template.getVersionRule());
      codeCls_template_insert.setBtmTypeId(codeCls_template.getBtmTypeId());
      codeCls_template_insert.setBtmTypeName(codeCls_template.getBtmTypeName());
      codeCls_template_insert.setCodeClassifyOid(codeCls_template.getCodeClassifyOid());
      codeCls_template_insert.setCodeClassifyOidName(codeCls_template.getCodeClassifyOidName());
      Map rvObj = baseMapper.getNextRevision(codeCls_template.getNameOid());
      codeCls_template_insert.setRevisionSeq(Integer.parseInt(rvObj.get("REVISIONSEQ").toString()));
      codeCls_template_insert.setRevisionValue(rvObj.get("REVISIONVAL").toString());
      codeCls_template_insert.setVersionSeq(Integer.parseInt(rvObj.get("VERSIONSEQ").toString()));
      codeCls_template_insert.setVersionValue(rvObj.get("VERSIONVAL").toString());
      codeCls_template_insert.setLctid(codeCls_template.getLctid());
      codeCls_template_insert.setLcStatus("Editing");
      codeCls_template_insert.setId(codeCls_template.getId());
      codeCls_template_insert.setName(codeCls_template.getName());
      codeCls_template_insert.setDescription(codeCls_template.getDescription());
      codeCls_template_insert.setOwner(String.valueOf(AuthUtil.getUser().getUserId()));
      codeCls_template_insert.setCopyFromVersion(codeCls_template.getOid());
      int insertCount = baseMapper.insert(codeCls_template_insert);
      codeCls_template.setLastR("0");
      codeCls_template.setLastModifyTime(new Date());
      // codeCls_template.setLastModifier(String.valueOf(AuthUtil.getUser().getUserId()));
      codeCls_template.setLastModifier(String.valueOf(AuthUtil.getUser().getUserId()));
      baseMapper.updateById(codeCls_template);
      //升版过后的模板oid
      String templateNewOid = codeCls_template_insert.getOid();

      //需要复制的模板属性
      //查询老模板下边的所有属性，赋值新模板oid
      Map<String,Object> condition = new HashMap<>(1);
      condition.put("classifyTemplateOid",templateOldOid);
      List<CodeClassifyTemplateAttr> codeClstempattrEntities = codeClstempattrMapper.selectByMap(condition);
      for (CodeClassifyTemplateAttr codeClassifyTemplateAttrDO :codeClstempattrEntities){
         codeClassifyTemplateAttrDO.setOid(VciBaseUtil.getPk());
         codeClassifyTemplateAttrDO.setClassifyTemplateOid(templateNewOid);
         codeClstempattrMapper.insert(codeClassifyTemplateAttrDO);
      }

      //复制模板流程
      List<ProcessTemplate>  codeClassifyProcessTempDOList = copyTemplateProcess(templateOldOid,templateNewOid);
      //复制模板阶段，阶段属性
      Map phase_attrMap = copyTemplatePhase_attr(templateOldOid,templateNewOid);

      List<CodeTemplatePhase> codeClassifyPhaseDOList = (ArrayList<CodeTemplatePhase>)phase_attrMap.get("phase");//模板阶段
      List<CodePhaseAttr> codePhaseAttrDOList = (ArrayList<CodePhaseAttr>)phase_attrMap.get("phaseAttr");//阶段属性

      //复制模板按钮
      List<CodeClassifyTemplateButton> codeClassifyTemplateButtonDOList = copyTemplateButton(templateOldOid,templateNewOid);

      //保存模板流程
      if(!CollectionUtils.isEmpty(codeClassifyProcessTempDOList)) {
         iFlowClient.processBatchSave(codeClassifyProcessTempDOList);
      }
      //模板阶段
      if(!CollectionUtils.isEmpty(codeClassifyPhaseDOList)) {
         codeTempphaseServiceImpl.saveBatch(codeClassifyPhaseDOList);
      }

      //模板阶段属性
      if(!CollectionUtils.isEmpty(codePhaseAttrDOList)) {
         codePhaseattrServiceImpl.saveBatch(codePhaseAttrDOList);
      }
//      //模板按钮
      if(!CollectionUtils.isEmpty(codeClassifyTemplateButtonDOList)) {
         codeTempbuttonServiceImpl.saveBatch(codeClassifyTemplateButtonDOList);
      }
      return R.success("升版成功！");
   }

   @Override
   @Transactional
   public R copyTemplate(CodeClassifyTemplateDTO codeClassifyDTO) {
      //旧的模板oid
      String oldOid = codeClassifyDTO.getOid();
      //新的模板oid
      String newOid = VciBaseUtil.getPk();
      //分类oid,复制过来的新的分类oid
      String codeClassifyOid = codeClassifyDTO.getCodeclassifyoid();

      QueryWrapper<CodeClassifyTemplate> wrapper = new QueryWrapper<>();
      wrapper.eq("CODECLASSIFYOID",codeClassifyOid);
      Long aLong = baseMapper.selectCount(wrapper);
      if(aLong > 0){
         return R.fail("该分类下已有子模版，无法进行复制操作，仅能进行升版操作！");
      }

      //复制模板
      CodeClassifyTemplate codeClassifyTemplateDO_old = baseMapper.selectById(oldOid);//旧模板

      //验证，业务类型是不是一致
      CodeClassify codeClassifyDO_old = codeClassifyService.selectBtmOrParentBtm(codeClassifyTemplateDO_old.getCodeClassifyOid());
      if(codeClassifyDO_old==null){
         return R.fail("复制的模板所属分类以及上级没有业务类型，请重新选择!");
      }

      //找当前分类下的业务类型
      CodeClassify codeClassifyDO_new = codeClassifyService.selectBtmOrParentBtm(codeClassifyOid);
      if(codeClassifyDO_new==null){
         return R.fail("当前分类没有业务类型，请重新选择!");
      }

      if(!codeClassifyDO_old.getBtmTypeId().equals(codeClassifyDO_new.getBtmTypeId())){
         return R.fail("选择的分类和当前分类业务类型不一致，请重新选择!");
      }

      codeClassifyTemplateDO_old.setId(codeClassifyDTO.getId());//英文名称
      codeClassifyTemplateDO_old.setName(codeClassifyDTO.getName());//中文名称
      codeClassifyTemplateDO_old.setDescription(codeClassifyDTO.getDescription());//描述
      codeClassifyTemplateDO_old.setCodeClassifyOid(codeClassifyOid);//分类oid
      codeClassifyTemplateDO_old.setOid(newOid);
      codeClassifyTemplateDO_old.setTs(new Date());
      codeClassifyTemplateDO_old.setCreateTime(new Date());
      codeClassifyTemplateDO_old.setLastModifyTime(new Date());
      // 复制的模板生命周期改为编辑中
      codeClassifyTemplateDO_old.setLcStatus(FrameWorkDefaultValueConstant.FRAMEWORK_RELEASE_EDITING);
      List<CodeClassifyTemplate> codeClassifyTemplateDOList = new ArrayList<>();
      codeClassifyTemplateDOList.add(codeClassifyTemplateDO_old);

      //复制模板属性
      List<CodeClassifyTemplateAttr> codeClassifyTemplateAttrDOList = copyTemplateAttr(oldOid,newOid);

      //复制模板流程
      List<ProcessTemplate> codeClassifyProcessTempDOList = copyTemplateProcess(oldOid,newOid);

      //复制模板阶段，阶段属性
      Map phase_attrMap = copyTemplatePhase_attr(oldOid,newOid);

      List<CodeTemplatePhase> codeClassifyPhaseDOList = (ArrayList<CodeTemplatePhase>)phase_attrMap.get("phase");//模板阶段
      List<CodePhaseAttr> codePhaseAttrDOList = (ArrayList<CodePhaseAttr>)phase_attrMap.get("phaseAttr");//阶段属性

      //复制模板按钮
      List<CodeClassifyTemplateButton> codeClassifyTemplateButtonDOList = copyTemplateButton(oldOid,newOid);

//      baseMapper.insert(codeClassifyTemplateDOList);
      this.saveBatch(codeClassifyTemplateDOList);
      codeTempbuttonServiceImpl.saveBatch(codeClassifyTemplateButtonDOList);
      iFlowClient.processBatchSave(codeClassifyProcessTempDOList);
      codeClstempattrService.saveBatch(codeClassifyTemplateAttrDOList);
      codeTempphaseServiceImpl.saveBatch(codeClassifyPhaseDOList);
      codePhaseattrServiceImpl.saveBatch(codePhaseAttrDOList);
      //一起保存数据
//      WebUtil.setPersistence(false);//不执行保存
//      //保存模板
//      BatchCBO batchCBOTemplate = codeClassifyTemplateMapper.batchInsert(codeClassifyTemplateDOList);
//      //保存模板属性
//      if(!CollectionUtils.isEmpty(codeClassifyTemplateAttrDOList)) {
//         BatchCBO batchCBOTemplateAttr = codeClassifyTemplateAttrDaoI.batchInsert(codeClassifyTemplateAttrDOList);
//         batchCBOTemplate.copyFromOther(batchCBOTemplateAttr);
//      }
//
//      //保存模板流程
//      if(!CollectionUtils.isEmpty(codeClassifyProcessTempDOList)) {
//         BatchCBO batchCBOTemplateProcessAttr = codeClassifyProcessTempDaoI.batchInsert(codeClassifyProcessTempDOList);
//         batchCBOTemplate.copyFromOther(batchCBOTemplateProcessAttr);
//      }
//
//      //模板阶段
//      if(!CollectionUtils.isEmpty(codeClassifyPhaseDOList)) {
//         BatchCBO batchCBOTemplatePhaseAttr = codeTemplatePhaseDaoI.batchInsert(codeClassifyPhaseDOList);
//         batchCBOTemplate.copyFromOther(batchCBOTemplatePhaseAttr);
//      }
//
//      //模板阶段属性
//      if(!CollectionUtils.isEmpty(codePhaseAttrDOList)) {
//         BatchCBO batchCBOTemplatePhaseAttrAttr = codePhaseAttrDaoI.batchInsert(codePhaseAttrDOList);
//         batchCBOTemplate.copyFromOther(batchCBOTemplatePhaseAttrAttr);
//      }
//
//      //模板按钮
//      if(!CollectionUtils.isEmpty(codeClassifyTemplateButtonDOList)) {
//         BatchCBO batchCBOTemplateButtonAttr = codeClassifyTemplateButtonDaoI.batchInsert(codeClassifyTemplateButtonDOList);
//         batchCBOTemplate.copyFromOther(batchCBOTemplateButtonAttr);
//      }
//
//
//      WebUtil.setPersistence(true);//执行保存
//
//      boService.persistenceBatch(batchCBOTemplate);//一起执行保存
      return R.success("复制成功！");
   }


   private HashMap<String,Object> getVersionValue(int verRuleName) {
      HashMap<String,Object> obj = new HashMap<>(2);
      obj.put("VersionSeq",1);
      if (verRuleName == 0) {
         obj.put("VersionVal","1");
      } else if (verRuleName == 1) {
         obj.put("VersionVal","a");
      } else if (verRuleName == 2) {
         obj.put("VersionVal","0");
      }

      return obj;
   }

   /**
    * 复制模板流程
    */
   public List<ProcessTemplate> copyTemplateProcess(String templateOldOid,String templateNewOid){
      Map<String,Object> wrapperMap = new HashMap();
      wrapperMap.put("template_id",templateOldOid);
      R<List<ProcessTemplate>> listR = iFlowClient.selectByWrapper(wrapperMap);
      if(!listR.isSuccess()){
         throw new VciBaseException("查询模板流程时出错，请重试！");
      }
      List<ProcessTemplate> codeClsflowtempEntities = listR.getData();
      for (ProcessTemplate codeClassifyProcessTempDO:codeClsflowtempEntities){
         codeClassifyProcessTempDO.setId(null);
         codeClassifyProcessTempDO.setTemplateId(templateNewOid);
         //modify by lihang - @20220406 设置模板主键位置出错，导致升版的模板中的流程是空的。
      }
      return codeClsflowtempEntities;
   }


   /**
    * 复制模板阶段，模板属性
    * @param templateOldOid
    * @param templateNewOid
    * @return map phase:(List<CodeTemplatePhaseDO>) phaseAttr:(List<CodePhaseAttrDO>)
    */
   public Map copyTemplatePhase_attr(String templateOldOid,String templateNewOid){
      //模板阶段
//      VciQueryWrapperForDO phaseWrapper = new VciQueryWrapperForDO(CodeTemplatePhaseDO.class);
//      phaseWrapper.addQueryMap("codeClassifyTemplateOid",templateOldOid);
      Map<String,Object> condition = new HashMap<>(1);
      condition.put("codeclassifyTemplateOid",templateOldOid);
      List<CodeTemplatePhase> codeTempphaseEntities = codeTempphaseMapper.selectByMap(condition);
//      List<CodeTemplatePhaseDO>  codeClassifyPhaseDOList = codeTemplatePhaseDaoI.selectByWrapper(phaseWrapper);//要保存的新的模板流程
      Map<String,String> phaseKeyMap = new HashMap<String,String>();//需要复制的模板阶段属性,key:value,模板阶段老oid:模板属性新oid
      List<String> phaseOidList = new ArrayList<String>();
      for (CodeTemplatePhase codeTemplatePhaseDO:codeTempphaseEntities){
         String oldoid = codeTemplatePhaseDO.getOid();
         String newOid = VciBaseUtil.getPk();
         codeTemplatePhaseDO.setOid(newOid);
         codeTemplatePhaseDO.setCodeClassifyTemplateOid(templateNewOid);
         phaseKeyMap.put(oldoid,newOid);
         phaseOidList.add(oldoid);
      }

      //模板阶段的属性
      List<CodePhaseAttr> codePhaseAttrDOList = new ArrayList<CodePhaseAttr>();

      if(!CollectionUtils.isEmpty(phaseOidList)){//size()==0下边方法会报错
//         Map<String,String> conditionMap =  new HashMap<>();
//         conditionMap.put("codephaseoid", QueryOptionConstant.IN + "(" + VciBaseUtil.toInSql(phaseOidList.toArray(new String[0])) + ")");
//         codePhaseAttrDOList = codePhaseAttrDaoI.selectByCondition(conditionMap,new PageHelper(-1));
         codePhaseAttrDOList = codePhaseattrMapper.selectByPhaseaIds(VciBaseUtil.toInSql(phaseOidList.toArray(new String[0])));
      }
      for (CodePhaseAttr codePhaseAttrDO:codePhaseAttrDOList){
         String oldPhaseoid = codePhaseAttrDO.getCodePhaseOid();
//         String newOid = VciBaseUtil.getPk();
         codePhaseAttrDO.setOid(null);
         codePhaseAttrDO.setCodePhaseOid(phaseKeyMap.get(oldPhaseoid));
//         codePhaseattrMapper.insert(codePhaseAttrDO);
      }
      Map phaseMap = new HashMap();
      phaseMap.put("phase",codeTempphaseEntities);
      phaseMap.put("phaseAttr",codePhaseAttrDOList);
      return phaseMap;
   }

   /**
    * 复制模板按钮
    */
   public List<CodeClassifyTemplateButton> copyTemplateButton(String templateOldOid,String templateNewOid){

      Map<String,Object> condition = new HashMap<>(1);
      condition.put("classifyTemplateOid",templateOldOid);
//      VciQueryWrapperForDO buttonWrapper = new VciQueryWrapperForDO(CodeClassifyTemplateButtonDO.class);
//      buttonWrapper.addQueryMap("classifyTemplateOid",templateOldOid);
      List<CodeClassifyTemplateButton> codeTempbuttonEntities = codeTempbuttonMapper.selectByMap(condition);
//      List<CodeClassifyTemplateButtonDO> codeClassifyTemplateButtonDOList = codeClassifyTemplateButtonDaoI.selectByWrapper(buttonWrapper);
      for (CodeClassifyTemplateButton codeClassifyTemplateButtonDO:codeTempbuttonEntities){
//         String newOid = VciBaseUtil.getPk();
         codeClassifyTemplateButtonDO.setOid(null);
         codeClassifyTemplateButtonDO.setClassifyTemplateOid(templateNewOid);
      }
      return codeTempbuttonEntities;
   }


   /**
    * 复制模板属性
    */
   public List<CodeClassifyTemplateAttr> copyTemplateAttr(String templateOldOid,String templateNewOid){

//      VciQueryWrapperForDO codeClassifyTemplateAttrQuery = new VciQueryWrapperForDO(CodeClassifyTemplateAttrDO.class);
//      codeClassifyTemplateAttrQuery.addQueryMap("classifyTemplateOid",templateOldOid);

//      Map<String,Object> condition = new HashMap<>(1);
//      condition.put("classifyTemplateOid",templateOldOid);
      QueryWrapper<CodeClassifyTemplateAttr> wrapper=new QueryWrapper<>();
      wrapper.eq("classifyTemplateOid",templateOldOid);

//      List<CodeClassifyTemplateAttr> codeClassifyTemplateAttrDOList = codeClassifyTemplateAttrDaoI.selectByWrapper(codeClassifyTemplateAttrQuery);
      List<CodeClassifyTemplateAttr> codeClstempattrEntities = codeClstempattrMapper.selectList(wrapper);

      for (CodeClassifyTemplateAttr codeClassifyTemplateAttrDO :codeClstempattrEntities){
//         String attrOid = VciBaseUtil.getPk();
         codeClassifyTemplateAttrDO.setOid(null);
         codeClassifyTemplateAttrDO.setClassifyTemplateOid(templateNewOid);
//         codeClstempattrMapper.insert(codeClassifyTemplateAttrDO);
      }
      return codeClstempattrEntities;
   }


   /**
    * 分类模板列表
    *
    * @param conditionMap 查询条件
    * @param pageHelper   分页对象
    * @return 显示对象
    * @throws VciBaseException 查询出错的时候会抛出异常
    */
   @Override
   public DataGrid<CodeClassifyTemplateVO> gridCodeClassifyTemplate(Map<String, String> conditionMap, PageHelper pageHelper) throws VciBaseException {
      DataGrid<CodeClassifyTemplateVO> dataGrid=new DataGrid<CodeClassifyTemplateVO>();
      //没有传分类id，不执行查询逻辑，直接返回
//      if(conditionMap.size()==0){
//         dataGrid.setData(new ArrayList<>());
//         dataGrid.setTotal(0);
//         return dataGrid;
//      }
//      if (pageHelper == null) {
//         pageHelper = new PageHelper(-1);
//      }
//      pageHelper.addDefaultDesc("revisionSeq");

//      CodeClassifyTemplateVO codeClstemplateVO = new CodeClassifyTemplateVO();


      CodeClassifyTemplate codeClstemplateQuery = new CodeClassifyTemplate();
//      BeanUtil.toBean(map,codeClstempattrVO);
//      BeanUtil
      CodeClassifyTemplateDTO codeClassifyTemplateDTO = new CodeClassifyTemplateDTO();
      BeanMap beanMap = BeanMap.create(codeClassifyTemplateDTO);
      beanMap.putAll(conditionMap);
//      BeanUtils.copyProperties(codeClstemplateVO,codeClstemplateQuery);
      BeanUtilForVCI.copyPropertiesIgnoreCase(codeClassifyTemplateDTO,codeClstemplateQuery);
      if (pageHelper == null) {
         pageHelper = new PageHelper(-1);
      }
//      IPage iPage = new IPage();
      Query query = new Query();
//      query.setSize(100);
      if(pageHelper.getLimit() != -1){
         query.setSize(pageHelper.getLimit());
         query.setCurrent(pageHelper.getPage());
         query.setDescs("versionValue");
      }

//      List<CodeClstemplateVO> doList = codeClstemplateMapper.selectPlCodeClstemplatePage(Condition.getPage(query), codeClstemplateVO);

      IPage<CodeClassifyTemplate> doList = baseMapper.
         selectPage(Condition.getPage(query), Condition.getQueryWrapper(codeClstemplateQuery));
      if (!CollectionUtils.isEmpty(doList.getRecords())) {
//         QueryWrapper<CodeClstemplateVO> codeClstemplateVOQueryWrapper = new QueryWrapper<>();
//         codeClstemplateVOQueryWrapper.allEq(plCodeClstemplate);
//         List<CodeClstemplateEntity> codeClstemplateEntity = new ArrayList<>();
//         BeanUtils.copyProperties(doList,codeClstemplateEntity);

         dataGrid.setData(codeClassifyTemplateDO2VOs(doList.getRecords()));
         dataGrid.setTotal(VciBaseUtil.getInt(String.valueOf(codeClassifyTemplateMapper.selectCount(Condition.getQueryWrapper(codeClstemplateQuery)))));
      }
      return dataGrid;
   }


   /**
    * 增加分类模板对象
    * @param codeClassifyTemplateDTO 分类模板对象数据传输对象
    * @return 执行结果
    * @throws VciBaseException 参数为空，唯一项，必输项不通过时会抛出异常
    */
   @Override
   public R<CodeClassifyTemplateVO> addSave(CodeClassifyTemplateDTO codeClassifyTemplateDTO) throws VciBaseException{
      VciBaseUtil.alertNotNull(codeClassifyTemplateDTO,"需要添加的数据对象");

      QueryWrapper<CodeClassifyTemplate> wrapper = new QueryWrapper<>();
      wrapper.eq("CODECLASSIFYOID",codeClassifyTemplateDTO.getCodeclassifyoid());
      Long aLong = baseMapper.selectCount(wrapper);
      if(aLong > 0){
         return R.fail("该分类下已有子模版，无法新增，仅能进行升版操作！");
      }
      //将DTO转换为DO
      CodeClassifyTemplate codeClassifyTemplateDO = new CodeClassifyTemplate();
      BeanUtilForVCI.copyPropertiesIgnoreCase(codeClassifyTemplateDTO,codeClassifyTemplateDO);

      //查询分类以及上级分类的业务类型btmtypeid、btmtypename
      List<CodeClassify> codeClassifyDOList = codeClassifyService.selectAllLevelParents(codeClassifyTemplateDTO.getCodeclassifyoid());

      //所有分类都没有业务类型，返回提示
      if(codeClassifyDOList.size()==0){
         return R.fail(DATA_OID_NOT_EXIST);
      }

      //设置btmtypeid和name
      DefaultAttrAssimtUtil.addDefaultAttrAssimt(codeClassifyTemplateDO, MdmBtmTypeConstant.CODE_CLASSIFY_TEMPLATE);
      CodeClassify codeClassifyDO = codeClassifyDOList.stream().filter(s -> StringUtils.isNotBlank(s.getBtmTypeId())).findFirst().get();
      codeClassifyTemplateDO.setBtmTypeId(codeClassifyDO.getBtmTypeId());
      codeClassifyTemplateDO.setBtmTypeName(codeClassifyDO.getBtmTypeName());
      codeClassifyTemplateDO.setLcStatus(FRAMEWORK_RELEASE_EDITING);
      codeClassifyTemplateDO.setOwner(String.valueOf(AuthUtil.getUser().getUserId()));
      codeClassifyTemplateDO.setLctid("codeClsTempLc");
      codeClassifyTemplateDO.setRevisionRule("numberversionrule");

      baseMapper.insert(codeClassifyTemplateDO);
      //默认添加模板属性
//        List<CodeClassifyTemplateAttrDO> attrDOList = new ArrayList<>();

//        CodeClassifyTemplateAttrDO codeAttr = new CodeClassifyTemplateAttrDO();
//        codeAttr.setId("id");
//        codeAttr.setName("企业编码");
//        codeAttr.setAttributeDataType("VTString");
//        codeAttr.setAttrTableWidth(150);
//        codeAttr.setOrderNum(1);
//        codeAttr.setFormDisplayFlag(BooleanEnum.TRUE.getValue());
//        codeAttr.setTableDisplayFlag(BooleanEnum.TRUE.getValue());
//        codeAttr.setClassifyTemplateOid(codeClassifyTemplateDO.getOid());
//        attrDOList.add(codeAttr);
//
//
//        CodeClassifyTemplateAttrDO groupAttr = new CodeClassifyTemplateAttrDO();
//        groupAttr.setId("name");
//        groupAttr.setName("集团码");
//        groupAttr.setAttributeDataType("VTString");
//        groupAttr.setAttrTableWidth(150);
//        groupAttr.setOrderNum(2);
//        groupAttr.setFormDisplayFlag(BooleanEnum.TRUE.getValue());
//        groupAttr.setTableDisplayFlag(BooleanEnum.TRUE.getValue());
//        groupAttr.setClassifyTemplateOid(codeClassifyTemplateDO.getOid());
//        attrDOList.add(groupAttr);
//
//        CodeClassifyTemplateAttrDO descAttr = new CodeClassifyTemplateAttrDO();
//        descAttr.setId("description");
//        descAttr.setName("描述");
//        descAttr.setAttrTableWidth(150);
//        descAttr.setAttributeDataType("VTString");
//        descAttr.setOrderNum(3);
//        descAttr.setFormDisplayFlag(BooleanEnum.TRUE.getValue());
//        descAttr.setTableDisplayFlag(BooleanEnum.TRUE.getValue());
//        descAttr.setClassifyTemplateOid(codeClassifyTemplateDO.getOid());
//        attrDOList.add(descAttr);
//
//        CodeClassifyTemplateAttrDO statusAttr = new CodeClassifyTemplateAttrDO();
//        statusAttr.setId("lcstatus");
//        statusAttr.setName("状态");
//        statusAttr.setAttrTableWidth(70);
//        statusAttr.setOrderNum(4);
//        statusAttr.setFormDisplayFlag(BooleanEnum.TRUE.getValue());
//        statusAttr.setTableDisplayFlag(BooleanEnum.TRUE.getValue());
//        statusAttr.setAttributeDataType("VTString");
//        statusAttr.setClassifyTemplateOid(codeClassifyTemplateDO.getOid());
//        attrDOList.add(statusAttr);
//
//
//        CodeClassifyTemplateAttrDO secAttr = new CodeClassifyTemplateAttrDO();
//        secAttr.setId("secretgrade");
//        secAttr.setName("密级");
//        secAttr.setAttrTableWidth(70);
//        secAttr.setAttributeDataType(VciFieldTypeEnum.VTInteger.name());
//        secAttr.setEnumId("Enumsecretgrade");
//        secAttr.setEnumName("密级");
//        secAttr.setOrderNum(4);
//        secAttr.setFormDisplayFlag(BooleanEnum.TRUE.getValue());
//        secAttr.setTableDisplayFlag(BooleanEnum.TRUE.getValue());
//        secAttr.setClassifyTemplateOid(codeClassifyTemplateDO.getOid());
//        attrDOList.add(secAttr);

      return R.data(codeClassifyTemplateDO2VO(codeClassifyTemplateDO));
   }

   /**
    * 修改分类模板对象
    * @param codeClassifyTemplateDTO 分类模板对象数据传输对象
    * @return 执行结果
    * @throws VciBaseException 参数为空，唯一项，必输项不通过时会抛出异常
    */
   @Override
   public R editSave(CodeClassifyTemplateDTO codeClassifyTemplateDTO) throws VciBaseException{
      VciBaseUtil.alertNotNull(codeClassifyTemplateDTO,"数据对象",codeClassifyTemplateDTO.getOid(),"分类模板对象主键");
      //检查ts
      CodeClassifyTemplate codeClassifyTemplateDOCopyFromDTO = new CodeClassifyTemplate();
      BeanUtilForVCI.copyPropertiesIgnoreCase(codeClassifyTemplateDTO,codeClassifyTemplateDOCopyFromDTO);
      CodeClassifyTemplate codeClassifyTemplateDO = null;
      if(codeClassifyTemplateDOCopyFromDTO.getOid() == null){
         baseMapper.insert(codeClassifyTemplateDOCopyFromDTO);
         return R.data(codeClassifyTemplateDOCopyFromDTO);
      }else{
//         Map<String,Object> condition = new HashMap<>(2);
//         condition.put("oid",codeClassifyTemplateDOCopyFromDTO.getOid());
//         condition.put("ts",codeClassifyTemplateDOCopyFromDTO.getTs());
         CodeClassifyTemplate detail = baseMapper
            .selectById(codeClassifyTemplateDOCopyFromDTO.getOid());
         //      boolean tsBoolean = boService.checkTs(codeClassifyTemplateAttrDOListemplateDOCopyFromDTO);
         if(detail.getTs().compareTo(codeClassifyTemplateDOCopyFromDTO.getTs()) != 0){//不是最新的不让改
            return R.fail("当前数据不是最新，请刷新后再修改！");
         }

         //将DTO转换为DO
         codeClassifyTemplateDO = selectByOid(codeClassifyTemplateDTO.getOid());
         String lcstatus = codeClassifyTemplateDO.getLcStatus();
         String versionvalue = codeClassifyTemplateDO.getVersionValue();

         //只有编辑中才能修改
         if(!CodeClassifyTemplateLC.EDITING.getValue().equals(codeClassifyTemplateDO.getLcStatus())){
            return R.fail("只有编辑中的，模板才能修改！");
         }
         revisionModelUtil.copyFromDTOIgnore(codeClassifyTemplateDTO,codeClassifyTemplateDO);
         //不修改版本号和状态
         codeClassifyTemplateDO.setLcStatus(lcstatus);
         codeClassifyTemplateDO.setVersionValue(versionvalue);
         codeClassifyTemplateDO.setTs(new Date());
         codeClassifyTemplateDO.setLastModifier(AuthUtil.getUser().getAccount());
         codeClassifyTemplateDO.setLastModifyTime(new Date());
         baseMapper.updateById(codeClassifyTemplateDO);
      }
      return R.data(codeClassifyTemplateDO2VO(codeClassifyTemplateDO));
   }

   /**
    *根据父分类id去查找叶子节点的模板，如果没查到则认为模板在上层建立，则根据分类去查当前模板
    * @param codeClassifyOid 父分类的主键
    * @return
    */
   @Override
   public List<CodeClassifyTemplateVO> childTemplates(String codeClassifyOid){
      List<CodeClassifyTemplateVO> codeClassifyTemplateVOList=new ArrayList<>();
//      Map<String/**模板的主键**/,String/**分类的主键**/> childHasTemplateMap =baseMapper
//         .selectChildHasReleaseTemplate(FrameWorkDefaultValueConstant.FRAMEWORK_DATA_ENABLED,
//            codeClassifyOid,CodeClassifyTemplateLC.RELEASED.getValue());
      List<Map<String,String>> childHasTemplateList = baseMapper
         .selectChildHasReleaseTemplate(FrameWorkDefaultValueConstant.FRAMEWORK_DATA_ENABLED,
            codeClassifyOid,CodeClassifyTemplateLC.RELEASED.getValue());
      Map<String/**模板的主键**/,String/**分类的主键**/> childHasTemplateMap = new HashMap<>();
      if(!CollectionUtils.isEmpty(childHasTemplateList)){
         childHasTemplateList.stream().forEach(cbo->{
            // 有时候查询出来的key是大写，有时候是小写的key
            String oid = Func.isEmpty(cbo.get("OID")) ? cbo.get("oid"):cbo.get("OID");
            String clsoid = Func.isEmpty(cbo.get("CLSOID")) ? cbo.get("clsoid") : cbo.get("CLSOID");
            childHasTemplateMap.put(oid,clsoid);
         });
      }

      Set<String> templateOid = childHasTemplateMap.keySet();
      List<CodeClassifyTemplate>  classifyTemplateDOS=new ArrayList<>();
      if(!CollectionUtils.isEmpty(templateOid)) {
         classifyTemplateDOS= this.listCodeClassifyTemplateDOByOidCollections(templateOid);
      }else{
         classifyTemplateDOS=selectOnlyTemplateByClassifyOid(codeClassifyOid);
      }
      List<CodeClassifyTemplateVO> templateVOList = codeClassifyTemplateDO2VOs(classifyTemplateDOS, true);
      if(!CollectionUtils.isEmpty(templateVOList)){
         codeClassifyTemplateVOList.addAll(templateVOList);
      }
      return codeClassifyTemplateVOList;
   }

   /**
    * 使用分类主键递归查询
    * @param codeClassifyOid 分类的主键
    * @return 模板的数据对象
    */
   private List<CodeClassifyTemplate> selectOnlyTemplateByClassifyOid(String codeClassifyOid){
      //1.直接查询，看看这个分类下面有没有发布状态的模板
      //2.如果没有，则往上找分类的内容，这个分类层级不会太多，所以直接递归即可
      //3.如果分类下面添加了模板，但是没有发布，则说明模板可能还在编辑的状态，依然使用上级分类

//      Map<String,String> conditionMap = new HashMap<>();
//      conditionMap.put("codeClassifyOid",codeClassifyOid);
//      conditionMap.put("lcstatus",CodeClassifyTemplateLC.RELEASED.getValue());
      QueryWrapper<CodeClassifyTemplate> wrapper=new QueryWrapper<>();
      wrapper.eq("codeClassifyOid",codeClassifyOid)
         .eq("lcstatus",CodeClassifyTemplateLC.RELEASED.getValue());

      List<CodeClassifyTemplate> templateDOS = baseMapper.selectList(wrapper);
      if(CollectionUtils.isEmpty(templateDOS)){
         //递归找上级的模板
         CodeClassify classifyDO = codeClassifyMapper.selectById(codeClassifyOid);
//            codeClassifyDaoI.selectByPrimaryKey(codeClassifyOid);
         if(Func.isEmpty(classifyDO)){
            //说明已经是顶了，也没找到的话，那就返回了
            return new ArrayList<>();
         }
         if(StringUtils.isNotBlank(classifyDO.getParentCodeClassifyOid())) {
            return selectOnlyTemplateByClassifyOid(classifyDO.getParentCodeClassifyOid());
         }else{
            return new ArrayList<>();
         }
      }else{
         return templateDOS;
      }
   }

   /**
    * 使用主题库的分类主键，获取生效的模板
    *
    * @param codeClassifyOid 主题库分类主键
    * @param hasAttribute    是否包含属性
    * @return 模板的信息
    */
   @Override
   public List<CodeClassifyTemplateVO> listReleaseTemplateByClassifyOid(String codeClassifyOid, boolean hasAttribute) {
      VciBaseUtil.alertNotNull(codeClassifyOid,"主题库分类主键");
      List<CodeClassifyTemplate> templateDOS = selectOnlyTemplateByClassifyOid(codeClassifyOid);
      if(CollectionUtils.isEmpty(templateDOS)){
         throw new VciBaseException("当前分类，以及其上级分类都没有设置模板");
      }
      List<CodeClassifyTemplateVO> templateVOList = codeClassifyTemplateDO2VOs(templateDOS, true);
      return sortTemplateByRevision(templateVOList);
   }

   /**
    * 用模板的版本来排序
    * @param templateVOList 模板的显示对象
    * @return 排序后的列表
    */
   @Override
   public List<CodeClassifyTemplateVO> sortTemplateByRevision(List<CodeClassifyTemplateVO> templateVOList){
      if(!CollectionUtils.isEmpty(templateVOList) && templateVOList.size() >1){
         //获取版本号最大的那个
         templateVOList = templateVOList.stream().sorted((o1,o2)->
            Integer.valueOf(o1.getRevisionSeq()).compareTo(Integer.valueOf(o2.getRevisionValue()))
         ).collect(Collectors.toList());
      }
      return templateVOList;
   }

   /**
    * 主键获取分类模板对象(包含属性）
    *
    * @param oid 主键
    * @return 分类模板对象显示对象
    * @throws VciBaseException 参数为空，数据不存在时会抛出异常
    */
   @Override
   public CodeClassifyTemplateVO getObjectHasAttrByOid(String oid) throws VciBaseException {
      List<CodeClassifyTemplate> doList = new ArrayList<>();
      doList.add(selectByOid(oid));
      List<CodeClassifyTemplateVO> templateVOS = codeClassifyTemplateDO2VOs(doList, true);
      return CollectionUtils.isEmpty(templateVOS)?null:templateVOS.get(0);
   }
}