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

@@ -38,6 +38,7 @@
import com.vci.ubcs.code.service.ICodeRuleService;
import com.vci.ubcs.code.vo.pagemodel.CodeBasicSecVO;
import com.vci.ubcs.code.vo.pagemodel.CodeClassifyVO;
import com.vci.ubcs.code.vo.pagemodel.CodeFixedValueVO;
import com.vci.ubcs.code.vo.pagemodel.CodeRuleVO;
import com.vci.ubcs.code.wrapper.CodeClassifyWrapper;
import com.vci.ubcs.code.wrapper.CodeRuleWrapper;
@@ -443,8 +444,7 @@
         }
         // 发布时将码段类型按照字符串分隔的形式拼接并存储
         String secTypeStr = codeBasicSecService.listCodeBasicSecByRuleOid(codeRuleDO.getOid()).stream().map(CodeBasicSecVO::getSecType).collect(Collectors.joining(","));
         codeRuleDO.setBasicSecTypes(secTypeStr);
         count = codeRuleMapper.update(null,wrapper.set(CodeRule::getLcStatus, CodeRuleLC.RELEASED.getValue()));
         count = codeRuleMapper.update(null,wrapper.set(CodeRule::getLcStatus, CodeRuleLC.RELEASED.getValue()).set(CodeRule::getBasicSecTypes,secTypeStr));
      } else {
         return R.fail("暂不支持的操作类型");
      }
