医学规则测试：规则未覆盖术语导出

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

@@ -9,22 +9,32 @@ import com.diagbot.entity.PacsConfig;
 import com.diagbot.entity.TransfusionConfig;
 import com.diagbot.entity.node.BillItem;
 import com.diagbot.entity.node.LisCritical;
+import com.diagbot.entity.node.LisRemind;
+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.enums.StatusEnum;
 import com.diagbot.exception.CommonErrorCode;
 import com.diagbot.exception.CommonException;
 import com.diagbot.repository.BillManRepository;
 import com.diagbot.repository.LisCriticalRepository;
+import com.diagbot.repository.LisRemindRepository;
+import com.diagbot.repository.MedRegNameRepository;
 import com.diagbot.repository.PacsCriticalRepository;
+import com.diagbot.repository.PacsRemindRepository;
 import com.diagbot.repository.TransfusionRemindRepository;
+import com.diagbot.repository.TransfusionSuggestRepository;
+import com.diagbot.repository.YiBaoOperationNameRepository;
 import com.diagbot.util.ExcelUtils;
 import com.diagbot.vo.BillRuleVO;
 import com.diagbot.vo.CriticalRuleVO;
 import com.diagbot.vo.HighriskRuleVO;
 import com.diagbot.vo.HospitalIdVO;
 import com.diagbot.vo.OtherRuleVO;
-import com.sun.org.apache.xpath.internal.operations.Bool;
+import com.google.common.collect.Lists;
 import io.github.lvyahui8.spring.aggregate.facade.DataBeanAggregateQueryFacade;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;
@@ -67,6 +77,17 @@ public class RuleTestFacade {
     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;
 
@@ -264,44 +285,138 @@ public class RuleTestFacade {
         //危急值规则-检查
         List<PacsCritical> criticalRules_pacs = pacsCriticalRepository.findByStatus(StatusEnum.Enable.getKey());
 
-        Map<String, Object> paramMap = new HashMap<>();
-        paramMap.put("billRules", billRules);
-        paramMap.put("billItems_transfusion", billRules_transfusion);
-        paramMap.put("criticalRules_lis", criticalRules_lis);
-        paramMap.put("criticalRules_pacs", criticalRules_pacs);
-
-        Map<String, List<String>> outParamMap = unUsedMappingFacade.usedNames(paramMap);
-        List<String> lisBillNames = outParamMap.get("lisBillNames");
-        List<LisConfig> unUsedLisBill = unUsedMappingFacade.unUsedMapping(lisConfigList, lisBillNames);
-        List<String> pacsBillNames = outParamMap.get("pacsBillNames");
-        List<PacsConfig> unUsedPacsBill = unUsedMappingFacade.unUsedMapping(pacsConfigList, pacsBillNames);
-        List<String> diseaseBillNames = outParamMap.get("diseaseBillNames");
-        List<DiseaseConfig> unUsedDiseaseBill = unUsedMappingFacade.unUsedMapping(diseaseConfigList, diseaseBillNames);
-        List<String> drugBillNames = outParamMap.get("drugBillNames");
-        List<DrugConfig> unUsedDrugBill = unUsedMappingFacade.unUsedMapping(drugConfigList, drugBillNames);
-        List<String> operationBillNames = outParamMap.get("operationBillNames");
-        List<OperationConfig> unUsedOperationBill = unUsedMappingFacade.unUsedMapping(operationConfigList, operationBillNames);
+        //高危药品规则
+        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, 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);
+
+        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")) {
+            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<LisConfig> unUsedLisConfigs = unUsedMappingFacade.unUsedMapping(lisConfigList, lisNames);
+        List<PacsConfig> unUsedPacsConfigs = unUsedMappingFacade.unUsedMapping(pacsConfigList, pacsNames);
+        List<DiseaseConfig> unUsedDiseaseConfigs = unUsedMappingFacade.unUsedMapping(diseaseConfigList, drugNames);
+        List<DrugConfig> unUsedDrugConfigs = unUsedMappingFacade.unUsedMapping(drugConfigList, drugNames);
+        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<?>> lisBillMap = new HashMap<Class<?>, List<?>>();
-        lisBillMap.put(LisConfig.class, unUsedLisBill);
-        map.put("检验开单项", lisBillMap);
-        Map<Class<?>, List<?>> pacsBillMap = new HashMap<Class<?>, List<?>>();
-        pacsBillMap.put(PacsConfig.class, unUsedPacsBill);
-        map.put("检查开单项", pacsBillMap);
-        Map<Class<?>, List<?>> diseaseBillMap = new HashMap<Class<?>, List<?>>();
-        diseaseBillMap.put(DiseaseConfig.class, unUsedDiseaseBill);
-        map.put("诊断开单项", diseaseBillMap);
-        Map<Class<?>, List<?>> drugBillMap = new HashMap<Class<?>, List<?>>();
-        drugBillMap.put(DrugConfig.class, unUsedDrugBill);
-        map.put("药品开单项", drugBillMap);
-        Map<Class<?>, List<?>> operationBillMap = new HashMap<Class<?>, List<?>>();
-        operationBillMap.put(OperationConfig.class, unUsedOperationBill);
-        map.put("手术和操作开单项", operationBillMap);
-
+        Map<Class<?>, List<?>> lisMap = new HashMap<Class<?>, List<?>>();
+        lisMap.put(LisConfig.class, unUsedLisConfigs);
+        map.put("检验", lisMap);
+        Map<Class<?>, List<?>> pacsMap = new HashMap<Class<?>, List<?>>();
+        pacsMap.put(PacsConfig.class, unUsedPacsConfigs);
+        map.put("检查", pacsMap);
+        Map<Class<?>, List<?>> diseaseMap = new HashMap<Class<?>, List<?>>();
+        diseaseMap.put(DiseaseConfig.class, unUsedDiseaseConfigs);
+        map.put("诊断", diseaseMap);
+        Map<Class<?>, List<?>> drugMap = new HashMap<Class<?>, List<?>>();
+        drugMap.put(DrugConfig.class, unUsedDrugConfigs);
+        map.put("药品", drugMap);
+        Map<Class<?>, List<?>> operationMap = new HashMap<Class<?>, List<?>>();
+        operationMap.put(OperationConfig.class, unUsedOperationConfig);
+        map.put("手术和操作", operationMap);
+        Map<Class<?>, List<?>> transfusionMap = new HashMap<Class<?>, List<?>>();
+        transfusionMap.put(TransfusionConfig.class, unUsedTransfusionConfigs);
+        map.put("输血", transfusionMap);
 
         ExcelUtils.exportExcel(map, null, fileName, response);
     }
