1.报检规则修改0704

amos-boot-system-tzs/amos-boot-module-jyjc/amos-boot-module-jyjc-api/src/main/java/com/yeejoin/amos/boot/module/jyjc/api/enums/InspectionCompanyType.java

@@ -14,7 +14,8 @@ public enum InspectionCompanyType {
      * 检验单位分类
      */
     LEGAL("legal","法定"),
-    THIRD("third","第3方");
+    THIRD("third","第3方"),
+    ALL("all","全部机构");
 
     private String code;
     private String name;

amos-boot-system-tzs/amos-boot-module-jyjc/amos-boot-module-jyjc-biz/src/main/java/com/yeejoin/amos/boot/module/jyjc/biz/action/RuleActionHandler.java

@@ -2,10 +2,12 @@ package com.yeejoin.amos.boot.module.jyjc.biz.action;
 
 import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.yeejoin.amos.boot.biz.common.utils.RedisUtils;
+import com.yeejoin.amos.boot.module.jyjc.api.entity.JyjcInspectionApplicationNoAcceptLog;
 import com.yeejoin.amos.boot.module.jyjc.api.enums.InspectionCompanyType;
 import com.yeejoin.amos.boot.module.jyjc.api.enums.LicenceTypeEnum;
 import com.yeejoin.amos.boot.module.jyjc.api.enums.OpenBizTypeEnum;
 import com.yeejoin.amos.boot.module.jyjc.biz.rule.InspectionEquipInfo;
+import com.yeejoin.amos.boot.module.jyjc.biz.service.impl.JyjcInspectionApplicationNoAcceptLogServiceImpl;
 import com.yeejoin.amos.boot.module.jyjc.biz.service.impl.RuleCommonServiceImpl;
 import com.yeejoin.amos.boot.module.ymt.api.dto.TzBaseEnterpriseInfoDto;
 import com.yeejoin.amos.boot.module.ymt.api.entity.TzBaseUnitLicence;
@@ -40,6 +42,7 @@ public class RuleActionHandler {
     private final RedissonClient redissonClient;
     private RedisUtils redisUtils;
     private RuleCommonServiceImpl ruleCommonService;
+    private JyjcInspectionApplicationNoAcceptLogServiceImpl noAcceptLogService;
 
     /**
      * 省特检院等特殊公司code
@@ -79,18 +82,18 @@ public class RuleActionHandler {
         try {
             boolean isLocked = lock.tryLock(0, 180, TimeUnit.SECONDS);
             if (!isLocked) {
-                log.warn("规则回填重复丢弃：请求变量参数:{},核对项目编码:{},是否进行属地过滤:{},默认的检验机构code:{}, 法定的检验机构code:{}, 法定的检验机构code: {},是否需要匹配核准代码:{}", bizObj, itemCode, isMatchArea, defaultInspectionCode, legalInspectionCodes, inspectionCompanyType, isMatchItem);
+                log.warn("规则回掉重复,消息将丢弃");
                 return;
             }
             if (redisUtils.hasKey(this.buildRedisDataKey("filterInspectionOrgAction", inspectionEquipInfo.getUuid()))) {
-                log.warn("规则回填重复丢弃：请求变量参数:{},核对项目编码:{},是否进行属地过滤:{},默认的检验机构code:{}, 法定的检验机构code:{}, 法定的检验机构code: {},是否需要匹配核准代码:{}", bizObj, itemCode, isMatchArea, defaultInspectionCode, legalInspectionCodes, inspectionCompanyType, isMatchItem);
+                log.warn("规则回掉重复,消息将丢弃");
                 return;
             }
             redisUtils.set(this.buildRedisDataKey("filterInspectionOrgAction", inspectionEquipInfo.getUuid()), inspectionEquipInfo.getUuid(), 3600);
             // 1.获取所有的符合资质条件的单位许可信息
             List<TzBaseUnitLicence> unitLicenceList = getBaseUnitLicenceList(itemCode, isMatchItem);
             // 2.匹配过滤机构信息,默认检验机构（目前检测没配置规则，后续检测也需要配置规则时，需要规则那回调方法新增参数，区分检验还是检测）
-            List<TzBaseEnterpriseInfoDto> tzBaseEnterpriseInfoList = getInspectionUnitListForFirstCommit(unitLicenceList, isMatchArea, inspectionEquipInfo, OpenBizTypeEnum.JY.getCode(), defaultInspectionCode, legalInspectionCodes, isMustAccept);
+            List<TzBaseEnterpriseInfoDto> tzBaseEnterpriseInfoList = getInspectionUnitListForLegal(unitLicenceList, isMatchArea, inspectionEquipInfo, OpenBizTypeEnum.JY.getCode(), defaultInspectionCode, legalInspectionCodes, isMustAccept);
             ruleCommonService.publishMqttMessage(inspectionEquipInfo.getComponentKey(), tzBaseEnterpriseInfoList);
         } catch (MqttException | InterruptedException e) {
             log.error("首次提交的检验机构匹配动作执行失败: {}", e.getMessage());
@@ -152,6 +155,43 @@ public class RuleActionHandler {
         return tzBaseUnitLicences;
     }
 
+
+    private List<TzBaseEnterpriseInfoDto> getInspectionUnitListForNoAccept2(List<TzBaseUnitLicence> unitLicenceList, Boolean isMatchArea, InspectionEquipInfo inspectionEquipInfo, String openBizType, String defaultInspectionCode, String legalInspectionCodes, String inspectionCompanyType, Boolean isCanNoAccept) {
+        List<TzBaseEnterpriseInfoDto> matchEnterpriseInfos = new ArrayList<>();
+        if(inspectionCompanyType.equals(InspectionCompanyType.ALL.getCode())){
+            // 是否进行属地过滤
+            String areaCode = isMatchArea ? inspectionEquipInfo.getAreaCode() : "";
+            // 所有符合资质的单位code
+            Set<String> unitCodes = unitLicenceList.stream().map(TzBaseUnitLicence::getUnitCode).collect(Collectors.toSet());
+            // 1.按照资质 + 开通区域，进行单位的筛选
+            if (unitCodes.size() > 0) {
+                matchEnterpriseInfos = tzBaseEnterpriseInfoMapper.getInspectionUnitListByCode(new ArrayList<>(unitCodes), areaCode, openBizType);
+                // 返回下一步是否可不予返回，供下一节点审核时显示判断是否显示不予受理按钮，在提交时数据会写入到主表：true-必须处理，false-可不予受理
+                this.setIsCanNoAccept(matchEnterpriseInfos, isCanNoAccept);
+            }
+            // 2.去掉已经不予受理的机构
+            List<String> unitCodesList = getNoAcceptHistoryUnit(inspectionEquipInfo);
+            matchEnterpriseInfos = matchEnterpriseInfos.stream().filter(u-> !unitCodesList.contains(u.getUseCode())).collect(Collectors.toList());
+            // 3.未空时显示默认机构(兜底机构)，只匹配开通的业务类型（检验还是检测）且不匹配开通区域且不可不予受理操作
+            if(matchEnterpriseInfos.isEmpty()){
+                matchEnterpriseInfos = tzBaseEnterpriseInfoMapper.getInspectionUnitListByCode(new ArrayList<>(Arrays.asList(defaultInspectionCode.split(","))), "", openBizType);
+                // 返回下一步是否可不予返回，供下一节点审核时显示判断是否显示不予受理按钮，在提交时数据会写入到主表：true-必须处理，false-可不予受理
+                this.setIsCanNoAccept(matchEnterpriseInfos, true);
+            }
+        } else {
+            log.warn("{}：待实现", inspectionCompanyType);
+        }
+        return matchEnterpriseInfos;
+    }
+
+    private List<String> getNoAcceptHistoryUnit(InspectionEquipInfo inspectionEquipInfo) {
+        LambdaQueryWrapper<JyjcInspectionApplicationNoAcceptLog> queryWrapper  = new LambdaQueryWrapper<>();
+        queryWrapper.eq(JyjcInspectionApplicationNoAcceptLog::getApplicationSeq, inspectionEquipInfo.getAppSeq());
+        queryWrapper.select(JyjcInspectionApplicationNoAcceptLog::getInspectionUnitCode);
+        List<JyjcInspectionApplicationNoAcceptLog> acceptLogs = noAcceptLogService.list(queryWrapper);
+        return acceptLogs.stream().map(JyjcInspectionApplicationNoAcceptLog::getInspectionUnitCode).collect(Collectors.toList());
+    }
+
     private List<TzBaseEnterpriseInfoDto> getInspectionUnitListForNoAccept(List<TzBaseUnitLicence> unitLicenceList, Boolean isMatchArea, InspectionEquipInfo inspectionEquipInfo, String openBizType, String defaultInspectionCode, String legalInspectionCodes, String inspectionCompanyType, Boolean isCanNoAccept) {
         // 是否进行属地过滤
         String areaCode = isMatchArea ? inspectionEquipInfo.getAreaCode() : "";
@@ -189,7 +229,22 @@ public class RuleActionHandler {
         return matchEnterpriseInfos;
     }
 
-    private List<TzBaseEnterpriseInfoDto> getInspectionUnitListForFirstCommit(List<TzBaseUnitLicence> unitLicenceList, Boolean isMatchArea, InspectionEquipInfo inspectionEquipInfo, String openBizType, String defaultInspectionCode, String legalInspectionCodes, Boolean isCanNoAccept) {
+    private List<TzBaseEnterpriseInfoDto> getInspectionUnitListForFirstCommit2(List<TzBaseUnitLicence> unitLicenceList, Boolean isMatchArea, InspectionEquipInfo inspectionEquipInfo, String openBizType, String defaultInspectionCode, String legalInspectionCodes, Boolean isMustAccept, String inspectionCompanyType) {
+        List<TzBaseEnterpriseInfoDto> matchEnterpriseInfos = new ArrayList<>();
+        if(inspectionCompanyType.equals(InspectionCompanyType.ALL.getCode())){
+            matchEnterpriseInfos = getInspectionUnitListForAll(unitLicenceList, isMatchArea, inspectionEquipInfo, openBizType, defaultInspectionCode, legalInspectionCodes, isMustAccept);
+        }if(inspectionCompanyType.equals(InspectionCompanyType.LEGAL.getCode())){
+            // 目前未使用到可替换 firstInspectionOrgMatchAction 业务
+            matchEnterpriseInfos = getInspectionUnitListForLegal(unitLicenceList, isMatchArea, inspectionEquipInfo, openBizType, defaultInspectionCode, legalInspectionCodes, isMustAccept);
+        } else if(inspectionCompanyType.equals(InspectionCompanyType.THIRD.getCode())){
+            // TODO 待实现
+            log.warn("{}类型:未实现",InspectionCompanyType.THIRD.getName());
+        }
+        return matchEnterpriseInfos;
+    }
+
+
+    private List<TzBaseEnterpriseInfoDto> getInspectionUnitListForLegal(List<TzBaseUnitLicence> unitLicenceList, Boolean isMatchArea, InspectionEquipInfo inspectionEquipInfo, String openBizType, String defaultInspectionCode, String legalInspectionCodes, Boolean isCanNoAccept) {
         // 是否进行属地过滤
         String areaCode = isMatchArea ? inspectionEquipInfo.getAreaCode() : "";
         // 所有符合单位的code
@@ -215,10 +270,93 @@ public class RuleActionHandler {
         return matchEnterpriseInfos;
     }
 
+    private List<TzBaseEnterpriseInfoDto> getInspectionUnitListForAll(List<TzBaseUnitLicence> unitLicenceList, Boolean isMatchArea, InspectionEquipInfo inspectionEquipInfo, String openBizType, String defaultInspectionCode, String legalInspectionCodes, Boolean isCanNoAccept) {
+        // 是否进行属地过滤
+        String areaCode = isMatchArea ? inspectionEquipInfo.getAreaCode() : "";
+        // 所有符合单位的code
+        Set<String> unitCodes = unitLicenceList.stream().map(TzBaseUnitLicence::getUnitCode).collect(Collectors.toSet());
+        List<TzBaseEnterpriseInfoDto> matchEnterpriseInfos = tzBaseEnterpriseInfoMapper.getInspectionUnitListByCode(new ArrayList<>(unitCodes), areaCode, openBizType);
+        // 返回下一步是否可不予返回，供下一节点审核时显示判断是否显示不予受理按钮，在提交时数据会写入到主表：true-必须处理，false-可不予受理
+        this.setIsCanNoAccept(matchEnterpriseInfos, isCanNoAccept);
+        return matchEnterpriseInfos;
+    }
+
     private void setIsCanNoAccept(List<TzBaseEnterpriseInfoDto> matchEnterpriseInfos, Boolean isCanNoAccept) {
         matchEnterpriseInfos.forEach(m -> m.setUseCodeAndName(m.getUseCode() + "_" + isCanNoAccept));
     }
 
 
+    /**
+     * 规则回调方法-用户自选首次提交的检验机构匹配,可替换firstInspectionOrgMatchAction，由于规则修改太多，故新增一个
+     *
+     * @param bizObj                请求变量参数
+     * @param itemCode              核对项目编码，多个用逗号分割
+     * @param isMatchArea           是否进行属地过滤（检验检测机构的开通区域包含设备归属地市），true-过滤，false-不过滤
+     * @param defaultInspectionCode 默认的检验机构code，多个用逗号分割，在按照属地匹配不上时，默认的检验机构
+     * @param legalInspectionCodes  法定的检验机构code，多个用逗号分割，检验机构的最大集合-不为空
+     * @param inspectionCompanyType 需要显示的单位类型：legal-法定、third-第3方、all-全部，默认都是legal-法定，预留需求变更点
+     * @param isMatchItem           是否需要匹配核准代码：true-匹配； false-不匹配
+     * @param isMustAccept          true-必须处理，false-可不予受理
+     * @param orgType               jy-检验机构，jc-检测机构
+     */
+    public void firstInspectionOrgMatchAction2(Object bizObj, String itemCode, Boolean isMatchArea, String defaultInspectionCode, String legalInspectionCodes, String inspectionCompanyType, Boolean isMatchItem, Boolean isMustAccept, String orgType) {
+        log.info("收到用户自选首次提交的检验机构匹配规则回调：请求变量参数:{},核对项目编码:{},是否进行属地过滤:{},默认的检验机构code:{}, 法定的检验机构code:{}, 检验机构类型: {},是否需要匹配核准代码:{},是否必须处理：{},检验机构类型：{}", bizObj, itemCode, isMatchArea, defaultInspectionCode, legalInspectionCodes, inspectionCompanyType, isMatchItem, isMustAccept, orgType);
+        InspectionEquipInfo inspectionEquipInfo = (InspectionEquipInfo) bizObj;
+        // 规则不支持或者的关系消息会重复故去重处理
+        RLock lock = redissonClient.getLock(this.buildLockKey("firstInspectionOrgMatchAction2", inspectionEquipInfo.getUuid()));
+        try {
+            boolean isLocked = lock.tryLock(0, 180, TimeUnit.SECONDS);
+            if (!isLocked) {
+                log.warn("规则回掉重复,消息将丢弃");
+                return;
+            }
+            if (redisUtils.hasKey(this.buildRedisDataKey("firstInspectionOrgMatchAction2", inspectionEquipInfo.getUuid()))) {
+                log.warn("规则回掉重复,消息将丢弃");
+                return;
+            }
+            redisUtils.set(this.buildRedisDataKey("firstInspectionOrgMatchAction2", inspectionEquipInfo.getUuid()), inspectionEquipInfo.getUuid(), 3600);
+            // 1.获取所有的符合资质条件的单位许可信息
+            List<TzBaseUnitLicence> unitLicenceList = getBaseUnitLicenceList(itemCode, isMatchItem);
+            // 2.匹配过滤机构信息,区分检验还是检测
+            List<TzBaseEnterpriseInfoDto> tzBaseEnterpriseInfoList = getInspectionUnitListForFirstCommit2(unitLicenceList, isMatchArea, inspectionEquipInfo, orgType, defaultInspectionCode, legalInspectionCodes, isMustAccept, inspectionCompanyType);
+            ruleCommonService.publishMqttMessage(inspectionEquipInfo.getComponentKey(), tzBaseEnterpriseInfoList);
+        } catch (MqttException | InterruptedException e) {
+            log.error("用户自选首次提交的检验机构匹配动作执行失败: {}", e.getMessage());
+        } finally {
+            if (lock.isHeldByCurrentThread()) {
+                lock.unlock();
+            }
+        }
+    }
+
+
+    /**
+     * 规则回调方法-用户自选不予受理的检验机构匹配
+     *
+     * @param bizObj                请求变量参数
+     * @param itemCode              核对项目编码，多个用逗号分割
+     * @param isMatchArea           是否进行属地过滤（检验检测机构的开通区域包含设备归属地市），true-过滤，false-不过滤
+     * @param defaultInspectionCode 默认的检验机构code
+     * @param inspectionCompanyType 需要显示的单位类型：legal-法定、third-第3方、all-全部，默认都是legal-法定，预留需求变更点
+     * @param legalInspectionCodes  法定的检验机构code，多个用逗号分割，检验机构的最大集合-不为空
+     * @param isMustAccept          true-必须处理，false-可不予受理
+     * @param orgType               jy-检验机构，jc-检测机构
+     */
+    public void noAcceptInspectionOrgMatchAction2(Object bizObj, String itemCode, Boolean isMatchArea, String defaultInspectionCode, String inspectionCompanyType, Boolean isMatchItem, String legalInspectionCodes, Boolean isMustAccept, String orgType) {
+        log.info("收到不予受理的检验机构匹配规则回调：请求变量参数:{},核对项目编码:{},是否进行属地过滤:{},默认的检验机构code:{}, 法定的检验机构code:{}, 检验机构类型: {},是否需要匹配核准代码:{},是否必须处理：{}，公司类型：{}", bizObj, itemCode, isMatchArea, defaultInspectionCode, legalInspectionCodes, inspectionCompanyType, isMatchItem, isMustAccept, orgType);
+        InspectionEquipInfo inspectionEquipInfo = (InspectionEquipInfo) bizObj;
+        try {
+            // 1.获取所有的符合资质条件的单位许可信息
+            List<TzBaseUnitLicence> unitLicenceList = getBaseUnitLicenceList(itemCode, isMatchItem);
+            // 2.匹配过滤机构信息,默认检验机构（目前检测没配置规则，后续检测也需要配置规则时，需要规则那回调方法新增参数，区分检验还是检测）
+            List<TzBaseEnterpriseInfoDto> tzBaseEnterpriseInfoList = getInspectionUnitListForNoAccept2(unitLicenceList, isMatchArea, inspectionEquipInfo, orgType, defaultInspectionCode, legalInspectionCodes, inspectionCompanyType, isMustAccept);
+            ruleCommonService.publishMqttMessage(inspectionEquipInfo.getComponentKey(), tzBaseEnterpriseInfoList);
+        } catch (MqttException e) {
+            log.error("Error publishing MQTT message: {}", e.getMessage());
+        }
+    }
+
+
+
 }
 

amos-boot-system-tzs/amos-boot-module-jyjc/amos-boot-module-jyjc-biz/src/main/java/com/yeejoin/amos/boot/module/jyjc/biz/event/listener/EnableRuleDataPreparationListener.java

@@ -137,6 +137,7 @@ public class EnableRuleDataPreparationListener implements ApplicationListener<In
         inspectionEquipInfo.setLastNoAcceptInspectionCode(this.buildLastNoAcceptInspectionCode(jyjcInspectionApplicationNoAcceptLog));
         // 是否球罐 0 1 转 boolean
         inspectionEquipInfo.setIsBallValve(!"0".equals(registrationInfo.getWhetherSphericalTank()));
+        inspectionEquipInfo.setAppSeq(equipInfoModel.getAppSeq());
         // 触发规则
         publisher.publish(new TouchRuleEvent(this, inspectionEquipInfo));
     }

amos-boot-system-tzs/amos-boot-module-jyjc/amos-boot-module-jyjc-biz/src/main/java/com/yeejoin/amos/boot/module/jyjc/biz/rule/InspectionEquipInfo.java

@@ -60,4 +60,7 @@ public class InspectionEquipInfo implements Serializable {
     @ApiModelProperty(value = "是否是球阀,压力容器定向规则使用")
     private Boolean isBallValve = false;
 
+    @ApiModelProperty(value = "申请表主键")
+    private String appSeq;
+
 }