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

@@ -20,36 +20,37 @@
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.vci.ubcs.code.dto.CodeClstemplateDTO;
import com.vci.ubcs.code.entity.CodeClstempattrEntity;
import com.vci.ubcs.code.entity.CodeClstemplateEntity;
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.CodeClstempattrMapper;
import com.vci.ubcs.code.mapper.CodeClstemplateMapper;
import com.vci.ubcs.code.mapper.*;
import com.vci.ubcs.code.service.ICodeClassifyService;
import com.vci.ubcs.code.service.ICodeClstemplateService;
import com.vci.ubcs.code.vo.CodeClstempattrVO;
import com.vci.ubcs.code.vo.CodeClstemplateVO;
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.web.pagemodel.DataGrid;
import com.vci.ubcs.starter.web.pagemodel.Tree;
import com.vci.ubcs.starter.web.util.BeanUtilForVCI;
import com.vci.ubcs.starter.web.util.VciBaseUtil;
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.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
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.FRAMEWORK_RELEASE_RELEASED;
import static com.vci.ubcs.code.constant.FrameWorkDefaultValueConstant.LC_STATUS;
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;

@@ -83,6 +84,23 @@
   private CodeTempbuttonServiceImpl codeTempbuttonServiceImpl;
   @Autowired(required = false)
   private CodeClsflowtempServiceImpl codeClsflowtempServiceImpl;
   @Autowired(required = false)
   private CodeClsflowtempMapper codeClsflowtempMapper;
   @Autowired(required = false)
   private CodeTempphaseMapper codeTempphaseMapper;
   @Autowired(required = false)
   private CodeTempbuttonMapper codeTempbuttonMapper;
   @Autowired(required = false)
   private CodePhaseattrMapper codePhaseattrMapper;
   @Autowired(required = false)
   private ICodeClassifyService codeClassifyService;
   @Autowired(required = false)
   private CodeClstemplateMapper codeClstemplateMapper;
   @Autowired(required = false)
   private CodePhaseattrServiceImpl codePhaseattrServiceImpl;



   @Override
   public IPage<CodeClstemplateVO> selectPlCodeClstemplatePage(IPage<CodeClstemplateVO> page, CodeClstemplateVO plCodeClstemplate) {
      return page.setRecords(baseMapper.selectPlCodeClstemplatePage(page, plCodeClstemplate));
@@ -119,8 +137,12 @@
//      VciParentQueryOption parentQueryOption = new VciParentQueryOption();
//      parentQueryOption.setParentFieldName(PARENT_FIELD_NAME);
//      queryWrapperForDO.parentQueryChild(treeQueryObject,parentQueryOption);
      CodeClstemplateEntity codeClstemplateEntity = new CodeClstemplateEntity();
      return baseMapper.selectList(Condition.getQueryWrapper(codeClstemplateEntity));
//      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);
   }

@@ -210,19 +232,20 @@
      BeanUtilForVCI.copyPropertiesIgnoreCase(codeClstemplateDTO,codeClassifyTemplateDOCopyFromDTO);

      //检查ts
      Map<String,Object> condition = new HashMap<>(2);
      condition.put("oid",codeClstemplateDTO.getOid());
      condition.put("ts",codeClstemplateDTO.getTs());