-
 }

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

@@ -1,12 +1,27 @@
 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.enums.GraphLabelEnum;
 import com.diagbot.enums.StatusEnum;
 import com.diagbot.repository.MedicineRepository;
 import com.diagbot.util.EntityUtil;
 import com.diagbot.util.ListUtil;
+import com.diagbot.util.StringUtil;
 import com.google.common.collect.Lists;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;
@@ -14,6 +29,7 @@ import org.springframework.stereotype.Component;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.Set;
 import java.util.stream.Collectors;
 
 /**
@@ -50,92 +66,357 @@ public class UnUsedMappingFacade {
     }
 
     /**
-     * 规则中包含的标准术语
+     * 开单合理性包含的术语
      *
-     * @param map
+     * @param billItems
      * @return
      */
-    public Map<String, List<String>> usedNames(Map<String, Object> map) {
+    public Map<String, List<String>> billUsedNames(List<BillItem> billItems) {
         Map<String, List<String>> retMap = new HashMap<>();
-        if (map.containsKey("billRules")) {
-            List<BillItem> billItems = (List<BillItem>) map.get("billRules");
-            //开单项使用
-            List<String> lisBillNames = billItems.stream()
-                    .filter(i -> i.getConceptLabel().equals(GraphLabelEnum.LisSet.getName()))
-                    .map(i -> i.getConceptName())
-                    .distinct()
-                    .collect(Collectors.toList());
-            //禁忌项使用
-            lisBillNames.addAll(billItems.stream()
-                    .filter(i -> i.getConditionLabel().equals(GraphLabelEnum.Lis.getName()))
-                    .map(i -> i.getConditionName())
-                    .distinct()
-                    .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()
-                    .collect(Collectors.toList());
-            //禁忌项使用
-            pacsBillNames.addAll(billItems.stream()
-                    .filter(i -> i.getConditionLabel().equals(GraphLabelEnum.BillConflictItem.getName()))
-                    .map(i -> i.getConditionName())
-                    .distinct()
-                    .collect(Collectors.toList()));
-            //开单项使用
-            List<String> operationBillNames = billItems.stream()
-                    .filter(i -> i.getConceptLabel().equals(GraphLabelEnum.YiBaoOperationName.getName()))
-                    .map(i -> i.getConceptName())
-                    .distinct()
-                    .collect(Collectors.toList());
-            //禁忌项使用
+        if (ListUtil.isEmpty(billItems)) {
+            return retMap;
+        }
+        //开单项使用
+        List<String> lisBillNames = billItems.stream()
+                .filter(i -> i.getConceptLabel().equals(GraphLabelEnum.LisSet.getName()))
+                .map(i -> i.getConceptName())
+                .distinct()
+                .collect(Collectors.toList());
+        //禁忌项使用
+        lisBillNames.addAll(billItems.stream()
+                .filter(i -> i.getConditionLabel().equals(GraphLabelEnum.Lis.getName()))
+                .map(i -> i.getConditionName())
+                .distinct()
+                .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()
+                .collect(Collectors.toList());
+        //禁忌项使用
+        pacsBillNames.addAll(billItems.stream()
+                .filter(i -> i.getConditionLabel().equals(GraphLabelEnum.BillConflictItem.getName()))
+                .map(i -> i.getConditionName())
+                .distinct()
+                .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()));*/
-            //开单项使用
-            List<String> diseaseBillNames = billItems.stream()
-                    .filter(i -> i.getConceptLabel().equals(GraphLabelEnum.YiBaoDiseaseName.getName()))
-                    .map(i -> i.getConceptName())
-                    .distinct()
-                    .collect(Collectors.toList());
-            //禁忌项使用
-            diseaseBillNames.addAll(billItems.stream()
-                    .filter(i -> i.getConditionLabel().equals(GraphLabelEnum.Disease.getName()))
-                    .map(i -> i.getConditionName())
-                    .distinct()
-                    .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()));
+        //开单项使用
+        List<String> diseaseBillNames = billItems.stream()
+                .filter(i -> i.getConceptLabel().equals(GraphLabelEnum.YiBaoDiseaseName.getName()))
+                .map(i -> i.getConceptName())
+                .distinct()
+                .collect(Collectors.toList());
+        //禁忌项使用
+        diseaseBillNames.addAll(billItems.stream()
+                .filter(i -> i.getConditionLabel().equals(GraphLabelEnum.Disease.getName()))
+                .map(i -> i.getConditionName())
+                .distinct()
+                .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()));
+                }
+            }
+        }
+        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()
+                .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());
+        retMap.put("drug", medRegNames);
+        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;
+        }
+
+        items = items.stream()
+                .filter(i -> StringUtil.isNotBlank(i.getOpgrade())
+                        && !i.getOpgrade().equals("0")
+                        && !i.getOpgrade().equals("1"))
+                .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());
                     }
                 }
             }
