自动化测试

cdssman-service/src/main/java/com/diagbot/aggregate/RuleTestAggregate.java

@@ -321,9 +321,11 @@ public class RuleTestAggregate {
                 }
                 if (!success) {
                     for (ResultRule result : entry.getValue()) {
+                        Integer count = 1;
                         result.setSuccess(0);
                         result.setMessage(result.getMessage() + "提示内容（"
-                                + msgList.stream().map(i -> i.getMsg()).collect(Collectors.joining("；"))
+                                + (count++) + "、"
+                                + msgList.stream().map(i -> i.getMsg()).collect(Collectors.joining("；" + (count++) + "、"))
                                 + "）与预期不符");
                         retList.add(result);
                     }

cdssman-service/src/main/java/com/diagbot/facade/MedRuleConvertFacade.java

@@ -1145,7 +1145,7 @@ public class MedRuleConvertFacade {
                         }
                         billMsg = MsgUtil.getCommonOtherMsg(orderType, content, resultRule.getRuleHisName(), conType, lis);
                     } else if (resultRule.getRuleBaseLibType().equals(LexiconEnum.Group.getKey())) {
-                        billMsg = MsgUtil.getCommonOtherMsg(orderType, resultRule.getRuleBaseLibName(), resultRule.getRuleHisName(), conType, lis);
+                        billMsg = MsgUtil.getCommonOtherMsg(orderType, resultRule.getRuleBaseLibName(), resultRule.getRuleHisName(), ConEnum.group.getName(), lis);
                     }
                 } else if (resultRule.getRuleLibType().equals(LexiconEnum.PacsResult.getKey())) {
                     if (resultRule.getRuleBaseLibType().equals(LexiconEnum.PacsResult.getKey())) {
@@ -1243,7 +1243,7 @@ public class MedRuleConvertFacade {
                     } else if (ListUtil.isNotEmpty(medicineResults)) {
                         billMsg = MsgUtil.getCommonOtherMsg(orderType, content, medicineResults.get(0).getRuleBaseHisName(), TypeEnum.drug.getName(), lis);
                     } else if (ListUtil.isNotEmpty(groupResults)) {
-                        billMsg = MsgUtil.getCommonOtherMsg(orderType, content, groupResults.get(0).getRuleBaseLibName(), TypeEnum.group.getName(), lis);
+                        billMsg = MsgUtil.getCommonOtherMsg(orderType, content, groupResults.get(0).getRuleBaseLibName(), ConEnum.group.getName(), lis);
                     } else {
                         billMsg = MsgUtil.getCommonOtherMsg(orderType, content, "", ConEnum.lis.getName(), lis);
                     }

cdssman-service/src/main/java/com/diagbot/facade/ResultRuleFacade.java

@@ -65,7 +65,7 @@ public class ResultRuleFacade extends ResultRuleServiceImpl {
      */
     public void exportExcel(HttpServletResponse response, ResultRulePageVO resultRulePageVO) {
         resultRulePageVO.setSize(-1L);
-        IPage<ResultRulePageDTO> page = this.getPage(resultRulePageVO);
+        IPage<ResultRulePageDTO> page = super.getPage(resultRulePageVO);
         List<ResultRulePageDTO> records = page.getRecords();
         List<ResultRule> baseRules = this.list(new QueryWrapper<ResultRule>()
                 .eq("success", resultRulePageVO.getSuccess()));
@@ -73,11 +73,11 @@ public class ResultRuleFacade extends ResultRuleServiceImpl {
         Map<Long, ResultRule> baseRuleMap = baseRules.stream().collect(Collectors.toMap(ResultRule::getId, v -> v));
 
         records.forEach(record -> {
+            if (ListUtil.isEmpty(record.getBaseRules())) {
+                record.setBaseRules(Lists.newLinkedList());
+            }
             List<Long> resultIds = Arrays.asList(record.getIds().split(",")).stream().map(Long::parseLong).collect(Collectors.toList());
             resultIds.forEach(id -> {
-                if (ListUtil.isEmpty(record.getBaseRules())) {
-                    record.setBaseRules(Lists.newLinkedList());
-                }
                 record.getBaseRules().add(baseRuleMap.get(id));
             });
         });

cdssman-service/src/main/java/com/diagbot/facade/RuleTestFacade.java

@@ -1,16 +1,28 @@
 package com.diagbot.facade;
 
 import com.diagbot.aggregate.RuleTestAggregate;
+import com.diagbot.dto.RuleDTO;
+import com.diagbot.entity.DiseaseConfig;
+import com.diagbot.entity.DrugConfig;
+import com.diagbot.entity.LisConfig;
+import com.diagbot.entity.OperationConfig;
+import com.diagbot.entity.PacsConfig;
+import com.diagbot.entity.TransfusionConfig;
 import com.diagbot.exception.CommonErrorCode;
 import com.diagbot.exception.CommonException;
+import com.diagbot.util.ExcelUtils;
 import com.diagbot.vo.HospitalIdVO;
 import com.diagbot.vo.RuleTestVO;
+import com.diagbot.vo.RuleVO;
 import io.github.lvyahui8.spring.aggregate.facade.DataBeanAggregateQueryFacade;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;
 
+import javax.servlet.http.HttpServletResponse;
 import java.util.HashMap;
+import java.util.List;
 import java.util.Map;
+import java.util.stream.Collectors;
 
 /**
  * @Description:
@@ -37,28 +49,10 @@ public class RuleTestFacade {
     @Autowired
     private TransfusionConfigFacade transfusionConfigFacade;
 
-    /*@Autowired
-    private BillManRepository billManRepository;
     @Autowired
-    private LisCriticalRepository lisCriticalRepository;
+    private KlRuleFacade klRuleFacade;
     @Autowired
-    private PacsCriticalRepository pacsCriticalRepository;
-    @Autowired
-    private TransfusionRemindRepository transfusionRemindRepository;
-    @Autowired
-    private MedRegNameRepository medRegNameRepository;
-    @Autowired
-    private YiBaoOperationNameRepository yiBaoOperationNameRepository;
-    @Autowired
-    private LisRemindRepository lisRemindRepository;
-    @Autowired
-    private PacsRemindRepository pacsRemindRepository;
-    @Autowired
-    private TransfusionSuggestRepository transfusionSuggestRepository;
-
-    @Autowired
-    private UnUsedMappingFacade unUsedMappingFacade;*/
-
+    private UnUsedMappingFacade unUsedMappingFacade;
 
     /**
      * 全规则测试
@@ -241,8 +235,11 @@ public class RuleTestFacade {
      * @param response
      * @param hospitalIdVO
      */
-   /* public void exportExcel(HttpServletResponse response, HospitalIdVO hospitalIdVO) {
+    public void exportExcel(HttpServletResponse response, HospitalIdVO hospitalIdVO) {
         Long hospitalId = hospitalIdVO.getHospitalId();
+
+        List<RuleDTO> list = klRuleFacade.getRules(new RuleVO());
+
         List<LisConfig> lisConfigList = lisConfigFacade.getListByHospitalId(hospitalId);
         List<PacsConfig> pacsConfigList = pacsConfigFacade.getListByHospitalId(hospitalId);
         List<DrugConfig> drugConfigList = drugConfigFacade.getListByHospitalId(hospitalId);
@@ -250,127 +247,19 @@ public class RuleTestFacade {
         List<OperationConfig> operationConfigList = operationConfigFacade.getListByHospitalId(hospitalId);
         List<TransfusionConfig> transfusionConfigList = transfusionConfigFacade.getListByHospitalId(hospitalId);
 
-        //开单合理性规则-通用
-        List<BillItem> billRules = billManRepository.getAllRules();
-        //开单合理性规则-输血
-        List<TransfusionRemind> billRules_transfusion = transfusionRemindRepository.findByStatus(StatusEnum.Enable.getKey());
-
-        //危急值规则-检验
-        List<LisCritical> criticalRules_lis = lisCriticalRepository.findCustomByStatus(StatusEnum.Enable.getKey());
-        //危急值规则-检查
-        List<PacsCritical> criticalRules_pacs = pacsCriticalRepository.findByStatus(StatusEnum.Enable.getKey());
-
-        //高危药品规则
-        List<MedRegName> highriskRules_drug = medRegNameRepository.findByStatusAndRisklevelExists(StatusEnum.Enable.getKey());
-        //高危手术规则
-        List<YiBaoOperationName> highriskRule_operation = yiBaoOperationNameRepository.findByStatusAndOpgradeExists(StatusEnum.Enable.getKey());
-
-        //化验其他值提醒
-        List<LisRemind> otherRule_lis = lisRemindRepository.findByStatus(StatusEnum.Enable.getKey());
-        //辅检其他值提醒
-        List<PacsRemind> otherRule_pacs = pacsRemindRepository.findByStatus(StatusEnum.Enable.getKey());
-        //输血其他值提醒
-        List<TransfusionSuggest> otherRule_transfusion = transfusionSuggestRepository.findByStatus(StatusEnum.Enable.getKey());
-
         //诊断映射关系
         Map<String, Map<String, List<Long>>> diseaseConfigMap = diseaseConfigFacade.getUniqueConfigMap(hospitalId, null, null);
 
-        Map<String, List<String>> billMap = unUsedMappingFacade.billUsedNames(billRules);
-        Map<String, List<String>> billTransfusionMap = unUsedMappingFacade.billTransfusionUsedNames(billRules_transfusion);
-        Map<String, List<String>> criticalLisMap = unUsedMappingFacade.criticalLisUsedNames(criticalRules_lis);
-        Map<String, List<String>> criticalPacsMap = unUsedMappingFacade.criticalPacsUsedNames(criticalRules_pacs);
-        Map<String, List<String>> highriskDrugMap = unUsedMappingFacade.highriskDrugUsedNames(highriskRules_drug);
-        Map<String, List<String>> highriskOperationMap = unUsedMappingFacade.highriskOperationUsedNames(highriskRule_operation);
-        Map<String, List<String>> otherLisMap = unUsedMappingFacade.otherLisUsedNames(otherRule_lis);
-        Map<String, List<String>> otherPacsMap = unUsedMappingFacade.otherPacsUsedNames(otherRule_pacs);
-        Map<String, List<String>> otherTransfusionMap = unUsedMappingFacade.otherTransfusionUsedNames(otherRule_transfusion);
+        Map<String, List<String>> usedMap = unUsedMappingFacade.usedNames(list);
 
-        List<String> lisNames = Lists.newLinkedList();
-        List<String> pacsNames = Lists.newLinkedList();
-        List<String> diseaseNames = Lists.newLinkedList();
-        List<String> drugNames = Lists.newLinkedList();
-        List<String> operationNames = Lists.newLinkedList();
-        List<String> transfusionNames = Lists.newLinkedList();
-
-        //lis
-        if (billMap.containsKey("lis")) {
-            lisNames.addAll(billMap.get("lis"));
-        }
-        if (billTransfusionMap.containsKey("lis")) {
-            lisNames.addAll(billTransfusionMap.get("lis"));
-        }
-        if (criticalLisMap.containsKey("lis")) {
-            lisNames.addAll(criticalLisMap.get("lis"));
-        }
-        if (highriskOperationMap.containsKey("lis")) {
-            lisNames.addAll(highriskOperationMap.get("lis"));
-        }
-        if (otherLisMap.containsKey("lis")) {
-            lisNames.addAll(otherLisMap.get("lis"));
-        }
-        //pacs
-        if (billMap.containsKey("pacs")) {
-            pacsNames.addAll(billMap.get("pacs"));
-        }
-        if (criticalPacsMap.containsKey("pacs")) {
-            pacsNames.addAll(criticalPacsMap.get("pacs"));
-        }
-        //disease
-        if (billMap.containsKey("disease")) {
-            diseaseNames.addAll(billMap.get("disease"));
-        }
-        if (billTransfusionMap.containsKey("disease")) {
-            diseaseNames.addAll(billTransfusionMap.get("disease"));
-        }
-        if (highriskOperationMap.containsKey("disease")) {
-            diseaseNames.addAll(highriskOperationMap.get("disease"));
-        }
-        if (otherLisMap.containsKey("disease")) {
-            diseaseNames.addAll(otherLisMap.get("disease"));
-        }
-        if (otherPacsMap.containsKey("disease")) {
-            List<String> names = otherPacsMap.get("disease");
-            if (ListUtil.isNotEmpty(names)) {
-                names.forEach(name -> {
-                    diseaseNames.addAll(diseaseConfigMap.keySet().stream().filter(i -> i.contains(name)).collect(Collectors.toList()));
-                });
-            }
-            //diseaseNames.addAll(otherPacsMap.get("disease"));
-        }
-        if (otherTransfusionMap.containsKey("disease")) {
-            diseaseNames.addAll(otherTransfusionMap.get("disease"));
-        }
-        //drug
-        if (billMap.containsKey("drug")) {
-            drugNames.addAll(billMap.get("drug"));
-        }
-        if (highriskDrugMap.containsKey("drug")) {
-            drugNames.addAll(highriskDrugMap.get("drug"));
-        }
-        if (otherLisMap.containsKey("drug")) {
-            drugNames.addAll(otherLisMap.get("drug"));
-        }
-        //operation
-        if (billMap.containsKey("operation")) {
-            operationNames.addAll(billMap.get("operation"));
-        }
-        if (billTransfusionMap.containsKey("operation")) {
-            operationNames.addAll(billTransfusionMap.get("operation"));
-        }
-        if (highriskOperationMap.containsKey("operation")) {
-            operationNames.addAll(highriskOperationMap.get("operation"));
-        }
-        if (otherTransfusionMap.containsKey("operation")) {
-            operationNames.addAll(otherTransfusionMap.get("operation"));
-        }
-        //transfusion
-        if (billTransfusionMap.containsKey("transfusion")) {
-            transfusionNames.addAll(billTransfusionMap.get("transfusion"));
-        }
-        if (otherTransfusionMap.containsKey("transfusion")) {
-            transfusionNames.addAll(otherTransfusionMap.get("transfusion"));
-        }
+        List<String> lisNames = usedMap.get("lis");
+        List<String> pacsNames = usedMap.get("pacs");
+        List<String> diseaseNames = usedMap.get("disease");
+        List<String> drugNames = usedMap.get("drug");
+        List<String> operationNames = usedMap.get("operation");
+        List<String> transfusionNames = usedMap.get("transfusion");
 
+        diseaseNames.addAll(diseaseConfigMap.keySet().stream().filter(i -> i.contains("流产")).collect(Collectors.toList()));
 
         List<LisConfig> unUsedLisConfigs = unUsedMappingFacade.unUsedMapping(lisConfigList, lisNames);
         List<PacsConfig> unUsedPacsConfigs = unUsedMappingFacade.unUsedMapping(pacsConfigList, pacsNames);
@@ -379,7 +268,6 @@ public class RuleTestFacade {
         List<OperationConfig> unUsedOperationConfig = unUsedMappingFacade.unUsedMapping(operationConfigList, operationNames);
         List<TransfusionConfig> unUsedTransfusionConfigs = unUsedMappingFacade.unUsedMapping(transfusionConfigList, transfusionNames);
 
-
         String fileName = "规则未使用的映射关系.xls";
         Map<String, Map<Class<?>, List<?>>> map = new HashMap<>();
         Map<Class<?>, List<?>> lisMap = new HashMap<Class<?>, List<?>>();
@@ -402,5 +290,5 @@ public class RuleTestFacade {
         map.put("输血", transfusionMap);
 
         ExcelUtils.exportExcel(map, null, fileName, response);
-    }*/
+    }
 }

cdssman-service/src/main/java/com/diagbot/facade/UnUsedMappingFacade.java

@@ -1,25 +1,14 @@
-/*
+
 package com.diagbot.facade;
 
 import com.alibaba.fastjson.JSONObject;
-import com.diagbot.entity.node.BillItem;
-import com.diagbot.entity.node.LisCritical;
-import com.diagbot.entity.node.LisRemind;
-import com.diagbot.entity.node.MedNameRegName;
-import com.diagbot.entity.node.MedRegName;
-import com.diagbot.entity.node.PacsCritical;
-import com.diagbot.entity.node.PacsRemind;
-import com.diagbot.entity.node.TransfusionRemind;
-import com.diagbot.entity.node.TransfusionSuggest;
-import com.diagbot.entity.node.YiBaoOperationName;
-import com.diagbot.entity.relationship.LisNameLisCritical;
-import com.diagbot.entity.relationship.LisRemindMedicine;
-import com.diagbot.entity.relationship.LisRemindYiBaoDiseaseName;
-import com.diagbot.entity.relationship.TransfusionSuggestYiBaoDiseaseName;
-import com.diagbot.entity.relationship.TransfusionSuggestYiBaoOperationName;
+import com.diagbot.dto.MedClassMedDTO;
+import com.diagbot.dto.RuleDTO;
+import com.diagbot.entity.ResultRule;
 import com.diagbot.enums.GraphLabelEnum;
+import com.diagbot.enums.LexiconEnum;
 import com.diagbot.enums.StatusEnum;
-import com.diagbot.repository.MedicineRepository;
+import com.diagbot.util.BeanUtil;
 import com.diagbot.util.EntityUtil;
 import com.diagbot.util.ListUtil;
 import com.diagbot.util.StringUtil;
@@ -33,28 +22,26 @@ import java.util.Map;
 import java.util.Set;
 import java.util.stream.Collectors;
 
-*/
+
 /**
  * @Description:
  * @Author:zhaops
  * @time: 2021/1/7 15:32
- *//*
+ */
 
 @Component
 public class UnUsedMappingFacade {
-
     @Autowired
-    private MedicineRepository medicineRepository;
+    private KlRelationFacade klRelationFacade;
 
-    */
-/**
+    /**
      * 未使用映射关系
      *
      * @param items
      * @param usedNames
      * @param <T>
      * @return
-     *//*
+     */
 
     public <T> List<T> unUsedMapping(List<T> items, List<String> usedNames) {
         List<T> retList = Lists.newLinkedList();
@@ -70,390 +57,116 @@ public class UnUsedMappingFacade {
         return retList;
     }
 
-    */
-/**
-     * 开单合理性包含的术语
-     *
-     * @param billItems
+    /**
+     * 规则包含术语
+     * @param list
      * @return
-     *//*
-
-    public Map<String, List<String>> billUsedNames(List<BillItem> billItems) {
+     */
+    public Map<String, List<String>> usedNames(List<RuleDTO> list) {
         Map<String, List<String>> retMap = new HashMap<>();
-        if (ListUtil.isEmpty(billItems)) {
+
+        if (ListUtil.isEmpty(list)) {
             return retMap;
         }
-        //开单项使用
-        List<String> lisBillNames = billItems.stream()
-                .filter(i -> i.getConceptLabel().equals(GraphLabelEnum.LisSet.getName()))
-                .map(i -> i.getConceptName())
-                .distinct()
+        List<String> lisNames = list.stream()
+                .filter(i -> i.getRuleLibType().equals(LexiconEnum.LisName.getKey()) || i.getRuleLibType().equals(LexiconEnum.LisSubName.getKey()))
+                .map(RuleDTO::getRuleLibName)
                 .collect(Collectors.toList());
-        //禁忌项使用
-        lisBillNames.addAll(billItems.stream()
-                .filter(i -> i.getConditionLabel().equals(GraphLabelEnum.Lis.getName()))
-                .map(i -> i.getConditionName())
-                .distinct()
+        lisNames.addAll(list.stream()
+                .filter(i -> i.getHasSubCond() != null && i.getHasSubCond().equals(1) && (i.getRuleBaseLibType().equals(LexiconEnum.LisName.getKey()) || i.getRuleBaseLibType().equals(LexiconEnum.LisSubName.getKey())))
+                .map(RuleDTO::getRuleBaseLibName)
                 .collect(Collectors.toList()));
-        //开单项使用
-        List<String> pacsBillNames = billItems.stream()
-                .filter(i -> i.getConceptLabel().equals(GraphLabelEnum.PacsName.getName()) || i.getConceptLabel().equals(GraphLabelEnum.PacsSubName.getName()))
-                .map(i -> i.getConceptName())
-                .distinct()
+        lisNames = lisNames.stream().distinct().collect(Collectors.toList());
+
+        List<String> pacsNames = list.stream()
+                .filter(i -> i.getRuleLibType().equals(LexiconEnum.PacsName.getKey()) || i.getRuleLibType().equals(LexiconEnum.PacsSubName.getKey()))
+                .map(RuleDTO::getRuleLibName)
                 .collect(Collectors.toList());
-        //禁忌项使用
-        pacsBillNames.addAll(billItems.stream()
-                .filter(i -> i.getConditionLabel().equals(GraphLabelEnum.BillConflictItem.getName()))
-                .map(i -> i.getConditionName())
-                .distinct()
+        pacsNames.addAll(list.stream()
+                .filter(i -> i.getHasSubCond() != null && i.getHasSubCond().equals(1) && (i.getRuleBaseLibType().equals(LexiconEnum.PacsName.getKey()) || i.getRuleBaseLibType().equals(LexiconEnum.PacsSubName.getKey())))
+                .map(RuleDTO::getRuleBaseLibName)
                 .collect(Collectors.toList()));
-        //开单项使用
-        List<String> operationBillNames = billItems.stream()
-                .filter(i -> i.getConceptLabel().equals(GraphLabelEnum.YiBaoOperationName.getName()))
-                .map(i -> i.getConceptName())
-                .distinct()
-                .collect(Collectors.toList());
-        //禁忌项使用
-            */
-/*operationBillNames.addAll(billItems.stream()
-                    .filter(i -> i.getConditionLabel().equals("手术"))
-                    .map(i -> i.getConditionName())
-                    .distinct()
-                    .collect(Collectors.toList()));*//*
+        pacsNames = pacsNames.stream().distinct().collect(Collectors.toList());
 
-        //开单项使用
-        List<String> diseaseBillNames = billItems.stream()
-                .filter(i -> i.getConceptLabel().equals(GraphLabelEnum.YiBaoDiseaseName.getName()))
-                .map(i -> i.getConceptName())
-                .distinct()
+        List<String> diseaseNames = list.stream()
+                .filter(i -> i.getRuleLibType().equals(LexiconEnum.Disease.getKey()))
+                .map(RuleDTO::getRuleLibName)
                 .collect(Collectors.toList());
-        //禁忌项使用
-        diseaseBillNames.addAll(billItems.stream()
-                .filter(i -> i.getConditionLabel().equals(GraphLabelEnum.Disease.getName()))
-                .map(i -> i.getConditionName())
-                .distinct()
+        diseaseNames.addAll(list.stream()
+                .filter(i -> i.getHasSubCond() != null && i.getHasSubCond().equals(1) && (i.getRuleBaseLibType().equals(LexiconEnum.Disease.getKey())))
+                .map(RuleDTO::getRuleBaseLibName)
                 .collect(Collectors.toList()));
-        //开单项使用
-        List<String> drugRegNames = billItems.stream()
-                .filter(i -> i.getConceptLabel().equals(GraphLabelEnum.MedRegName.getName()))
-                .map(i -> i.getConceptName())
-                .distinct()
-                .collect(Collectors.toList());
-        //药品注册名转药品通用名
-        List<String> drugBillNames = Lists.newArrayList();
-        if (ListUtil.isNotEmpty(drugBillNames)) {
-            List<MedNameRegName> medNameRegNames = medicineRepository.findCustomByNameAndRegName(StatusEnum.Enable.getKey());
-            Map<String, List<MedNameRegName>> medNameRegNameMap
-                    = EntityUtil.makeEntityListMap(medNameRegNames, "medRegName");
-            for (String regName : drugRegNames) {
-                if (medNameRegNameMap.containsKey(regName)) {
-                    drugBillNames.addAll(medNameRegNameMap.get(regName).stream().map(i -> i.getMedName()).collect(Collectors.toList()));
+        diseaseNames = diseaseNames.stream().distinct().collect(Collectors.toList());
+
+        //药品分类转换
+        List<MedClassMedDTO> medClassMedList = klRelationFacade.getMedClassMedList();
+        Map<String, List<String>> medClassMedMap =
+                medClassMedList.stream().collect(Collectors.groupingBy(MedClassMedDTO::getMedClassLibName,
+                        HashMap::new,
+                        Collectors.mapping(MedClassMedDTO::getMedLibName, Collectors.toList())));
+        List<RuleDTO> medList = Lists.newLinkedList();
+        for (RuleDTO result : list) {
+            if (result.getHasSubCond() != null && result.getHasSubCond().equals(1)) {
+                if (result.getRuleBaseLibType().equals(LexiconEnum.MedChemClass.getKey())
+                        || result.getRuleBaseLibType().equals(LexiconEnum.MedZhiLiaoClass.getKey())
+                        || result.getRuleBaseLibType().equals(LexiconEnum.MedYaoLiClass.getKey())) {
+                    List<String> medicines = medClassMedMap.get(result.getRuleBaseLibName());
+                    if (ListUtil.isNotEmpty(medicines)) {
+                        for (String med : medicines) {
+                            RuleDTO medResult = new RuleDTO();
+                            BeanUtil.copyProperties(result, medResult);
+                            medResult.setRuleBaseLibName(med);
+                            medResult.setRuleBaseLibType(LexiconEnum.Medicine.getKey());
+                            medResult.setRuleBaseLibTypeName(LexiconEnum.Medicine.getName());
+                            medList.add(medResult);
+                        }
+                    } else {
+                        medList.add(result);
+                    }
+                } else {
+                    medList.add(result);
                 }
+            } else {
+                medList.add(result);
             }
         }
-        drugBillNames.addAll(billItems.stream()
-                .filter(i -> i.getConditionLabel().equals(GraphLabelEnum.OralMedicine.getName())
-                        || i.getConditionLabel().equals(GraphLabelEnum.MedAllergen.getName()))
-                .map(i -> i.getConditionName())
-                .distinct()
-                .collect(Collectors.toList()));
-        retMap.put("lis", lisBillNames);
-        retMap.put("pacs", pacsBillNames);
-        retMap.put("disease", diseaseBillNames);
-        retMap.put("drug", drugBillNames);
-        retMap.put("operation", operationBillNames);
-
-        return retMap;
-    }
-
-    */
-/**
-     * 开单合理性-输血使用术语
-     *
-     * @param items
-     * @return
-     *//*
 
-    public Map<String, List<String>> billTransfusionUsedNames(List<TransfusionRemind> items) {
-        Map<String, List<String>> retMap = new HashMap<>();
-        if (ListUtil.isEmpty(items)) {
-            return retMap;
-        }
-        List<String> diseaseNames = items.stream()
-                .filter(i -> StringUtil.isNotBlank(i.getNode_label()) && i.getNode_label().equals(GraphLabelEnum.YiBaoDiseaseName.getName()))
-                .map(i -> i.getIndex_name())
-                .distinct()
-                .collect(Collectors.toList());
-        List<String> operationNames = items.stream()
-                .filter(i -> StringUtil.isNotBlank(i.getNode_label()) && i.getNode_label().equals(GraphLabelEnum.YiBaoOperationName.getName()))
-                .map(i -> i.getIndex_name())
-                .distinct()
-                .collect(Collectors.toList());
-        List<String> lisNames = items.stream()
-                .filter(i -> StringUtil.isNotBlank(i.getNode_label()) && i.getNode_label().equals(GraphLabelEnum.LisName.getName()))
-                .map(i -> i.getIndex_name())
-                .distinct()
-                .collect(Collectors.toList());
-        List<String> transfusionNames = items.stream()
-                .map(i -> i.getTransfusion_type())
-                .distinct()
+        List<String> drugNames = medList.stream()
+                .filter(i -> i.getRuleLibType().equals(LexiconEnum.Medicine.getKey()))
+                .map(RuleDTO::getRuleLibName)
                 .collect(Collectors.toList());
-        retMap.put("lis", lisNames);
-        retMap.put("disease", diseaseNames);
-        retMap.put("operation", operationNames);
-        retMap.put("transfusion", transfusionNames);
-        return retMap;
-    }
-
-    */
-/**
-     * 实验室检查危急值使用术语
-     *
-     * @param items
-     * @return
-     *//*
-
-    public Map<String, List<String>> criticalLisUsedNames(List<LisCritical> items) {
-        Map<String, List<String>> retMap = new HashMap<>();
-        if (ListUtil.isEmpty(items)) {
-            return retMap;
-        }
-        List<String> lisNames = Lists.newArrayList();
-        for (LisCritical item : items) {
-            Set<LisNameLisCritical> lisNameLisCriticalSet = item.getLisnameLisCriticals();
-            if (lisNameLisCriticalSet != null && lisNameLisCriticalSet.size() > 0) {
-                lisNameLisCriticalSet.forEach(lisNameLisCritical -> {
-                    if (lisNameLisCritical.getLisName() != null) {
-                        lisNames.add(lisNameLisCritical.getLisName().getName());
-                    }
-                });
-            }
-        }
-
-        retMap.put("lis", lisNames);
-        return retMap;
-    }
-
-    */
-/**
-     * 辅助检查危急值使用术语
-     *
-     * @param items
-     * @return
-     *//*
-
-    public Map<String, List<String>> criticalPacsUsedNames(List<PacsCritical> items) {
-        Map<String, List<String>> retMap = new HashMap<>();
-        if (ListUtil.isEmpty(items)) {
-            return retMap;
-        }
-        List<String> pacsNames = items.stream().map(i -> i.getPacsname()).distinct().collect(Collectors.toList());
-        retMap.put("pacs", pacsNames);
-        return retMap;
-    }
-
-    */
-/**
-     * 高危药品使用术语
-     *
-     * @param items
-     * @return
-     *//*
-
-    public Map<String, List<String>> highriskDrugUsedNames(List<MedRegName> items) {
-        Map<String, List<String>> retMap = new HashMap<>();
-        if (ListUtil.isEmpty(items)) {
-            return retMap;
-        }
-        List<String> medRegNames = items.stream().map(i -> i.getName()).distinct().collect(Collectors.toList());
-        List<String> medNames = Lists.newLinkedList();
-
-        List<MedNameRegName> medNameRegNames = medicineRepository.findCustomByNameAndRegName(StatusEnum.Enable.getKey());
-        Map<String, List<MedNameRegName>> medNameRegNameMap
-                = EntityUtil.makeEntityListMap(medNameRegNames, "medRegName");
-        for (String regName : medRegNames) {
-            if (medNameRegNameMap.containsKey(regName)) {
-                medNames.addAll(medNameRegNameMap.get(regName).stream().map(i -> i.getMedName()).collect(Collectors.toList()));
-            }
-        }
-
-        retMap.put("drug", medNames);
-        return retMap;
-    }
-
-    */
-/**
-     * 高危手术使用术语
-     *
-     * @param items
-     * @return
-     *//*
-
-    public Map<String, List<String>> highriskOperationUsedNames(List<YiBaoOperationName> items) {
-        Map<String, List<String>> retMap = new HashMap<>();
-        if (ListUtil.isEmpty(items)) {
-            return retMap;
-        }
+        drugNames.addAll(medList.stream()
+                .filter(i -> i.getHasSubCond() != null && i.getHasSubCond().equals(1) && (i.getRuleBaseLibType().equals(LexiconEnum.Medicine.getKey())))
+                .map(RuleDTO::getRuleBaseLibName)
+                .collect(Collectors.toList()));
+        drugNames = drugNames.stream().distinct().collect(Collectors.toList());
 
-        items = items.stream()
-                .filter(i -> StringUtil.isNotBlank(i.getOpgrade())
-                        && !i.getOpgrade().equals("0")
-                        && !i.getOpgrade().equals("1"))
+        List<String> operationNames = list.stream()
+                .filter(i -> i.getRuleLibType().equals(LexiconEnum.Operation.getKey()))
+                .map(RuleDTO::getRuleLibName)
                 .collect(Collectors.toList());
+        operationNames.addAll(list.stream()
+                .filter(i -> i.getHasSubCond() != null && i.getHasSubCond().equals(1) && (i.getRuleBaseLibType().equals(LexiconEnum.Operation.getKey())))
+                .map(RuleDTO::getRuleBaseLibName)
+                .collect(Collectors.toList()));
+        operationNames = operationNames.stream().distinct().collect(Collectors.toList());
 
-        if (ListUtil.isEmpty(items)) {
-            return retMap;
-        }
-
-        List<String> operationNames = items.stream()
-                .map(i -> i.getName()).distinct().collect(Collectors.toList());
-
-        List<String> lisNames = Lists.newArrayList();
-        List<String> diseaseNames = Lists.newArrayList();
-
-        for (YiBaoOperationName item : items) {
-            String highriskcond = item.getHighriskcond();
-            JSONObject jobj = JSONObject.parseObject(highriskcond);
-            if (null != jobj) {
-                // 合并疾病
-                JSONObject diagobj = jobj.getJSONObject("合并疾病");
-                if (null != diagobj) {
-                    for (Map.Entry<String, Object> entry : diagobj.entrySet()) {
-                        diseaseNames.add(entry.getKey());
-                    }
-                }
-                // 化验结果
-                JSONObject lisobj = jobj.getJSONObject("化验结果");
-                if (null != lisobj) {
-                    for (Map.Entry<String, Object> entry : lisobj.entrySet()) {
-                        lisNames.add(entry.getKey());
-                    }
-                }
-            }
-        }
-
-        retMap.put("operation", operationNames);
-        retMap.put("lis", lisNames);
-        retMap.put("disease", diseaseNames);
-        return retMap;
-    }
-
-    */
-/**
-     * 化验其他提醒使用术语
-     *
-     * @param items
-     * @return
-     *//*
-
-    public Map<String, List<String>> otherLisUsedNames(List<LisRemind> items) {
-        Map<String, List<String>> retMap = new HashMap<>();
-        if (ListUtil.isEmpty(items)) {
-            return retMap;
-        }
-
-        List<String> lisNames = items.stream()
-                .map(i -> i.getLisname())
+        List<String> transfusionNames = list.stream()
+                .filter(i -> i.getRuleLibType().equals(LexiconEnum.Transfusion.getKey()))
+                .map(RuleDTO::getRuleLibName)
                 .collect(Collectors.toList());
+        transfusionNames.addAll(list.stream()
+                .filter(i -> i.getHasSubCond() != null && i.getHasSubCond().equals(1) && (i.getRuleBaseLibType().equals(LexiconEnum.Transfusion.getKey())))
+                .map(RuleDTO::getRuleBaseLibName)
+                .collect(Collectors.toList()));
+        transfusionNames = transfusionNames.stream().distinct().collect(Collectors.toList());
 
-        List<String> diseaseNames = Lists.newArrayList();
-        List<String> drugNames = Lists.newArrayList();
-
-        for (LisRemind item : items) {
-            Set<LisRemindYiBaoDiseaseName> lisDisSet = item.getLisReminddisease();
-            if (lisDisSet != null && lisDisSet.size() > 0) {
-                lisDisSet.forEach(lisDis -> {
-                    if (lisDis.getYiBaoDiseaseName() != null) {
-                        diseaseNames.add(lisDis.getYiBaoDiseaseName().getName());
-                    }
-                });
-            }
-
-            Set<LisRemindMedicine> lisMedSet = item.getLisRemindmedicines();
-            if (lisMedSet != null && lisMedSet.size() > 0) {
-                lisMedSet.forEach(lisMed -> {
-                    if (lisMed.getMedicine() != null) {
-                        drugNames.add(lisMed.getMedicine().getName());
-                    }
-                });
-            }
-        }
-
-        retMap.put("disease", diseaseNames);
         retMap.put("lis", lisNames);
-        retMap.put("drug", drugNames);
-        return retMap;
-
-    }
-
-    */
-/**
-     * 辅检其他提醒使用术语
-     *
-     * @param items
-     * @return
-     *//*
-
-    public Map<String, List<String>> otherPacsUsedNames(List<PacsRemind> items) {
-        Map<String, List<String>> retMap = new HashMap<>();
-        if (ListUtil.isEmpty(items)) {
-            return retMap;
-        }
-
-        List<String> diseaseNames = items.stream()
-                .filter(i -> StringUtil.isNotBlank(i.getDisease()))
-                .map(i -> i.getDisease())
-                .collect(Collectors.toList());
-
-        retMap.put("disease", diseaseNames);
-
-        return retMap;
-
-    }
-
-
-    */
-/**
-     * 输血其他提醒使用术语
-     *
-     * @param items
-     * @return
-     *//*
-
-    public Map<String, List<String>> otherTransfusionUsedNames(List<TransfusionSuggest> items) {
-        Map<String, List<String>> retMap = new HashMap<>();
-        if (ListUtil.isEmpty(items)) {
-            return retMap;
-        }
-
-        List<String> transfusionNames = items.stream().map(i -> i.getTransfusion_type()).distinct().collect(Collectors.toList());
-        List<String> diseaseNames = Lists.newArrayList();
-        List<String> operationNames = Lists.newArrayList();
-
-        for (TransfusionSuggest item : items) {
-            Set<TransfusionSuggestYiBaoDiseaseName> transDisSet = item.getTransfusionSuggestDiseases();
-            if (transDisSet != null && transDisSet.size() > 0) {
-                transDisSet.forEach(transDis -> {
-                    if (transDis.getYiBaoDiseaseName() != null) {
-                        diseaseNames.add(transDis.getYiBaoDiseaseName().getName());
-                    }
-                });
-            }
-
-            Set<TransfusionSuggestYiBaoOperationName> transOptSet = item.getTransfusionSuggestOperations();
-            if (transOptSet != null && transOptSet.size() > 0) {
-                transOptSet.forEach(transOpt -> {
-                    if (transOpt.getYiBaoOperationName() != null) {
-                        operationNames.add(transOpt.getYiBaoOperationName().getName());
-                    }
-                });
-            }
-        }
-
-        retMap.put("transfusion", transfusionNames);
+        retMap.put("pacs", pacsNames);
         retMap.put("disease", diseaseNames);
+        retMap.put("drug", drugNames);
         retMap.put("operation", operationNames);
+        retMap.put("transfusion", transfusionNames);
         return retMap;
     }
 }
-*/

cdssman-service/src/main/java/com/diagbot/service/impl/ResultRuleServiceImpl.java

@@ -21,6 +21,7 @@ import org.springframework.stereotype.Service;
 @Service
 public class ResultRuleServiceImpl extends ServiceImpl<ResultRuleMapper, ResultRule> implements ResultRuleService {
 
+    @Override
     public IPage<ResultRulePageDTO> getPage(@Param("resultRulePageVO") ResultRulePageVO resultRulePageVO) {
         return baseMapper.getPage(resultRulePageVO);
     }

cdssman-service/src/main/java/com/diagbot/vo/ResultRulePageVO.java

@@ -14,4 +14,9 @@ import lombok.Setter;
 public class ResultRulePageVO extends Page {
     private Integer success;
     private Long resultId;
+    private Integer ruleLibType;
+    private String ruleLibName;
+    private Integer ruleBaseLibType;
+    private String ruleBaseLibName;
+    private String message;
 }

cdssman-service/src/main/java/com/diagbot/vo/RuleTestVO.java

@@ -22,7 +22,6 @@ public class RuleTestVO extends HospitalIdVO {
     /**
      * 测试序号
      */
-    @NotNull(message = "请输入测试序号")
     @ApiModelProperty(hidden = true)
     private Integer caseNo;
 }

cdssman-service/src/main/java/com/diagbot/web/RuleTestController.java

@@ -76,7 +76,12 @@ public class RuleTestController {
 
     @ApiOperation(value = "分页查询列表[zhaops]",
             notes = "success： 成功标志（0：失败，1：成功） <br>" +
-                    "resultId： 结果id <br>")
+                    "resultId： 结果id <br>" +
+                    "ruleLibType： 规则术语类型 <br>" +
+                    "ruleLibName： 规则医学标准术语（模糊查询） <br>" +
+                    "ruleBaseLibType： 基础规则术语类型 <br>" +
+                    "ruleBaseLibName： 基础规则医学标准术语（模糊查询） <br>" +
+                    "message： 失败原因（模糊查询 <br>")
     @PostMapping("/getResultRulePage")
     @SysLogger("getResultRulePage")
     public RespDTO<IPage<ResultRulePageDTO>> getResultRulePage(@Valid @RequestBody ResultRulePageVO resultRulePageVO) {
@@ -88,17 +93,22 @@ public class RuleTestController {
 
     //region --------------------------导出------------------------------
 
-    /*@ApiOperation(value = "导出规则未覆盖映射关系[by:zhaops]",
+    @ApiOperation(value = "导出规则未覆盖映射关系[by:zhaops]",
             notes = "")
     @PostMapping("/exportExcel")
     @SysLogger("exportExcel")
     public void exportExcel(HttpServletResponse response, @RequestBody @Valid HospitalIdVO hospitalIdVO) {
         ruleTestFacade.exportExcel(response, hospitalIdVO);
-    }*/
+    }
 
     @ApiOperation(value = "规则测试结果导出[by:zhaops]",
             notes = "success： 成功标志（0：失败，1：成功） <br>" +
-                    "resultId： 结果id <br>")
+                    "resultId： 结果id <br>" +
+                    "ruleLibType： 规则术语类型 <br>" +
+                    "ruleLibName： 规则医学标准术语（模糊查询） <br>" +
+                    "ruleBaseLibType： 基础规则术语类型 <br>" +
+                    "ruleBaseLibName： 基础规则医学标准术语（模糊查询） <br>" +
+                    "message： 失败原因（模糊查询 <br>")
     @PostMapping("/ruleExportExcel")
     @SysLogger("ruleExportExcel")
     public void ruleExportExcel(HttpServletResponse response, @RequestBody @Valid ResultRulePageVO resultRulePageVO) {

cdssman-service/src/main/resources/mapper/ResultRuleMapper.xml

@@ -43,7 +43,9 @@
     </resultMap>
 
     <select id="getPage" resultType="com.diagbot.dto.ResultRulePageDTO">
-        SELECT
+        SELECT t.*
+        FROM
+        (SELECT
         a.gmt_modified AS gmtModified,
         a.modifier AS modifier,
         a.result_id AS resultId,
@@ -60,7 +62,9 @@
         a.expected_output AS expectedOutput,
         a.success AS success,
         a.message AS message,
-        group_concat(id) as ids
+        group_concat(id) as ids,
+        group_concat(a.rule_base_lib_type) as ruleBaseLibTypes,
+        group_concat(a.rule_base_lib_name) as ruleBaseLibNames
         FROM
         test_result_rule a
         WHERE
@@ -76,7 +80,27 @@
         a.rule_order_no
         ORDER BY
         a.result_id,
-        a.rule_order_no
+        a.rule_order_no) t
+        WHERE 1 = 1
+        <if test="resultRulePageVO.success != null and resultRulePageVO.success == 0">
+            and t.message not like concat('%', '映射', '%')
+        </if>
+        <if test="resultRulePageVO.ruleLibType != null">
+            and t.ruleLibType = #{resultRulePageVO.ruleLibType}
+        </if>
+        <if test="resultRulePageVO.ruleLibName != null and resultRulePageVO.ruleLibName != ''">
+            and t.ruleLibName like concat('%', #{resultRulePageVO.ruleLibName}, '%')
+        </if>
+        <if test="resultRulePageVO.ruleBaseLibType != null">
+            and t.ruleBaseLibTypes is not null
+            and find_in_set( #{resultRulePageVO.ruleBaseLibType},t.ruleBaseLibTypes )>0
+        </if>
+        <if test="resultRulePageVO.ruleBaseLibName != null and resultRulePageVO.ruleBaseLibName != ''">
+            and t.ruleBaseLibName like concat('%', #{resultRulePageVO.ruleBaseLibName}, '%')
+        </if>
+        <if test="resultRulePageVO.message != null and resultRulePageVO.message != ''">
+            and t.message like concat('%', #{resultRulePageVO.message}, '%')
+        </if>
     </select>
 
 </mapper>