//      Map<String,Object> condition = new HashMap<>(2);
//      condition.put("oid",codeClstemplateDTO.getOid());
//      condition.put("ts",codeClstemplateDTO.getTs());
      CodeClstemplateEntity detail = baseMapper
         .selectOne(Condition.getQueryWrapper(condition,CodeClstemplateEntity.class));
      if(detail == null){//不是最新的不让改
         .selectById(codeClstemplateDTO.getOid());

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

   /**
@@ -273,6 +296,7 @@
    * @param codeClstemplateDTO 分类模板对象数据传输对象，oid和ts需要传输
    * @return 删除结果反馈：：success：成功，fail：失败
    */
   @Transactional
   @Override
   public R deleteCodeClassifyTemplate(CodeClstemplateDTO codeClstemplateDTO) {
      checkIsCanDelete(codeClstemplateDTO);
@@ -362,8 +386,8 @@
    * 参照树 分类模板对象
    * @param treeQueryObject 树形查询对象
    * @return 分类模板对象显示树
    * @throws VciBaseException 查询条件和分页出错的时候会抛出异常
    */
   @Transactional
   @Override
   public List<Tree> referTree(TreeQueryObject treeQueryObject) {
      if(treeQueryObject == null){
@@ -418,6 +442,7 @@
    * @param lcStatus
    * @return
    */
   @Transactional
   @Override
   public R updateLcStatus( String oid, String lcStatus){
      CodeClstemplateEntity codeClassifyTemplateDO = baseMapper.selectById(oid);
@@ -440,6 +465,7 @@
    * 升版
    * @param codeClassifyDTO
    */
   @Transactional
   @Override
   public R Upgrade(CodeClstemplateDTO codeClassifyDTO) {

@@ -454,93 +480,95 @@
      //需要新增的升级模板
//      ClientBusinessObject clientBusinessObject_template = boService.selectCBOByOid(codeClassifyDTO.getOid(), "codeclstemplate");
      CodeClstemplateEntity codeCls_template = baseMapper.selectById(templateOldOid);
      CodeClstemplateEntity codeCls_template_insert = null;
      CodeClstemplateEntity codeCls_template_insert = new CodeClstemplateEntity();
//         ClientBusinessObject clientBusinessObject_template_insert = null;
//      try {
////         clientBusinessObject_template_insert = clientBusinessObjectOperation.reviseBusinessObject(clientBusinessObject_template, "");
////         codeCls_template_insert.setOid((new ObjectUtility()).getNewObjectID36());
////         toBo.setRevisionid((new ObjectUtility()).getNewObjectID36());
//         codeCls_template_insert.setNameOid(codeCls_template.getNameOid());
//         codeCls_template_insert.setBtmname(codeCls_template.getBtmname());
////         codeCls_template_insert.setIsLast(1);
////         codeCls_template_insert.setIsFirstr(0);
////         codeCls_template_insert.setIsFirstv(1);
////         codeCls_template_insert.setIsLastV(1);
//         codeCls_template_insert.setCreator(AuthUtil.getUser().getUserName());
//         codeCls_template_insert.setCreateTime(new Date());
//         codeCls_template_insert.setLastModifier(AuthUtil.getUser().getUserName());
//         codeCls_template_insert.setLastModifyTime(new Date());
//         codeCls_template_insert.setRevisionRule(codeCls_template.getRevisionRule());
//         codeCls_template_insert.setVersionRule(codeCls_template.getVersionRule());
//         RevisionValueObject rvObj = this.getNextRevision(fromBo.getBtmName(), fromBo.getNameoid(), item.revRuleName, item.revInput, revisionVal);
//         codeCls_template_insert.setRevisionSeq(rvObj.getRevisionSeq());
//         codeCls_template_insert.setRevisionValue(rvObj.getRevisionVal());
//         clientBusinessObject_template_insert = clientBusinessObjectOperation.reviseBusinessObject(clientBusinessObject_template, "");
         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(AuthUtil.getUser().getUserName());
         codeCls_template_insert.setCreateTime(new Date());
         codeCls_template_insert.setLastModifier(AuthUtil.getUser().getUserName());
         codeCls_template_insert.setLastModifyTime(new Date());
         codeCls_template_insert.setRevisionRule(codeCls_template.getRevisionRule());
         codeCls_template_insert.setVersionRule(codeCls_template.getVersionRule());
         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());
//         VersionValueObject versionObj = this.getVersionValue(item.verRuleName);
//         codeCls_template_insert.setVersionSeq(versionObj.getVersionSeq());
//         codeCls_template_insert.setVersionValue(versionObj.getVersionVal());
//         codeCls_template_insert.setLctId(codeCls_template.getLctId());
//         codeCls_template_insert.setLcStatus(this.getLcFirstStatus(item.lifeCycle));
//         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(AuthUtil.getUser().getUserName());
////         codeCls_template_insert.setCheckinBy(userName);
//         codeCls_template_insert.setCopyFromVersion(codeCls_template.getOid());
         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(AuthUtil.getUser().getUserName());
//         codeCls_template_insert.setCheckinBy(userName);
         codeCls_template_insert.setCopyFromVersion(codeCls_template.getOid());
//      }catch (VCIError e){
//         e.printStackTrace();
//         logger.error("===============>分类模板-升版复制出错oid： "+templateOldOid+",mes"+e.error_message);
//         return BaseResult.error("升版出错");
//      }
//
//
//      CodeClassifyTemplateDO codeClassifyTemplateDO = new CodeClassifyTemplateDO();
      int insertCount = baseMapper.insert(codeCls_template_insert);
//      CodeClstemplateEntity codeClassifyTemplateDO = new CodeClstemplateEntity();
//      BeanUtilForVCI.copyPropertiesIgnoreCase(codeClassifyDTO,codeClassifyTemplateDO);
//      WebUtil.copyValueToObjectFromCbos(clientBusinessObject_template_insert,codeClassifyTemplateDO);
//      //modify by weidy@2022-2-27
//      //升版后不能使用insert方法，因为那个永远是新增一条数据，
//      //上方先从dto转给do，然后把升版的初始化的属性拷贝给do，最后再从do拷贝到cbo上
      //modify by weidy@2022-2-27
      //升版后不能使用insert方法，因为那个永远是新增一条数据，
      //上方先从dto转给do，然后把升版的初始化的属性拷贝给do，最后再从do拷贝到cbo上
//      WebUtil.copyValueToCboFromObj(clientBusinessObject_template_insert,codeClassifyTemplateDO);
//      //升版过后的模板oid
//      String templateNewOid = codeClassifyTemplateDO.getOid();
//
//      //需要复制的模板属性
//      //查询老模板下边的所有属性，赋值新模板oid
      //升版过后的模板oid
      String templateNewOid = codeCls_template_insert.getOid();

      //需要复制的模板属性
      //查询老模板下边的所有属性，赋值新模板oid
//      VciQueryWrapperForDO codeClassifyTemplateAttrQuery = new VciQueryWrapperForDO(CodeClassifyTemplateAttrDO.class);
//      codeClassifyTemplateAttrQuery.addQueryMap("classifyTemplateOid",templateOldOid);
      Map<String,Object> condition = new HashMap<>(1);
      condition.put("classifyTemplateOid",templateOldOid);
      List<CodeClstempattrEntity> codeClstempattrEntities = codeClstempattrMapper.selectByMap(condition);
//      List<CodeClassifyTemplateAttrDO> codeClassifyTemplateAttrDOList = codeClassifyTemplateAttrDaoI.selectByWrapper(codeClassifyTemplateAttrQuery);
//      for (CodeClassifyTemplateAttrDO codeClassifyTemplateAttrDO :codeClassifyTemplateAttrDOList){
      for (CodeClstempattrEntity codeClassifyTemplateAttrDO :codeClstempattrEntities){
//         String attrOid = VciBaseUtil.getPk();
//         codeClassifyTemplateAttrDO.setOid(attrOid);
//         codeClassifyTemplateAttrDO.setClassifyTemplateOid(templateNewOid);
//      }
//
//      //复制模板流程
//      List<CodeClassifyProcessTempDO>  codeClassifyProcessTempDOList = copyTemplateProcess(templateOldOid,templateNewOid);
//
//      //复制模板阶段，阶段属性
//      Map phase_attrMap = copyTemplatePhase_attr(templateOldOid,templateNewOid);
//
//      List<CodeTemplatePhaseDO> codeClassifyPhaseDOList = (ArrayList<CodeTemplatePhaseDO>)phase_attrMap.get("phase");//模板阶段
//      List<CodePhaseAttrDO> codePhaseAttrDOList = (ArrayList<CodePhaseAttrDO>)phase_attrMap.get("phaseAttr");//阶段属性
//
//      //复制模板按钮
//      List<CodeClassifyTemplateButtonDO> codeClassifyTemplateButtonDOList = copyTemplateButton(templateOldOid,templateNewOid);
//
//      //一起保存数据
         codeClassifyTemplateAttrDO.setOid(null);
         codeClassifyTemplateAttrDO.setClassifytemplateoid(templateNewOid);
         codeClstempattrMapper.insert(codeClassifyTemplateAttrDO);
      }

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

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

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

      //一起保存数据
//      WebUtil.setPersistence(false);//不执行保存
//      //保存模板
      //保存模板
//      BatchCBO batchCBOTemplate = new BatchCBO();
//      //batchCBO保存的时候没有能够自动update源数据的isLastR
//      //batchCBOTemplate.getCreateCbos().add(clientBusinessObject_template_insert);
//      //使用saveRevisionBuisnessObject可以解决这个问题，这里先暂时执行两次保存
      //batchCBO保存的时候没有能够自动update源数据的isLastR
      //batchCBOTemplate.getCreateCbos().add(clientBusinessObject_template_insert);
      //使用saveRevisionBuisnessObject可以解决这个问题，这里先暂时执行两次保存
//      try {
//         clientBusinessObjectOperation.saveRevisionBuinessObject(clientBusinessObject_template_insert);
//      } catch (VCIError vciError) {
//         throw new VciBaseException("升版保存出错了",new String[0],vciError);
//      }
//      // end --modify by lihang @20220408
//      //codeClassifyTemplateMapper.insert(codeClassifyTemplateDO);
//      //保存模板属性
      // end --modify by lihang @20220408
      //codeClassifyTemplateMapper.insert(codeClassifyTemplateDO);
      //保存模板属性
//      if(!CollectionUtils.isEmpty(codeClassifyTemplateAttrDOList)){
//         BatchCBO batchCBOTemplateAttr = codeClassifyTemplateAttrDaoI.batchInsert(codeClassifyTemplateAttrDOList);
//         batchCBOTemplate.copyFromOther(batchCBOTemplateAttr);
@@ -572,8 +600,432 @@
//      WebUtil.setPersistence(true);//执行保存
//
//      boService.persistenceBatch(batchCBOTemplate);//一起执行保存
//

//      return BaseResult.success("升版成功！");
      return R.success("升版成功！");
   }

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

      //复制模板
      CodeClstemplateEntity 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);
      List<CodeClstemplateEntity> codeClassifyTemplateDOList = new ArrayList<CodeClstemplateEntity>();
      codeClassifyTemplateDOList.add(codeClassifyTemplateDO_old);

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

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

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

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

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

//      baseMapper.insert(codeClassifyTemplateDOList);
      this.saveBatch(codeClassifyTemplateDOList);
      codeTempbuttonServiceImpl.saveBatch(codeClassifyTemplateButtonDOList);
      codeClsflowtempServiceImpl.saveBatch(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<CodeClsflowtempEntity> copyTemplateProcess(String templateOldOid,String templateNewOid){
//      VciQueryWrapperForDO processWrapper = new VciQueryWrapperForDO(CodeClassifyProcessTempDO.class);
//      processWrapper.addQueryMap("classifyTemplateOid",templateOldOid);
      Map<String,Object> condition = new HashMap<>(1);
      condition.put("classifyTemplateOid",templateOldOid);
      List<CodeClsflowtempEntity> codeClsflowtempEntities = codeClsflowtempMapper.selectByMap(condition);
//      List<CodeClassifyProcessTempDO>  codeClassifyProcessTempDOList = codeClassifyProcessTempDaoI.selectByWrapper(processWrapper);//要保存的新的模板流程
      for (CodeClsflowtempEntity codeClassifyProcessTempDO:codeClsflowtempEntities){
//         String newOid = VciBaseUtil.getPk();
         codeClassifyProcessTempDO.setOid(null);
         //codeClassifyProcessTempDO.setCodeClassifyOid(templateNewOid);
         codeClassifyProcessTempDO.setClassifytemplateoid(templateNewOid);
//         codeClsflowtempMapper.insert(codeClassifyProcessTempDO);
         //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<CodeTempphaseEntity> 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 (CodeTempphaseEntity codeTemplatePhaseDO:codeTempphaseEntities){
         String oldoid = codeTemplatePhaseDO.getOid();
         String newOid = VciBaseUtil.getPk();
         codeTemplatePhaseDO.setOid(newOid);
         codeTemplatePhaseDO.setCodeclassifytemplateoid(templateNewOid);
         phaseKeyMap.put(oldoid,newOid);
         phaseOidList.add(oldoid);
      }

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

      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 (CodePhaseattrEntity 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<CodeTempbuttonEntity> 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<CodeTempbuttonEntity> codeTempbuttonEntities = codeTempbuttonMapper.selectByMap(condition);
//      List<CodeClassifyTemplateButtonDO> codeClassifyTemplateButtonDOList = codeClassifyTemplateButtonDaoI.selectByWrapper(buttonWrapper);
      for (CodeTempbuttonEntity codeClassifyTemplateButtonDO:codeTempbuttonEntities){
//         String newOid = VciBaseUtil.getPk();
         codeClassifyTemplateButtonDO.setOid(null);
         codeClassifyTemplateButtonDO.setClassifytemplateoid(templateNewOid);
      }
      return codeTempbuttonEntities;
   }


   /**
    * 复制模板属性
    */
   public List<CodeClstempattrEntity> 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);

//      List<CodeClstempattrEntity> codeClassifyTemplateAttrDOList = codeClassifyTemplateAttrDaoI.selectByWrapper(codeClassifyTemplateAttrQuery);
      List<CodeClstempattrEntity> codeClstempattrEntities = codeClstempattrMapper.selectByMap(condition);

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


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



      List<CodeClstemplateVO> doList = codeClstemplateMapper.selectPlCodeClstemplatePage(Condition.getPage(query), plCodeClstemplate);
      if (!CollectionUtils.isEmpty(doList)) {
//         QueryWrapper<CodeClstemplateVO> codeClstemplateVOQueryWrapper = new QueryWrapper<>();
//         codeClstemplateVOQueryWrapper.allEq(plCodeClstemplate);
         List<CodeClstemplateEntity> codeClstemplateEntity = new ArrayList<>();
         BeanUtils.copyProperties(doList,codeClstemplateEntity);
         dataGrid.setData(codeClassifyTemplateDO2VOs(codeClstemplateEntity));
         dataGrid.setTotal(VciBaseUtil.getInt(String.valueOf(codeClstemplateMapper.selectCount(Condition.getQueryWrapper(plCodeClstemplate)))));
      }
      return dataGrid;
   }


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

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

      //所有分类都没有业务类型，返回提示
      if(codeClassifyDOList.size()==0){
         return R.fail("添加模板添加失败,分类和上级分类都没有关联业务类型！");
      }

      //设置btmtypeid和name
      CodeClassify codeClassifyDO = codeClassifyDOList.get(0);
      codeClassifyTemplateDO.setBtmTypeId(codeClassifyDO.getBtmTypeId());
      codeClassifyTemplateDO.setBtmTypeName(codeClassifyDO.getBtmTypeName());
      codeClassifyTemplateDO.setLcStatus(FRAMEWORK_RELEASE_EDITING);
      codeClassifyTemplateDO.setTs(new Date());
      codeClassifyTemplateDO.setOwner(AuthUtil.getUser().getUserName());
      codeClassifyTemplateDO.setLctid("codeClsTempLc");
      codeClassifyTemplateDO.setVersionValue("1");
      codeClassifyTemplateDO.setVersionSeq(1);
      codeClassifyTemplateDO.setRevisionValue("1");
      codeClassifyTemplateDO.setRevisionSeq(1);
      codeClassifyTemplateDO.setVersionRule("0");
      codeClassifyTemplateDO.setRevisionRule("numberversionrule");
      codeClassifyTemplateDO.setLastModifyTime(new Date());
      codeClassifyTemplateDO.setLastModifier(AuthUtil.getUser().getUserName());
      codeClassifyTemplateDO.setCreator(AuthUtil.getUser().getUserName());
      codeClassifyTemplateDO.setCreateTime(new Date());
      codeClassifyTemplateDO.setLastV("1");
      codeClassifyTemplateDO.setLastR("1");
      codeClassifyTemplateDO.setFirstV("1");
      codeClassifyTemplateDO.setFirstR("1");
      codeClassifyTemplateDO.setBtmname("codeclstemplate");

      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(CodeClstemplateDTO codeClassifyTemplateDTO) throws VciBaseException{
      VciBaseUtil.alertNotNull(codeClassifyTemplateDTO,"数据对象",codeClassifyTemplateDTO.getOid(),"分类模板对象主键");
      //检查ts
      CodeClstemplateEntity codeClassifyTemplateDOCopyFromDTO = new CodeClstemplateEntity();
      BeanUtilForVCI.copyPropertiesIgnoreCase(codeClassifyTemplateDTO,codeClassifyTemplateDOCopyFromDTO);
      CodeClstemplateEntity 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());
         CodeClstemplateEntity 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().getUserName());
         codeClassifyTemplateDO.setLastModifyTime(new Date());
         baseMapper.updateById(codeClassifyTemplateDO);
      }
      return R.data(codeClassifyTemplateDO2VO(codeClassifyTemplateDO));
   }
}