-            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("lisBillNames", lisBillNames);
-            retMap.put("pacsBillNames", pacsBillNames);
-            retMap.put("diseaseBillNames", diseaseBillNames);
-            retMap.put("drugBillItems", drugBillNames);
-            retMap.put("operationBillNames", operationBillNames);
         }
+
+        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())
+                .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("disease", diseaseNames);
+        retMap.put("operation", operationNames);
         return retMap;
     }
 }

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

@@ -239,7 +239,7 @@ public class RuleTestController {
 
     //region --------------------------导出------------------------------
 
-    @ApiOperation(value = "导出规则未使用映射关系[by:zhaops]",
+    @ApiOperation(value = "导出规则未覆盖映射关系[by:zhaops]",
             notes = "")
     @PostMapping("/exportExcel")
     @SysLogger("exportExcel")
@@ -268,7 +268,8 @@ public class RuleTestController {
     }
 
     @ApiOperation(value = "高危药品规则测试结果导出[by:zhaops]",
-            notes = "success： 成功标志（0：失败，1：成功） <br>" +
+            notes = "hospitalId： 医院Id <br>" +
+                    "success： 成功标志（0：失败，1：成功） <br>" +
                     "resultId： 结果id <br>")
     @PostMapping("/highriskDrugExportExcel")
     @SysLogger("highriskDrugExportExcel")
@@ -277,7 +278,8 @@ public class RuleTestController {
     }
 
     @ApiOperation(value = "高危手术规则测试结果导出[by:zhaops]",
-            notes = "success： 成功标志（0：失败，1：成功） <br>" +
+            notes = "hospitalId： 医院Id <br>" +
+                    "success： 成功标志（0：失败，1：成功） <br>" +
                     "resultId： 结果id <br>")
     @PostMapping("/highriskOperationExportExcel")
     @SysLogger("highriskOperationExportExcel")
@@ -286,7 +288,8 @@ public class RuleTestController {
     }
 
     @ApiOperation(value = "化验其他提醒规则测试结果导出[by:zhaops]",
-            notes = "success： 成功标志（0：失败，1：成功） <br>" +
+            notes = "hospitalId： 医院Id <br>" +
+                    "success： 成功标志（0：失败，1：成功） <br>" +
                     "resultId： 结果id <br>")
     @PostMapping("/otherLisExportExcel")
     @SysLogger("otherLisExportExcel")
@@ -295,7 +298,8 @@ public class RuleTestController {
     }
 
     @ApiOperation(value = "辅检其他提醒规则测试结果导出[by:zhaops]",
-            notes = "success： 成功标志（0：失败，1：成功） <br>" +
+            notes = "hospitalId： 医院Id <br>" +
+                    "success： 成功标志（0：失败，1：成功） <br>" +
                     "resultId： 结果id <br>")
     @PostMapping("/otherPacsExportExcel")
     @SysLogger("otherPacsExportExcel")
@@ -304,7 +308,8 @@ public class RuleTestController {
     }
 
     @ApiOperation(value = "输血其他提醒规则测试结果导出[by:zhaops]",
-            notes = "success： 成功标志（0：失败，1：成功） <br>" +
+            notes = "hospitalId： 医院Id <br>" +
+                    "success： 成功标志（0：失败，1：成功） <br>" +
                     "resultId： 结果id <br>")
     @PostMapping("/otherTransfusionExportExcel")
     @SysLogger("otherTransfusionExportExcel")