自动化测试

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

@@ -86,44 +86,44 @@ public class RuleTestAggregate {
     /**
      * 开单合理性测试
      *
-     * @param billRuleVO
+     * @param ruleTestVO
      */
     @DataProvider("billRuleTest")
-    public Boolean billRuleTest(@InvokeParameter("billRuleVO") RuleTestVO billRuleVO) {
-        billTestExe(billRuleVO);
+    public Boolean billRuleTest(@InvokeParameter("ruleTestVO") RuleTestVO ruleTestVO) {
+        billTestExe(ruleTestVO);
         return true;
     }
 
     /**
      * 开单合理性测试-输血
      *
-     * @param billRuleVO
+     * @param ruleTestVO
      */
     @DataProvider("billTransfusionRuleTest")
-    public Boolean billTransfusionRuleTest(@InvokeParameter("billTransfusionRuleVO") RuleTestVO billRuleVO) {
-        billTestExe(billRuleVO);
+    public Boolean billTransfusionRuleTest(@InvokeParameter("billTransfusionRuleVO") RuleTestVO ruleTestVO) {
+        billTestExe(ruleTestVO);
         return true;
     }
 
     /**
      * 危急值规则测试-检验
      *
-     * @param billRuleVO
+     * @param ruleTestVO
      */
     @DataProvider("criticalLisRuleTest")
-    public Boolean criticalLisRuleTest(@InvokeParameter("criticalLisRuleVO") RuleTestVO billRuleVO) {
-        billTestExe(billRuleVO);
+    public Boolean criticalLisRuleTest(@InvokeParameter("criticalLisRuleVO") RuleTestVO ruleTestVO) {
+        billTestExe(ruleTestVO);
         return true;
     }
 
     /**
      * 危急值规则测试-检查
      *
-     * @param billRuleVO
+     * @param ruleTestVO
      */
     @DataProvider("criticalPacsRuleTest")
-    public Boolean criticalPacsRuleTest(@InvokeParameter("criticalPacsRuleVO") RuleTestVO billRuleVO) {
-        billTestExe(billRuleVO);
+    public Boolean criticalPacsRuleTest(@InvokeParameter("criticalPacsRuleVO") RuleTestVO ruleTestVO) {
+        billTestExe(ruleTestVO);
         return true;
     }
 
@@ -133,8 +133,8 @@ public class RuleTestAggregate {
      * @return
      */
     @DataProvider("highriskDrugRuleTest")
-    public Boolean highriskDrugRuleTest(@InvokeParameter("highriskDrugRuleVO") RuleTestVO billRuleVO) {
-        billTestExe(billRuleVO);
+    public Boolean highriskDrugRuleTest(@InvokeParameter("highriskDrugRuleVO") RuleTestVO ruleTestVO) {
+        billTestExe(ruleTestVO);
         return true;
     }
 
@@ -144,8 +144,8 @@ public class RuleTestAggregate {
      * @return
      */
     @DataProvider("highriskOperationRuleTest")
-    public Boolean highriskOperationRuleTest(@InvokeParameter("highriskOperationRuleVO") RuleTestVO billRuleVO) {
-        billTestExe(billRuleVO);
+    public Boolean highriskOperationRuleTest(@InvokeParameter("highriskOperationRuleVO") RuleTestVO ruleTestVO) {
+        billTestExe(ruleTestVO);
         return true;
     }
 
@@ -153,24 +153,24 @@ public class RuleTestAggregate {
     /**
      * 其他值提醒-化验
      *
-     * @param billRuleVO
+     * @param ruleTestVO
      * @return
      */
     @DataProvider("otherLisRuleTest")
-    public Boolean otherLisRuleTest(@InvokeParameter("otherLisRuleVO") RuleTestVO billRuleVO) {
-        billTestExe(billRuleVO);
+    public Boolean otherLisRuleTest(@InvokeParameter("otherLisRuleVO") RuleTestVO ruleTestVO) {
+        billTestExe(ruleTestVO);
         return true;
     }
 
     /**
      * 其他值提醒-辅检
      *
-     * @param billRuleVO
+     * @param ruleTestVO
      * @return
      */
     @DataProvider("otherPacsRuleTest")
-    public Boolean otherPacsRuleTest(@InvokeParameter("otherPacsRuleVO") RuleTestVO billRuleVO) {
-        billTestExe(billRuleVO);
+    public Boolean otherPacsRuleTest(@InvokeParameter("otherPacsRuleVO") RuleTestVO ruleTestVO) {
+        billTestExe(ruleTestVO);
         return true;
     }
 
@@ -178,24 +178,24 @@ public class RuleTestAggregate {
     /**
      * 其他值提醒-输血
      *
-     * @param billRuleVO
+     * @param ruleTestVO
      * @return
      */
     @DataProvider("otherTransfusionRuleTest")
-    public Boolean otherTransfusionRuleTest(@InvokeParameter("otherTransfusionRuleVO") RuleTestVO billRuleVO) {
-        billTestExe(billRuleVO);
+    public Boolean otherTransfusionRuleTest(@InvokeParameter("otherTransfusionRuleVO") RuleTestVO ruleTestVO) {
+        billTestExe(ruleTestVO);
         return true;
     }
 
     /**
      * 正常项目重复开单
      *
-     * @param billRuleVO
+     * @param ruleTestVO
      * @return
      */
     @DataProvider("reBillRuleTest")
-    public Boolean reBillRuleTest(@InvokeParameter("reBillRuleVO") RuleTestVO billRuleVO) {
-        billTestExe(billRuleVO);
+    public Boolean reBillRuleTest(@InvokeParameter("reBillRuleVO") RuleTestVO ruleTestVO) {
+        billTestExe(ruleTestVO);
         return true;
     }
 
@@ -203,27 +203,27 @@ public class RuleTestAggregate {
     /**
      * 执行测试
      *
-     * @param billRuleVO
+     * @param ruleTestVO
      * @return
      */
-    public Boolean billTestExe(RuleTestVO billRuleVO) {
-        Long hospitalId = billRuleVO.getHospitalId();
+    public Boolean billTestExe(RuleTestVO ruleTestVO) {
+        Long hospitalId = ruleTestVO.getHospitalId();
         //开始运行
         RunningInfoVO runningInfoVO = new RunningInfoVO();
-        runningInfoVO.setCaseId(billRuleVO.getCaseId());
-        runningInfoVO.setHospitalId(billRuleVO.getHospitalId());
+        runningInfoVO.setCaseId(ruleTestVO.getCaseId());
+        runningInfoVO.setHospitalId(ruleTestVO.getHospitalId());
         runningInfoVO.setStatus(1);
         runningInfoFacade.updateStatus(runningInfoVO);
 
         //生成测试规则
-        List<ResultRule> resultList = medRuleConvertFacade.billConvert(hospitalId, billRuleVO.getCaseId());
+        List<ResultRule> resultList = medRuleConvertFacade.billConvert(hospitalId, ruleTestVO.getCaseId());
         if (ListUtil.isEmpty(resultList)) {
             return true;
         }
         //远程调用推理
         List<ResultRule> saveList = callIndication(resultList, hospitalId);
         //保存测试结果
-        saveResultRule(saveList, billRuleVO);
+        saveResultRule(saveList, ruleTestVO);
 
         //结束运行
         runningInfoVO.setStatus(0);
@@ -256,8 +256,8 @@ public class RuleTestAggregate {
             }
 
             Integer ruleType = entry.getValue().get(0).getRuleType();
-            IndicationPushVO indicationPushVO = medSearchDataFacade.createBillVO(entry.getValue());
-            indicationPushVO.setHospitalId(hospitalId);
+            IndicationPushVO indicationPushVO = medSearchDataFacade.createBillVO(entry.getValue(),hospitalId);
+
             //入参
             entry.getValue().forEach(result -> {
                 result.setInputParams(FastJsonUtils.getBeanToJson(indicationPushVO));
@@ -346,11 +346,11 @@ public class RuleTestAggregate {
      * 保存开单合理性测试结果
      *
      * @param list
-     * @param billRuleVO
+     * @param ruleTestVO
      * @return
      */
     @Transactional
-    public Boolean saveResultRule(List<ResultRule> list, RuleTestVO billRuleVO) {
+    public Boolean saveResultRule(List<ResultRule> list, RuleTestVO ruleTestVO) {
         Date now = new Date();
         Integer totleNum = list.stream()
                 .map(i -> i.getRuleOrderNo())
@@ -367,13 +367,13 @@ public class RuleTestAggregate {
                 .collect(Collectors.toList()).size();
         QueryWrapper<ResultInfo> resultInfoQueryWrapper = new QueryWrapper<>();
         resultInfoQueryWrapper.eq("is_deleted", IsDeleteEnum.N.getKey())
-                .eq("hospital_id", billRuleVO.getHospitalId())
-                .eq("case_id", billRuleVO.getCaseId());
+                .eq("hospital_id", ruleTestVO.getHospitalId())
+                .eq("case_id", ruleTestVO.getCaseId());
         ResultInfo resultInfo = resultInfoService.getOne(resultInfoQueryWrapper, false);
         if (resultInfo == null) {
             resultInfo = new ResultInfo();
-            resultInfo.setHospitalId(billRuleVO.getHospitalId());
-            resultInfo.setCaseId(billRuleVO.getCaseId());
+            resultInfo.setHospitalId(ruleTestVO.getHospitalId());
+            resultInfo.setCaseId(ruleTestVO.getCaseId());
             resultInfo.setGmtCreate(now);
         }
         resultInfo.setGmtModified(now);

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

@@ -1,13 +1,17 @@
 package com.diagbot.facade;
 
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
 import com.diagbot.biz.push.entity.Lis;
 import com.diagbot.dto.BillMsg;
 import com.diagbot.dto.MedClassMedDTO;
 import com.diagbot.dto.RuleDTO;
+import com.diagbot.entity.KlConcept;
 import com.diagbot.entity.ResultRule;
 import com.diagbot.enums.ConEnum;
+import com.diagbot.enums.IsDeleteEnum;
 import com.diagbot.enums.LexiconEnum;
 import com.diagbot.enums.RuleBaseTypeEnum;
+import com.diagbot.enums.StatusEnum;
 import com.diagbot.enums.TypeEnum;
 import com.diagbot.util.BeanUtil;
 import com.diagbot.util.ListUtil;
@@ -36,6 +40,8 @@ import java.util.stream.Collectors;
  */
 @Component
 public class MedRuleConvertFacade {
+    @Autowired
+    private KlConceptFacade klConceptFacade;
     @Autowired
     private KlRuleFacade klRuleFacade;
     @Autowired
@@ -93,15 +99,13 @@ public class MedRuleConvertFacade {
                         LexiconEnum.PacsSubName.getKey() }));
             } else if (caseId.equals(5L)) {
                 ruleVO.setRuleType(2);
-                ruleVO.setLibTypes(Arrays.asList(new Integer[] { LexiconEnum.Medicine.getKey()
-                }));
+                ruleVO.setLibTypes(Arrays.asList(new Integer[] { LexiconEnum.Medicine.getKey() }));
             } else if (caseId.equals(6L)) {
                 ruleVO.setRuleType(2);
                 ruleVO.setLibTypes(Arrays.asList(new Integer[] { LexiconEnum.Operation.getKey() }));
             } else if (caseId.equals(7L)) {
                 ruleVO.setRuleType(4);
-                ruleVO.setLibTypes(Arrays.asList(new Integer[] { LexiconEnum.LisSubName.getKey()
-                }));
+                ruleVO.setLibTypes(Arrays.asList(new Integer[] { LexiconEnum.LisSubName.getKey() }));
             } else if (caseId.equals(8L)) {
                 ruleVO.setRuleType(4);
                 ruleVO.setLibTypes(Arrays.asList(new Integer[] { LexiconEnum.PacsResult.getKey() }));
@@ -133,9 +137,16 @@ public class MedRuleConvertFacade {
             list = highrisk_operation_distinct(list);
         }
 
+        list.forEach(result->{
+            if(result==null){
+                System.out.println();
+            }
+        });
+
         Map<String, List<RuleDTO>> map = list
                 .stream()
                 .collect(Collectors.groupingBy(k -> k.getRuleId() + "_" + k.getGroupType()));
+
         Long ruleOrderNo = 1L;
         for (Map.Entry<String, List<RuleDTO>> entry : map.entrySet()) {
             //多个条件的痛ruleOrderNo
@@ -430,8 +441,20 @@ public class MedRuleConvertFacade {
                 if (result.getRuleType().equals(4)) {
                     if (StringUtil.isNotBlank(result.getRuleBaseLibName())
                             && result.getRuleBaseLibName().equals("流产")) {
-                        List<String> conflictDiseases = diseaseConfigMap.keySet().stream()
-                                .filter(i -> i.contains(result.getRuleBaseLibName())).collect(Collectors.toList());
+                        List<String> conflictDiseases = Lists.newLinkedList();
+                        if (hospitalId < 0) {
+                            List<KlConcept> concepts = klConceptFacade.list(new QueryWrapper<KlConcept>()
+                                    .eq("is_deleted", IsDeleteEnum.N.getKey())
+                                    .eq("status", StatusEnum.Enable.getKey())
+                                    .eq("lib_type", LexiconEnum.Disease.getKey())
+                                    .like("lib_name", result.getRuleBaseLibName()));
+                            if (ListUtil.isNotEmpty(concepts)) {
+                                conflictDiseases = concepts.stream().map(i -> i.getLibName()).collect(Collectors.toList());
+                            }
+                        } else {
+                            conflictDiseases = diseaseConfigMap.keySet().stream()
+                                    .filter(i -> i.contains(result.getRuleBaseLibName())).collect(Collectors.toList());
+                        }
                         for (String conflictDisease : conflictDiseases) {
                             ResultRule convertResult = new ResultRule();
                             BeanUtil.copyProperties(result, convertResult);
@@ -484,136 +507,140 @@ public class MedRuleConvertFacade {
             ruleOrderNo = (long) rePacsBillList.size();
         }
 
-        //术语映射-开单项映射
-        ruleOrderNo = 0L;
-        Map<Long, List<ResultRule>> billMappingMap = rePacsBillList
-                .stream()
-                .collect(Collectors.groupingBy(ResultRule::getRuleOrderNo));
-        for (Map.Entry<Long, List<ResultRule>> entry : billMappingMap.entrySet()) {
-            Map<Integer, List<ResultRule>> tempMap = new HashMap<>();
-            Integer num = 1;
-            for (ResultRule result : entry.getValue()) {
-                List<ResultRule> tempList = Lists.newLinkedList();
-                if (result.getRuleLibType().equals(LexiconEnum.Medicine.getKey())) {
-                    List<ResultRule> mappingList = getMappingResult_medicine(result, drugConfigMap, 1);
-                    if (result.getRuleLibType().equals(result.getRuleBaseLibType())
-                            && result.getRuleLibName().equals(result.getRuleBaseLibName())) {
-                        mappingList.forEach(item -> {
-                            item.setRuleBaseHisName(item.getRuleHisName());
-                        });
-                    }
-                    tempList.addAll(mappingList);
-                } else if (result.getRuleLibType().equals(LexiconEnum.Operation.getKey())) {
-                    List<ResultRule> mappingList = getMappingResult(result, operationConfigMap, 1);
-                    if (result.getRuleLibType().equals(result.getRuleBaseLibType())
-                            && result.getRuleLibName().equals(result.getRuleBaseLibName())) {
-                        mappingList.forEach(item -> {
-                            item.setRuleBaseHisName(item.getRuleHisName());
-                        });
-                    }
-                    tempList.addAll(mappingList);
-                } else if (result.getRuleLibType().equals(LexiconEnum.LisName.getKey())) {
-                    List<ResultRule> mappingList = getMappingResult_lis(result, lisConfigMap, 1);
-                    if (result.getRuleLibType().equals(result.getRuleBaseLibType())
-                            && result.getRuleLibName().equals(result.getRuleBaseLibName())) {
-                        mappingList.forEach(item -> {
-                            item.setRuleBaseHisName(item.getRuleHisName());
-                            item.setRuleBaseHisDetailName(item.getRuleHisDetailName());
-                        });
-                    }
-                    tempList.addAll(mappingList);
-                } else if (result.getRuleLibType().equals(LexiconEnum.LisSubName.getKey())) {
-                    List<ResultRule> mappingList = getMappingResult_lis(result, lisConfigMap, 1);
-                    if (result.getRuleLibType().equals(result.getRuleBaseLibType())
-                            && result.getRuleLibName().equals(result.getRuleBaseLibName())) {
-                        mappingList.forEach(item -> {
-                            item.setRuleBaseHisName(item.getRuleHisName());
-                            item.setRuleBaseHisDetailName(item.getRuleHisDetailName());
-                        });
-                    }
-                    tempList.addAll(mappingList);
-                } else if (result.getRuleLibType().equals(LexiconEnum.PacsName.getKey())) {
-                    List<ResultRule> mappingList = getMappingResult(result, pacsConfigMap, 1);
-                    if (result.getRuleLibType().equals(result.getRuleBaseLibType())
-                            && result.getRuleLibName().equals(result.getRuleBaseLibName())) {
-                        mappingList.forEach(item -> {
-                            item.setRuleBaseHisName(item.getRuleHisName());
-                        });
-                    }
-                    tempList.addAll(mappingList);
-                } else if (result.getRuleLibType().equals(LexiconEnum.PacsSubName.getKey())) {
-                    List<ResultRule> mappingList = getMappingResult(result, pacsConfigMap, 1);
-                    if (result.getRuleLibType().equals(result.getRuleBaseLibType())
-                            && result.getRuleLibName().equals(result.getRuleBaseLibName())) {
-                        mappingList.forEach(item -> {
-                            item.setRuleBaseHisName(item.getRuleHisName());
-                        });
-                    }
-                    tempList.addAll(mappingList);
-                } else if (result.getRuleLibType().equals(LexiconEnum.Transfusion.getKey())) {
-                    List<ResultRule> mappingList = getMappingResult(result, transfusionConfigMap, 1);
-                    if (result.getRuleLibType().equals(result.getRuleBaseLibType())
-                            && result.getRuleLibName().equals(result.getRuleBaseLibName())) {
-                        mappingList.forEach(item -> {
-                            item.setRuleBaseHisName(item.getRuleHisName());
-                        });
+        if (hospitalId < 0) {
+            conflictMappingList = BeanUtil.listCopyTo(rePacsBillList, ResultRule.class);
+        } else {
+            //术语映射-开单项映射
+            ruleOrderNo = 0L;
+            Map<Long, List<ResultRule>> billMappingMap = rePacsBillList
+                    .stream()
+                    .collect(Collectors.groupingBy(ResultRule::getRuleOrderNo));
+            for (Map.Entry<Long, List<ResultRule>> entry : billMappingMap.entrySet()) {
+                Map<Integer, List<ResultRule>> tempMap = new HashMap<>();
+                Integer num = 1;
+                for (ResultRule result : entry.getValue()) {
+                    List<ResultRule> tempList = Lists.newLinkedList();
+                    if (result.getRuleLibType().equals(LexiconEnum.Medicine.getKey())) {
+                        List<ResultRule> mappingList = getMappingResult_medicine(result, drugConfigMap, 1);
+                        if (result.getRuleLibType().equals(result.getRuleBaseLibType())
+                                && result.getRuleLibName().equals(result.getRuleBaseLibName())) {
+                            mappingList.forEach(item -> {
+                                item.setRuleBaseHisName(item.getRuleHisName());
+                            });
+                        }
+                        tempList.addAll(mappingList);
+                    } else if (result.getRuleLibType().equals(LexiconEnum.Operation.getKey())) {
+                        List<ResultRule> mappingList = getMappingResult(result, operationConfigMap, 1);
+                        if (result.getRuleLibType().equals(result.getRuleBaseLibType())
+                                && result.getRuleLibName().equals(result.getRuleBaseLibName())) {
+                            mappingList.forEach(item -> {
+                                item.setRuleBaseHisName(item.getRuleHisName());
+                            });
+                        }
+                        tempList.addAll(mappingList);
+                    } else if (result.getRuleLibType().equals(LexiconEnum.LisName.getKey())) {
+                        List<ResultRule> mappingList = getMappingResult_lis(result, lisConfigMap, 1);
+                        if (result.getRuleLibType().equals(result.getRuleBaseLibType())
+                                && result.getRuleLibName().equals(result.getRuleBaseLibName())) {
+                            mappingList.forEach(item -> {
+                                item.setRuleBaseHisName(item.getRuleHisName());
+                                item.setRuleBaseHisDetailName(item.getRuleHisDetailName());
+                            });
+                        }
+                        tempList.addAll(mappingList);
+                    } else if (result.getRuleLibType().equals(LexiconEnum.LisSubName.getKey())) {
+                        List<ResultRule> mappingList = getMappingResult_lis(result, lisConfigMap, 1);
+                        if (result.getRuleLibType().equals(result.getRuleBaseLibType())
+                                && result.getRuleLibName().equals(result.getRuleBaseLibName())) {
+                            mappingList.forEach(item -> {
+                                item.setRuleBaseHisName(item.getRuleHisName());
+                                item.setRuleBaseHisDetailName(item.getRuleHisDetailName());
+                            });
+                        }
+                        tempList.addAll(mappingList);
+                    } else if (result.getRuleLibType().equals(LexiconEnum.PacsName.getKey())) {
+                        List<ResultRule> mappingList = getMappingResult(result, pacsConfigMap, 1);
+                        if (result.getRuleLibType().equals(result.getRuleBaseLibType())
+                                && result.getRuleLibName().equals(result.getRuleBaseLibName())) {
+                            mappingList.forEach(item -> {
+                                item.setRuleBaseHisName(item.getRuleHisName());
+                            });
+                        }
+                        tempList.addAll(mappingList);
+                    } else if (result.getRuleLibType().equals(LexiconEnum.PacsSubName.getKey())) {
+                        List<ResultRule> mappingList = getMappingResult(result, pacsConfigMap, 1);
+                        if (result.getRuleLibType().equals(result.getRuleBaseLibType())
+                                && result.getRuleLibName().equals(result.getRuleBaseLibName())) {
+                            mappingList.forEach(item -> {
+                                item.setRuleBaseHisName(item.getRuleHisName());
+                            });
+                        }
+                        tempList.addAll(mappingList);
+                    } else if (result.getRuleLibType().equals(LexiconEnum.Transfusion.getKey())) {
+                        List<ResultRule> mappingList = getMappingResult(result, transfusionConfigMap, 1);
+                        if (result.getRuleLibType().equals(result.getRuleBaseLibType())
+                                && result.getRuleLibName().equals(result.getRuleBaseLibName())) {
+                            mappingList.forEach(item -> {
+                                item.setRuleBaseHisName(item.getRuleHisName());
+                            });
+                        }
+                        tempList.addAll(mappingList);
+                    } else if (result.getRuleLibType().equals(LexiconEnum.PacsResult.getKey())) {
+                        tempList.add(result);
+                    } else {
+                        tempList.add(result);
                     }
-                    tempList.addAll(mappingList);
-                } else if (result.getRuleLibType().equals(LexiconEnum.PacsResult.getKey())) {
-                    tempList.add(result);
-                } else {
-                    tempList.add(result);
+                    tempMap.put(num++, tempList);
                 }
-                tempMap.put(num++, tempList);
+                billMappingList.addAll(addRuleOrderNo(tempMap, ruleOrderNo));
+                ruleOrderNo = (long) billMappingList.size();
             }
-            billMappingList.addAll(addRuleOrderNo(tempMap, ruleOrderNo));
-            ruleOrderNo = (long) billMappingList.size();
-        }
 
-        //术语映射-禁忌项映射
-        ruleOrderNo = 0L;
-        Map<Long, List<ResultRule>> conflictMappingMap = billMappingList
-                .stream()
-                .collect(Collectors.groupingBy(ResultRule::getRuleOrderNo));
-        for (Map.Entry<Long, List<ResultRule>> entry : conflictMappingMap.entrySet()) {
-            Map<Integer, List<ResultRule>> tempMap = new HashMap<>();
-            Integer num = 1;
-            for (ResultRule result : entry.getValue()) {
-                List<ResultRule> tempList = Lists.newLinkedList();
-                if (result.getHasSubCond() != null && result.getHasSubCond().equals(1)) {
-                    if (result.getRuleLibType().equals(result.getRuleBaseLibType())
-                            && result.getRuleLibName().equals(result.getRuleBaseLibName())) {
-                        tempList.add(result);
-                    } else {
-                        if (result.getRuleBaseLibType().equals(LexiconEnum.Disease.getKey())) {
-                            List<ResultRule> mappingList = getMappingResult(result, diseaseConfigMap, 2);
-                            tempList.addAll(mappingList);
-                        } else if (result.getRuleBaseLibType().equals(LexiconEnum.Medicine.getKey())) {
-                            List<ResultRule> mappingList = getMappingResult_medicine(result, drugConfigMap, 2);
-                            tempList.addAll(mappingList);
-                        } else if (result.getRuleBaseLibType().equals(LexiconEnum.LisSubName.getKey())) {
-                            List<ResultRule> mappingList = getMappingResult_lis(result, lisConfigMap, 2);
-                            tempList.addAll(mappingList);
-                        } else if (result.getRuleBaseLibType().equals(LexiconEnum.PacsName.getKey())) {
-                            List<ResultRule> mappingList = getMappingResult(result, pacsConfigMap, 2);
-                            tempList.addAll(mappingList);
-                        } else if (result.getRuleBaseLibType().equals(LexiconEnum.PacsSubName.getKey())) {
-                            List<ResultRule> mappingList = getMappingResult(result, pacsConfigMap, 2);
-                            tempList.addAll(mappingList);
-                        } else if (result.getRuleBaseLibType().equals(LexiconEnum.Operation.getKey())) {
-                            List<ResultRule> mappingList = getMappingResult(result, operationConfigMap, 2);
-                            tempList.addAll(mappingList);
-                        } else {
+            //术语映射-禁忌项映射
+            ruleOrderNo = 0L;
+            Map<Long, List<ResultRule>> conflictMappingMap = billMappingList
+                    .stream()
+                    .collect(Collectors.groupingBy(ResultRule::getRuleOrderNo));
+            for (Map.Entry<Long, List<ResultRule>> entry : conflictMappingMap.entrySet()) {
+                Map<Integer, List<ResultRule>> tempMap = new HashMap<>();
+                Integer num = 1;
+                for (ResultRule result : entry.getValue()) {
+                    List<ResultRule> tempList = Lists.newLinkedList();
+                    if (result.getHasSubCond() != null && result.getHasSubCond().equals(1)) {
+                        if (result.getRuleLibType().equals(result.getRuleBaseLibType())
+                                && result.getRuleLibName().equals(result.getRuleBaseLibName())) {
                             tempList.add(result);
+                        } else {
+                            if (result.getRuleBaseLibType().equals(LexiconEnum.Disease.getKey())) {
+                                List<ResultRule> mappingList = getMappingResult(result, diseaseConfigMap, 2);
+                                tempList.addAll(mappingList);
+                            } else if (result.getRuleBaseLibType().equals(LexiconEnum.Medicine.getKey())) {
+                                List<ResultRule> mappingList = getMappingResult_medicine(result, drugConfigMap, 2);
+                                tempList.addAll(mappingList);
+                            } else if (result.getRuleBaseLibType().equals(LexiconEnum.LisSubName.getKey())) {
+                                List<ResultRule> mappingList = getMappingResult_lis(result, lisConfigMap, 2);
+                                tempList.addAll(mappingList);
+                            } else if (result.getRuleBaseLibType().equals(LexiconEnum.PacsName.getKey())) {
+                                List<ResultRule> mappingList = getMappingResult(result, pacsConfigMap, 2);
+                                tempList.addAll(mappingList);
+                            } else if (result.getRuleBaseLibType().equals(LexiconEnum.PacsSubName.getKey())) {
+                                List<ResultRule> mappingList = getMappingResult(result, pacsConfigMap, 2);
+                                tempList.addAll(mappingList);
+                            } else if (result.getRuleBaseLibType().equals(LexiconEnum.Operation.getKey())) {
+                                List<ResultRule> mappingList = getMappingResult(result, operationConfigMap, 2);
+                                tempList.addAll(mappingList);
+                            } else {
+                                tempList.add(result);
+                            }
                         }
+                    } else {
+                        tempList.add(result);
                     }
-                } else {
-                    tempList.add(result);
+                    tempMap.put(num++, tempList);
                 }
-                tempMap.put(num++, tempList);
+                conflictMappingList.addAll(addRuleOrderNo(tempMap, ruleOrderNo));
+                ruleOrderNo = (long) conflictMappingList.size();
             }
-            conflictMappingList.addAll(addRuleOrderNo(tempMap, ruleOrderNo));
-            ruleOrderNo = (long) conflictMappingList.size();
         }
 
         //生成预期结果
@@ -639,13 +666,18 @@ public class MedRuleConvertFacade {
                 retList.addAll(entry.getValue());
                 continue;
             }
-            BillMsg billMsg = getBillMsg(entry.getValue());
+            BillMsg billMsg = new BillMsg();
+            if (hospitalId < 0) {
+                billMsg = getBillMsg_inner(entry.getValue());
+            } else {
+                billMsg = getBillMsg(entry.getValue());
+            }
             if (billMsg != null) {
-                entry.getValue().forEach(item -> {
+                for (ResultRule item : entry.getValue()) {
                     if (StringUtil.isBlank(item.getExpectedOutput())) {
                         item.setExpectedOutput(billMsg.getMsg());
                     }
-                });
+                }
             } else {
                 entry.getValue().forEach(item -> {
                     item.setSuccess(0);
@@ -739,7 +771,7 @@ public class MedRuleConvertFacade {
                 continue;
             }
             Integer num = 0;
-            List<String> baseIdList = Arrays.asList(entry.getKey().split("|"));
+            List<String> baseIdList = Arrays.asList(entry.getKey().split("\\|"));
             for (Long ruleId : entry.getValue()) {
                 retList.add(nestMap.get(ruleId).get(baseIdList.get(num++)));
                 if (num == baseIdList.size()) {
@@ -1286,6 +1318,348 @@ public class MedRuleConvertFacade {
         return billMsg;
     }
 
+    /**
+     * 模拟提示信息
+     *
+     * @param list
+     * @return
+     */
+    public BillMsg getBillMsg_inner(List<ResultRule> list) {
+        BillMsg billMsg = new BillMsg();
+        if (list.size() == 1) {
+            ResultRule resultRule = list.get(0);
+            String orderType = getOrderType(resultRule.getRuleLibTypeName());
+            String conType = "";
+            if (StringUtil.isNotBlank(resultRule.getRuleBaseLibTypeName())) {
+                conType = getConType(resultRule.getRuleBaseLibTypeName(), resultRule.getRuleType(), resultRule.getRuleBaseType());
+            }
+            //开单合理性
+            if (resultRule.getRuleType().equals(1)) {
+                if (resultRule.getHasSubCond() != null && resultRule.getHasSubCond().equals(1)) {
+                    if (resultRule.getRuleBaseLibType().equals(LexiconEnum.Disease.getKey())) {
+                        //禁忌疾病
+                        billMsg = MsgUtil.getCommonBillMsg(resultRule.getRuleLibName(),
+                                resultRule.getRuleLibName(),
+                                resultRule.getRuleBaseLibName(),
+                                conType,
+                                orderType);
+                    } else if (resultRule.getRuleBaseLibType().equals(LexiconEnum.Medicine.getKey())) {
+                        //禁忌服用药品
+                        if (resultRule.getRuleBaseType().equals(RuleBaseTypeEnum.Eq.getKey())) {
+                            billMsg = MsgUtil.getCommonBillMsg(resultRule.getRuleLibName(),
+                                    resultRule.getRuleLibName(),
+                                    resultRule.getRuleBaseLibName(),
+                                    conType,
+                                    orderType);
+                        } else if (resultRule.getRuleBaseType().equals(RuleBaseTypeEnum.Allergen.getKey())) {
+                            billMsg = MsgUtil.getCommonBillMsg(resultRule.getRuleLibName(),
+                                    resultRule.getRuleLibName(),
+                                    resultRule.getRuleBaseLibName(),
+                                    conType,
+                                    orderType);
+                        }
+                    } else if (resultRule.getRuleBaseLibType().equals(LexiconEnum.Symptom.getKey())) {
+                        //禁忌症状
+                        billMsg = MsgUtil.getCommonBillMsg(resultRule.getRuleLibName(),
+                                resultRule.getRuleLibName(),
+                                resultRule.getRuleBaseLibName(),
+                                conType,
+                                orderType);
+                    } else if (resultRule.getRuleBaseLibType().equals(LexiconEnum.Vital.getKey())) {
+                        String content = resultRule.getRuleBaseLibName();
+                        if (StringUtil.isNotBlank(resultRule.getRuleBaseInputValue())) {
+                            content += trimZero(resultRule.getRuleBaseInputValue());
+                        }
+                        billMsg = MsgUtil.getCommonBillMsg(resultRule.getRuleLibName(),
+                                resultRule.getRuleLibName(),
+                                content,
+                                conType,
+                                orderType);
+                    } else if (resultRule.getRuleBaseLibType().equals(LexiconEnum.VitalResult.getKey())) {
+                        billMsg = MsgUtil.getCommonBillMsg(resultRule.getRuleLibName(),
+                                resultRule.getRuleLibName(),
+                                resultRule.getRuleBaseLibName(),
+                                conType,
+                                orderType);
+                    } else if (resultRule.getRuleBaseLibType().equals(LexiconEnum.Operation.getKey())) {
+                        //禁忌手术
+                        billMsg = MsgUtil.getCommonBillMsg(resultRule.getRuleLibName(),
+                                resultRule.getRuleLibName(),
+                                resultRule.getRuleBaseLibName(),
+                                conType,
+                                orderType);
+                    } else if (resultRule.getRuleBaseLibType().equals(LexiconEnum.LisSubName.getKey())) {
+                        //禁忌实验室检查
+                        String content = resultRule.getRuleBaseLibName();
+                        if (StringUtil.isNotBlank(resultRule.getRuleBaseInputValue())) {
+                            content += trimZero(resultRule.getRuleBaseInputValue());
+                        }
+                        billMsg = MsgUtil.getCommonBillMsg(resultRule.getRuleLibName(),
+                                resultRule.getRuleLibName(),
+                                content,
+                                conType,
+                                orderType);
+                    } else if (resultRule.getRuleBaseLibType().equals(LexiconEnum.PacsName.getKey())) {
+                        //互斥项
+                        if (resultRule.getRuleBaseType().equals(RuleBaseTypeEnum.BillItem.getKey())) {
+                            billMsg = MsgUtil.getCommonBillMsg(resultRule.getRuleLibName(),
+                                    resultRule.getRuleLibName(),
+                                    resultRule.getRuleBaseLibName(),
+                                    conType,
+                                    orderType);
+                        }
+                    } else if (resultRule.getRuleBaseLibType().equals(LexiconEnum.PacsResult.getKey())) {
+                        //禁忌辅助检查结果
+                        billMsg = MsgUtil.getCommonBillMsg(resultRule.getRuleLibName(),
+                                resultRule.getRuleLibName(),
+                                resultRule.getRuleBaseLibName(),
+                                conType,
+                                orderType);
+                    } else if (resultRule.getRuleBaseLibType().equals(LexiconEnum.Gender.getKey())) {
+                        //禁忌性别
+                        billMsg = MsgUtil.getCommonBillMsg(resultRule.getRuleLibName(),
+                                resultRule.getRuleLibName(),
+                                resultRule.getRuleBaseLibName(),
+                                conType,
+                                orderType);
+                    } else if (resultRule.getRuleBaseLibType().equals(LexiconEnum.Group.getKey())) {
+                        //禁忌禁忌人群
+                        billMsg = MsgUtil.getCommonBillMsg(resultRule.getRuleLibName(),
+                                resultRule.getRuleLibName(),
+                                resultRule.getRuleBaseLibName(),
+                                conType,
+                                orderType);
+                    } else if (resultRule.getRuleBaseLibType().equals(LexiconEnum.Allergen.getKey())) {
+                        //其他过敏原
+                        billMsg = MsgUtil.getCommonBillMsg(resultRule.getRuleLibName(),
+                                resultRule.getRuleLibName(),
+                                resultRule.getRuleBaseLibName(),
+                                conType,
+                                orderType);
+                    } else if (resultRule.getRuleBaseLibType().equals(LexiconEnum.Device.getKey())) {
+                        //禁忌医疗器械及物品提示信息
+                        billMsg = MsgUtil.getCommonBillMsg(resultRule.getRuleLibName(),
+                                resultRule.getRuleLibName(),
+                                resultRule.getRuleBaseLibName(),
+                                conType,
+                                orderType);
+                    } else if (resultRule.getRuleBaseLibType().equals(LexiconEnum.Age.getKey())) {
+                        //年龄
+                        String content = resultRule.getRuleBaseLibName();
+                        if (StringUtil.isNotBlank(resultRule.getRuleBaseInputValue())) {
+                            content += trimZero(resultRule.getRuleBaseInputValue());
+                        }
+                        billMsg = MsgUtil.getCommonBillMsg(resultRule.getRuleLibName(),
+                                resultRule.getRuleLibName(),
+                                content,
+                                conType,
+                                orderType);
+                    } else {
+                        //通用
+                        String content = resultRule.getRuleBaseLibName();
+                        if (StringUtil.isNotBlank(resultRule.getRuleBaseInputValue())) {
+                            content += trimZero(resultRule.getRuleBaseInputValue());
+                        }
+                        billMsg = MsgUtil.getCommonBillMsg(resultRule.getRuleLibName(),
+                                resultRule.getRuleLibName(),
+                                content,
+                                conType,
+                                orderType);
+                    }
+                }
+            } else if (resultRule.getRuleType().equals(2)) {
+                if (resultRule.getHasSubCond() != null && resultRule.getHasSubCond().equals(1)) {
+                    if (resultRule.getRuleBaseLibType().equals(LexiconEnum.Disease.getKey())) {
+                        billMsg = MsgUtil.getCommonHighRiskMsg(resultRule.getRuleBaseLibName(), resultRule.getRuleLibName(), orderType);
+                    } else if (resultRule.getRuleBaseLibType().equals(LexiconEnum.Form.getKey())) {
+                        billMsg = MsgUtil.getCommonHighRiskMsg(resultRule.getReferenceValue(), resultRule.getRuleLibName(), orderType);
+                    } else if (resultRule.getRuleBaseLibType().equals(LexiconEnum.Vital.getKey())) {
+                        String content = "";
+                        if (resultRule.getRuleBaseLibName().equals("收缩压")) {
+                            content = "血压" + resultRule.getRuleBaseInputValue() + "/80";
+                        } else if (resultRule.getRuleBaseLibName().equals("舒张压")) {
+                            content = "血压120/" + resultRule.getRuleBaseInputValue();
+                        } else {
+                            content = resultRule.getRuleBaseLibName();
+                            if (StringUtil.isNotBlank(resultRule.getRuleBaseInputValue())) {
+                                content += trimZero(resultRule.getRuleBaseInputValue());
+                            }
+                        }
+                        billMsg = MsgUtil.getCommonHighRiskMsg(content, resultRule.getRuleLibName(), orderType);
+                    } else if (resultRule.getRuleBaseLibType().equals(LexiconEnum.VitalResult.getKey())) {
+                        billMsg = MsgUtil.getCommonHighRiskMsg(resultRule.getRuleBaseLibName(), resultRule.getRuleLibName(), orderType);
+                    } else if (resultRule.getRuleBaseLibType().equals(LexiconEnum.LisSubName.getKey())) {
+                        String content = "";
+                        if (StringUtil.isNotBlank(resultRule.getRuleBaseLibName())) {
+                            content += resultRule.getRuleBaseLibName();
+                        }
+                        if (StringUtil.isNotBlank(resultRule.getRuleBaseInputValue())) {
+                            content += trimZero(resultRule.getRuleBaseInputValue());
+                        }
+                        billMsg = MsgUtil.getCommonHighRiskMsg(content, resultRule.getRuleLibName(), orderType);
+                    } else if (resultRule.getRuleBaseLibType().equals(LexiconEnum.PacsResult.getKey())) {
+                        billMsg = MsgUtil.getCommonHighRiskMsg(resultRule.getRuleBaseLibName(), resultRule.getRuleLibName(), orderType);
+                    } else if (resultRule.getRuleBaseLibType().equals(LexiconEnum.Age.getKey())) {
+                        String content = resultRule.getRuleBaseLibName() + ":";
+                        if (StringUtil.isNotBlank(resultRule.getRuleBaseInputValue())) {
+                            content += trimZero(resultRule.getRuleBaseInputValue());
+                        }
+                        billMsg = MsgUtil.getCommonHighRiskMsg(content, resultRule.getRuleLibName(), orderType);
+                    } else {
+                        billMsg = MsgUtil.getCommonHighRiskMsg(resultRule.getRuleBaseLibName(), resultRule.getRuleLibName(), orderType);
+                    }
+                } else {
+                    billMsg = MsgUtil.getCommonHighRiskMsg("", resultRule.getRuleLibName(), orderType);
+                }
+            } else if (resultRule.getRuleType().equals(3)) {
+                if (resultRule.getRuleLibType().equals(LexiconEnum.LisSubName.getKey())) {
+                    String content = "";
+                    if (StringUtil.isNotBlank(resultRule.getRuleBaseLibName())) {
+                        content += resultRule.getRuleBaseLibName();
+                    }
+                    if (StringUtil.isNotBlank(resultRule.getRuleBaseInputValue())) {
+                        content += trimZero(resultRule.getRuleBaseInputValue());
+                    }
+                    billMsg = MsgUtil.getCommonCriticalMsg(content, orderType);
+                } else if (resultRule.getRuleLibType().equals(LexiconEnum.PacsResult.getKey())) {
+                    billMsg = MsgUtil.getCommonCriticalMsg(resultRule.getRuleLibName(), orderType);
+                }
+            } else if (resultRule.getRuleType().equals(4)) {
+                if (resultRule.getRuleLibType().equals(LexiconEnum.LisSubName.getKey())) {
+                    Lis lis = new Lis();
+                    lis.setUniqueName(resultRule.getRuleLibName());
+
+                    if (resultRule.getRuleBaseLibType().equals(LexiconEnum.LisSubName.getKey())) {
+                        String content = resultRule.getRuleLibName();
+                        if (StringUtil.isNotBlank(resultRule.getRuleBaseInputValue())) {
+                            content += trimZero(resultRule.getRuleBaseInputValue());
+                        }
+                        billMsg = MsgUtil.getCommonOtherMsg(orderType, content, resultRule.getRuleLibName(), conType, lis);
+                    } else if (resultRule.getRuleBaseLibType().equals(LexiconEnum.Group.getKey())) {
+                        billMsg = MsgUtil.getCommonOtherMsg(orderType, resultRule.getRuleBaseLibName(), resultRule.getRuleLibName(), ConEnum.group.getName(), lis);
+                    }
+                } else if (resultRule.getRuleLibType().equals(LexiconEnum.PacsResult.getKey())) {
+                    if (resultRule.getRuleBaseLibType().equals(LexiconEnum.PacsResult.getKey())) {
+                        if (resultRule.getRuleBaseType() != null && resultRule.getRuleBaseType().equals(RuleBaseTypeEnum.Eq.getKey())) {
+                            billMsg = MsgUtil.getCommonOtherMsg(orderType, resultRule.getExpectedOutput(), resultRule.getRuleLibName(), conType, null);
+                        } else if (resultRule.getRuleBaseType() != null && resultRule.getRuleBaseType().equals(RuleBaseTypeEnum.Ne.getKey())) {
+                            billMsg = MsgUtil.getCommonOtherMsg(orderType, resultRule.getExpectedOutput(), resultRule.getRuleLibName(), conType, null);
+                        }
+                    } else if (resultRule.getRuleBaseLibType().equals(LexiconEnum.Gender.getKey())) {
+                        billMsg = MsgUtil.getCommonOtherMsg(orderType, resultRule.getExpectedOutput(), resultRule.getRuleLibName(), conType, null);
+                    } else if (resultRule.getRuleBaseLibType().equals(LexiconEnum.Group.getKey())) {
+                        billMsg = MsgUtil.getCommonOtherMsg(orderType, resultRule.getExpectedOutput(), resultRule.getRuleLibName(), conType, null);
+                    } else if (resultRule.getRuleBaseLibType().equals(LexiconEnum.Age.getKey())) {
+                        billMsg = MsgUtil.getCommonOtherMsg(orderType, resultRule.getExpectedOutput(), resultRule.getRuleLibName(), conType, null);
+                    }
+                }
+            } else if (resultRule.getRuleType().equals(5)) {
+                if (resultRule.getRuleBaseLibType().equals(LexiconEnum.LisSubName.getKey())) {
+                    String content = "";
+                    content += resultRule.getRuleLibName();
+                    if (StringUtil.isNotBlank(resultRule.getRuleBaseInputValue())) {
+                        content += trimZero(resultRule.getRuleBaseInputValue());
+                    }
+                    billMsg = MsgUtil.getCommonOtherMsg(TypeEnum.transfusion.getName(), content, resultRule.getRuleMsg(), ConEnum.lis.getName(), null);
+                }
+            } else if (resultRule.getRuleType().equals(6)) {
+                billMsg = MsgUtil.getCommonBillMsg(resultRule.getRuleLibName(), resultRule.getRuleLibName(), resultRule.getRuleBaseLibName(), conType, orderType);
+            }
+        } else if (list.size() > 1) {
+            Integer ruleType = list.get(0).getRuleType();
+            Integer ruleLibType = list.get(0).getRuleLibType();
+            String orderType = getOrderType(list.get(0).getRuleLibTypeName());
+            if (ruleType.equals(3)) {
+                //检验危急值
+                if (ruleLibType.equals(LexiconEnum.LisSubName.getKey())) {
+                    ResultRule resultRule = list.stream()
+                            .filter(i -> i.getRuleBaseLibType().equals(LexiconEnum.LisSubName.getKey()))
+                            .collect(Collectors.toList())
+                            .get(0);
+                    String content = "";
+                    if (StringUtil.isNotBlank(resultRule.getRuleBaseLibName())) {
+                        content += resultRule.getRuleBaseLibName();
+                    }
+                    if (StringUtil.isNotBlank(resultRule.getRuleBaseInputValue())) {
+                        content += trimZero(resultRule.getRuleBaseInputValue());
+                    }
+                    billMsg = MsgUtil.getCommonCriticalMsg(content, orderType);
+                }
+            } else if (ruleType.equals(4)) {
+                //检验其他值
+                if (ruleLibType.equals(LexiconEnum.LisSubName.getKey())) {
+                    Lis lis = new Lis();
+                    lis.setUniqueName(list.get(0).getRuleLibName());
+
+                    ResultRule lisResult = list.stream()
+                            .filter(i -> i.getRuleBaseLibType().equals(LexiconEnum.LisSubName.getKey()))
+                            .collect(Collectors.toList())
+                            .get(0);
+                    List<ResultRule> diseaseResults = list.stream()
+                            .filter(i -> i.getRuleBaseLibType().equals(LexiconEnum.Disease.getKey()))
+                            .collect(Collectors.toList());
+                    List<ResultRule> operationResults = list.stream()
+                            .filter(i -> i.getRuleBaseLibType().equals(LexiconEnum.Operation.getKey()))
+                            .collect(Collectors.toList());
+                    List<ResultRule> medicineResults = list.stream()
+                            .filter(i -> i.getRuleBaseLibType().equals(LexiconEnum.Medicine.getKey()))
+                            .collect(Collectors.toList());
+                    List<ResultRule> groupResults = list.stream()
+                            .filter(i -> i.getRuleBaseLibType().equals(LexiconEnum.Group.getKey()))
+                            .collect(Collectors.toList());
+
+                    String content = lisResult.getRuleLibName();
+                    if (StringUtil.isNotBlank(lisResult.getRuleBaseInputValue())) {
+                        content += trimZero(lisResult.getRuleBaseInputValue());
+                    }
+
+                    if (ListUtil.isNotEmpty(diseaseResults)) {
+                        billMsg = MsgUtil.getCommonOtherMsg(orderType, content, diseaseResults.get(0).getRuleBaseLibName(), TypeEnum.disease.getName(), lis);
+                    } else if (ListUtil.isNotEmpty(operationResults)) {
+                        billMsg = MsgUtil.getCommonOtherMsg(orderType, content, operationResults.get(0).getRuleBaseLibName(), TypeEnum.operation.getName(), lis);
+                    } else if (ListUtil.isNotEmpty(medicineResults)) {
+                        billMsg = MsgUtil.getCommonOtherMsg(orderType, content, medicineResults.get(0).getRuleBaseLibName(), TypeEnum.drug.getName(), lis);
+                    } else if (ListUtil.isNotEmpty(groupResults)) {
+                        billMsg = MsgUtil.getCommonOtherMsg(orderType, content, groupResults.get(0).getRuleBaseLibName(), ConEnum.group.getName(), lis);
+                    } else {
+                        billMsg = MsgUtil.getCommonOtherMsg(orderType, content, "", ConEnum.lis.getName(), lis);
+                    }
+                } else if (ruleLibType.equals(LexiconEnum.PacsResult.getKey())) {
+                    billMsg = MsgUtil.getCommonOtherMsg(orderType, list.get(0).getExpectedOutput(), "", "", null);
+                }
+            } else if (ruleType.equals(5)) {
+                ResultRule lisResult = list.stream()
+                        .filter(i -> i.getRuleBaseLibType().equals(LexiconEnum.LisSubName.getKey()))
+                        .collect(Collectors.toList())
+                        .get(0);
+                List<ResultRule> diseaseResults = list.stream()
+                        .filter(i -> i.getRuleBaseLibType().equals(LexiconEnum.Disease.getKey()))
+                        .collect(Collectors.toList());
+                List<ResultRule> operationResults = list.stream()
+                        .filter(i -> i.getRuleBaseLibType().equals(LexiconEnum.Operation.getKey()))
+                        .collect(Collectors.toList());
+                String content = lisResult.getRuleLibName();
+                if (StringUtil.isNotBlank(lisResult.getRuleBaseInputValue())) {
+                    content += trimZero(lisResult.getRuleBaseInputValue());
+                }
+
+                if (ListUtil.isNotEmpty(diseaseResults)) {
+                    ResultRule diseaseResult = diseaseResults.get(0);
+                    content = "诊断" + diseaseResult.getRuleBaseLibName() + "，" + content;
+                    billMsg = MsgUtil.getCommonOtherMsg(TypeEnum.transfusion.getName(), content, lisResult.getRuleMsg(), ConEnum.disease.getName(), null);
+                } else if (ListUtil.isNotEmpty(operationResults)) {
+                    ResultRule operationResult = operationResults.get(0);
+                    content += "，已开" + operationResult.getRuleBaseLibName();
+                    billMsg = MsgUtil.getCommonOtherMsg(TypeEnum.transfusion.getName(), content, lisResult.getRuleMsg(), ConEnum.operations.getName(), null);
+                } else {
+                    billMsg = MsgUtil.getCommonOtherMsg(TypeEnum.transfusion.getName(), content, lisResult.getRuleMsg(), ConEnum.lis.getName(), null);
+                }
+            }
+        }
+        return billMsg;
+    }
+
+
     /**
      * 生成随机数
      *

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

@@ -32,11 +32,12 @@ public class MedSearchDataFacade {
      * @param list
      * @return
      */
-    public IndicationPushVO createBillVO(List<ResultRule> list) {
+    public IndicationPushVO createBillVO(List<ResultRule> list, Long hospitalId) {
         IndicationPushVO indicationPushVO = new IndicationPushVO();
+        indicationPushVO.setHospitalId(hospitalId);
         indicationPushVO.setAge("20");
         indicationPushVO.setSex(3);
-        Integer ruleType=list.get(0).getRuleType();
+        Integer ruleType = list.get(0).getRuleType();
         switch (ruleType) {
             case 1:
             case 6:
@@ -67,29 +68,49 @@ public class MedSearchDataFacade {
             if (result.getRuleType().equals(1)) {
                 if (result.getRuleLibType().equals(LexiconEnum.Medicine.getKey())) {
                     Drug drug = new Drug();
-                    drug.setName(result.getRuleHisName());
+                    if (hospitalId < 0) {
+                        drug.setName(result.getRuleLibName());
+                    } else {
+                        drug.setName(result.getRuleHisName());
+                    }
                     drug.setUniqueName(result.getRuleLibName());
                     indicationPushVO.getDrugOrder().add(drug);
                 } else if (result.getRuleLibType().equals(LexiconEnum.Operation.getKey())) {
                     Item operation = new Item();
-                    operation.setName(result.getRuleHisName());
+                    if (hospitalId < 0) {
+                        operation.setName(result.getRuleLibName());
+                    } else {
+                        operation.setName(result.getRuleHisName());
+                    }
                     operation.setUniqueName(result.getRuleLibName());
                     indicationPushVO.getOperationOrder().add(operation);
                 } else if (result.getRuleLibType().equals(LexiconEnum.LisName.getKey())) {
                     //检验开单项
                     Lis lis = new Lis();
-                    lis.setName(result.getRuleHisName());
+                    if (hospitalId < 0) {
+                        lis.setName(result.getRuleLibName());
+                    } else {
+                        lis.setName(result.getRuleHisName());
+                    }
                     lis.setUniqueName(result.getRuleLibName());
                     indicationPushVO.getLisOrder().add(lis);
                 } else if (result.getRuleLibType().equals(LexiconEnum.PacsName.getKey())
                         || result.getRuleLibType().equals(LexiconEnum.PacsSubName.getKey())) {
                     Pacs pacs = new Pacs();
-                    pacs.setName(result.getRuleHisName());
+                    if (hospitalId < 0) {
+                        pacs.setName(result.getRuleLibName());
+                    } else {
+                        pacs.setName(result.getRuleHisName());
+                    }
                     pacs.setUniqueName(result.getRuleLibName());
                     indicationPushVO.getPacsOrder().add(pacs);
                 } else if (result.getRuleLibType().equals(LexiconEnum.Transfusion.getKey())) {
                     ItemExt itemExt = new ItemExt();
-                    itemExt.setName(result.getRuleHisName());
+                    if (hospitalId < 0) {
+                        itemExt.setName(result.getRuleLibName());
+                    } else {
+                        itemExt.setName(result.getRuleHisName());
+                    }
                     itemExt.setUniqueName(result.getRuleLibName());
                     indicationPushVO.getTransfusionOrder().add(itemExt);
                 }
@@ -97,13 +118,21 @@ public class MedSearchDataFacade {
                 //高危
                 if (result.getRuleLibType().equals(LexiconEnum.Medicine.getKey())) {
                     Drug drug = new Drug();
-                    drug.setName(result.getRuleHisName());
+                    if (hospitalId < 0) {
+                        drug.setName(result.getRuleLibName());
+                    } else {
+                        drug.setName(result.getRuleHisName());
+                    }
                     drug.setUniqueName(result.getRuleLibName());
                     drug.setForm(result.getRuleBaseLibName());
                     indicationPushVO.getDrugOrder().add(drug);
                 } else if (result.getRuleLibType().equals(LexiconEnum.Operation.getKey())) {
                     Item operation = new Item();
-                    operation.setName(result.getRuleHisName());
+                    if (hospitalId < 0) {
+                        operation.setName(result.getRuleLibName());
+                    } else {
+                        operation.setName(result.getRuleHisName());
+                    }
                     operation.setUniqueName(result.getRuleLibName());
                     indicationPushVO.getOperationOrder().add(operation);
                 }
@@ -112,8 +141,13 @@ public class MedSearchDataFacade {
                 if (result.getRuleLibType().equals(LexiconEnum.LisSubName.getKey())) {
                     //检验开单项
                     Lis lis = new Lis();
-                    lis.setName(result.getRuleHisName());
-                    lis.setDetailName(result.getRuleHisDetailName());
+                    if (hospitalId < 0) {
+                        lis.setName(result.getRuleLibName());
+                        lis.setDetailName("");
+                    } else {
+                        lis.setName(result.getRuleHisName());
+                        lis.setDetailName(result.getRuleHisDetailName());
+                    }
                     lis.setUniqueName(result.getRuleLibName());
                     indicationPushVO.getLis().add(lis);
                 } else if (result.getRuleLibType().equals(LexiconEnum.PacsResult.getKey())) {
@@ -149,7 +183,11 @@ public class MedSearchDataFacade {
                 if (result.getRuleLibType().equals(LexiconEnum.PacsName.getKey())
                         || result.getRuleLibType().equals(LexiconEnum.PacsSubName.getKey())) {
                     Pacs pacs = new Pacs();
-                    pacs.setName(result.getRuleHisName());
+                    if (hospitalId < 0) {
+                        pacs.setName(result.getRuleLibName());
+                    } else {
+                        pacs.setName(result.getRuleHisName());
+                    }
                     pacs.setUniqueName(result.getRuleLibName());
                     pacs.setDateValue(now);
                     indicationPushVO.getPacsOrder().add(pacs);
@@ -161,21 +199,33 @@ public class MedSearchDataFacade {
                 if (result.getRuleBaseLibType().equals(LexiconEnum.Disease.getKey())) {
                     if (result.getRuleBaseType().equals(RuleBaseTypeEnum.Eq.getKey())) {
                         Item diag = new Item();
-                        diag.setName(result.getRuleBaseHisName());
+                        if (hospitalId < 0) {
+                            diag.setName(result.getRuleBaseLibName());
+                        } else {
+                            diag.setName(result.getRuleBaseHisName());
+                        }
                         diag.setUniqueName(result.getRuleBaseLibName());
                         indicationPushVO.getDiag().add(diag);
                     }
                 } else if (result.getRuleBaseLibType().equals(LexiconEnum.Medicine.getKey())) {
                     if (result.getRuleBaseType().equals(RuleBaseTypeEnum.Eq.getKey())) {
-                        indicationPushVO.setSymptom(indicationPushVO.getSymptom() +
-                                (StringUtil.isNotBlank(result.getRuleBaseHisName())
-                                        ? ("一直服用" + result.getRuleBaseHisName() + ",")
-                                        : ""));
+                        if (hospitalId < 0) {
+                            indicationPushVO.setSymptom(indicationPushVO.getSymptom() + "一直服用" + result.getRuleBaseLibName() + ",");
+                        } else {
+                            indicationPushVO.setSymptom(indicationPushVO.getSymptom() +
+                                    (StringUtil.isNotBlank(result.getRuleBaseHisName())
+                                            ? ("一直服用" + result.getRuleBaseHisName() + ",")
+                                            : ""));
+                        }
                     } else if (result.getRuleBaseType().equals(RuleBaseTypeEnum.Allergen.getKey())) {
-                        indicationPushVO.setPasts(indicationPushVO.getPasts() +
-                                (StringUtil.isNotBlank(result.getRuleBaseHisName())
-                                        ? ("对" + result.getRuleBaseHisName() + "过敏,")
-                                        : ""));
+                        if (hospitalId < 0) {
+                            indicationPushVO.setPasts(indicationPushVO.getPasts() + "对" + result.getRuleBaseLibName() + "过敏,");
+                        } else {
+                            indicationPushVO.setPasts(indicationPushVO.getPasts() +
+                                    (StringUtil.isNotBlank(result.getRuleBaseHisName())
+                                            ? ("对" + result.getRuleBaseHisName() + "过敏,")
+                                            : ""));
+                        }
                     }
                 } else if (result.getRuleBaseLibType().equals(LexiconEnum.Symptom.getKey())) {
                     if (result.getRuleBaseType().equals(RuleBaseTypeEnum.Eq.getKey())) {
@@ -194,15 +244,24 @@ public class MedSearchDataFacade {
                 } else if (result.getRuleBaseLibType().equals(LexiconEnum.Operation.getKey())) {
                     if (result.getRuleBaseType().equals(RuleBaseTypeEnum.Eq.getKey())) {
                         Item operation = new Item();
-                        operation.setName(result.getRuleBaseHisName());
+                        if (hospitalId < 0) {
+                            operation.setName(result.getRuleBaseLibName());
+                        } else {
+                            operation.setName(result.getRuleBaseHisName());
+                        }
                         operation.setUniqueName(result.getRuleBaseLibName());
                         indicationPushVO.getOperation().add(operation);
                     }
                 } else if (result.getRuleBaseLibType().equals(LexiconEnum.LisSubName.getKey())) {
                     if (result.getRuleBaseType().equals(RuleBaseTypeEnum.Compare.getKey())) {
                         Lis lis = new Lis();
-                        lis.setName(result.getRuleBaseHisName());
-                        lis.setDetailName(result.getRuleBaseHisDetailName());
+                        if (hospitalId < 0) {
+                            lis.setName(result.getRuleBaseLibName());
+                            lis.setDetailName("");
+                        } else {
+                            lis.setName(result.getRuleBaseHisName());
+                            lis.setDetailName(result.getRuleBaseHisDetailName());
+                        }
                         lis.setUniqueName(result.getRuleBaseLibName());
                         lis.setUnits(result.getRuleBaseUnit());
                         Pattern pattern = Pattern.compile("^\\d+(\\.\\d+)?$");
@@ -226,12 +285,20 @@ public class MedSearchDataFacade {
                         || result.getRuleBaseLibType().equals(LexiconEnum.PacsSubName.getKey())) {
                     if (result.getRuleBaseType().equals(RuleBaseTypeEnum.BillItem.getKey())) {
                         Pacs pacs = new Pacs();
-                        pacs.setName(result.getRuleBaseHisName());
+                        if (hospitalId < 0) {
+                            pacs.setName(result.getRuleBaseLibName());
+                        } else {
+                            pacs.setName(result.getRuleBaseHisName());
+                        }
                         pacs.setUniqueName(result.getRuleBaseLibName());
                         indicationPushVO.getPacsOrder().add(pacs);
                     } else if (result.getRuleBaseType().equals(RuleBaseTypeEnum.Regex.getKey())) {
                         Pacs pacs = new Pacs();
-                        pacs.setName(result.getRuleBaseHisName());
+                        if (hospitalId < 0) {
+                            pacs.setName(result.getRuleBaseLibName());
+                        } else {
+                            pacs.setName(result.getRuleBaseHisName());
+                        }
                         pacs.setUniqueName(result.getRuleBaseLibName());
                         pacs.setDesc(result.getRuleBaseInputValue());
                         pacs.setResult(result.getRuleBaseInputValue());