@@ -507,76 +507,105 @@
   @Override
   public R checkLikeCodeRule(String oid) throws VciBaseException {
      // 1、查询出当前要发布的规则
      CodeRuleVO codeRuleVO = getObjectHasSecByOid(oid);
      // 当前发布的规则不存在码段信息
      if(Func.isEmpty(codeRuleVO.getSecVOList())){
         return R.data(null);
      CodeRuleVO releaseCodeRule = getObjectHasSecByOid(oid);
      // 当前发布的规则不存在码段信息，直接空信息返回
      if(Func.isEmpty(releaseCodeRule.getSecVOList())){
         return R.success("");
      }
      // 2、找出与当前发布的规则码段顺序一致的规则
      String secTypes = codeRuleVO.getSecVOList().stream().map(CodeBasicSecVO::getSecType).collect(Collectors.joining(","));
      //先查询出所有已发布的编码规则
      List<CodeRule> codeRuleList = codeRuleMapper.selectList(Wrappers.<CodeRule>query().lambda().eq(CodeRule::getLcStatus, FrameWorkDefaultValueConstant.FRAMEWORK_RELEASE_RELEASED));
      String secTypes = releaseCodeRule.getSecVOList().stream().map(CodeBasicSecVO::getSecType).collect(Collectors.joining(","));
      // 查询出所有已发布的编码规则中码段类型顺序与当前要发布的规则顺序一致的编码规则，此时已近过滤掉大部分规则，运算量减小
      List<CodeRule> codeRuleList = codeRuleMapper.selectList(Wrappers.<CodeRule>query().lambda()
         .eq(CodeRule::getLcStatus, FrameWorkDefaultValueConstant.FRAMEWORK_RELEASE_RELEASED)
         .eq(CodeRule::getBasicSecTypes,secTypes)
      );
      // 为空，证明不存在类同的编码规则直接返回
      if(Func.isEmpty(codeRuleList)){
         return R.success("");
      }
      // 查询出基础码段列表（按照orderNum升序排序）
      List<CodeRuleVO> codeRuleVOS = codeRuleDO2VOs(codeRuleList, true);
      // 满足码段类型顺序一致的要求的编码规则，可以进入下一步比较规则
      List<CodeRuleVO> codeRuleVOStream = codeRuleVOS.parallelStream().filter(item -> {
         // 对BasicSec使用orderNum排序(查询的时候其实已经排过一次序了)，并将secType用逗号分隔拼接成一个字符串
         String itemSecTypes = item.getSecVOList().parallelStream().sorted(Comparator.comparing(CodeBasicSecVO::getOrderNum)).map(CodeBasicSecVO::getSecType).collect(Collectors.joining(","));
         if (secTypes.equals(itemSecTypes)) {
            return true;
         }
         return false;
      }).collect(Collectors.toList());
      // 3、各类码段分别进行比对
      codeRuleVOStream.parallelStream().filter(item->{
         item.getSecVOList().stream().filter(basicSec->{
            switch (basicSec.getSecType()){
      List<CodeRuleVO> lastCodeRule = new ArrayList<>();
      codeRuleVOS.stream().forEach(item->{
         List<CodeBasicSecVO> secVOList = item.getSecVOList();
         boolean flag = true;
         for (int index = 0; index < secVOList.size(); index++) {
            // 当前要发布的规则包含的码段信息
            CodeBasicSecVO releaseBasicSec = releaseCodeRule.getSecVOList().get(index);
            // 已发布的规则包含的码段信息
            CodeBasicSecVO releasedBasicSec = secVOList.get(index);
            // 因为码段顺序都是按照OrderNum排序的，所以直接按照下标两两比较就可以了
            switch (releasedBasicSec.getSecType()){
               // 属性码段，比对属性和属性所在分类(referCodeClassifyOid)
               case "codeattrsec":
                  List<CodeBasicSecVO> codeattrsec = this.getBasicSecBySecType("codeattrsec", codeRuleVO);

                  if(!releasedBasicSec.getReferCodeClassifyOid().equals(releaseBasicSec.getReferCodeClassifyOid())){
                     flag = false;
                  }
                  break;
               // 可变码段，比对码段长度，编码补位方式和补位时的字符
               case "codevariablesec":
                  if(!(releasedBasicSec.getCodeSecLength().equals(releaseBasicSec.getCodeSecLength())
                     && releasedBasicSec.getCodeFillType().equals(releaseBasicSec.getCodeFillType())
                     && releasedBasicSec.getCodeFillSeparator().equals(releaseBasicSec.getCodeFillSeparator()))){
                     flag = false;
                  }
                  break;
               // 固定码段比对按升序排序的码值，
               case "codefixedsec":
                  if(Func.isNotEmpty(releasedBasicSec.getFixedValueVOList()) && Func.isNotEmpty(releaseBasicSec.getFixedValueVOList())){
                     // 将fixedValue按照逗号分隔拼接起来，以便比较，由于查询时已按照orderNum排过序了，所以不需要再次排序
                     String reledFixedValues = releasedBasicSec.getFixedValueVOList().stream().map(CodeFixedValueVO::getId).collect(Collectors.joining(","));
                     String releFixedValues = releaseBasicSec.getFixedValueVOList().stream().map(CodeFixedValueVO::getId).collect(Collectors.joining(","));
                     if(reledFixedValues.equals(releFixedValues)){
                        flag = false;
                     }
                  }
                  break;
               // 分类码段比对按升序排序码值
               case "codeclassifysec":
                  if(!releasedBasicSec.getReferCodeClassifyOid().equals(releaseBasicSec.getReferCodeClassifyOid())){
                     flag = false;
                  }
                  break;
               // 日期码段比对日期格式
               case "codedatesec":
                  if(!releasedBasicSec.getCodeDateFormatStr().equals(releaseBasicSec.getCodeDateFormatStr())){
                     flag = false;
                  }
                  break;
               // 引用码段，比对参照应用的业务类型
               // 引用码段，比对参照引用的业务类型
               case "coderefersec":
                  if(!releasedBasicSec.getReferBtmId().equals(releaseBasicSec.getReferBtmId())){
                     flag = false;
                  }
                  break;
               // 层级码段，比对层级类型、层级的值、字符截取类型、取值类型
               case "codelevelsec":
                  if(!(releasedBasicSec.getCodeLevelType().equals(releaseBasicSec.getCodeLevelType())
                     && releasedBasicSec.getCodeLevelValue().equals(releaseBasicSec.getCodeLevelValue())
                     && releasedBasicSec.getValueCutType().equals(releaseBasicSec.getValueCutType())
                     && releasedBasicSec.getCodeGetValueType().equals(releaseBasicSec.getCodeGetValueType()))){
                     flag = false;
                  }
                  break;
               case "codeserialsec":
               // 流水码段比对码段的长度

               case "codeserialsec":
                  if(!releasedBasicSec.getCodeFillLength().equals(releaseBasicSec.getCodeFillLength())){
                     flag = false;
                  }
                  break;
               default:
                  return false;
            }
            return false;
         });
         return false;
         }
         // 满足所有码段类型比对条件的规则
         if (flag) {
            lastCodeRule.add(item);
         }
      });
      // 最后将结果进行返回
      // 最后将结果进行处理并返回


      return null;
   }

   private List<CodeBasicSecVO> getBasicSecBySecType(String secType,CodeRuleVO codeRuleVO){
      List<CodeBasicSecVO> codeBasicSecVOList = codeRuleVO.getSecVOList().parallelStream().filter(item -> {
         if (item.getSecType().equals(secType)) {
            return true;
         }
         return false;
      }).collect(Collectors.toList());
      return codeBasicSecVOList;
   }

   /**