远程调用有效规则和明细查看接口

cdssman-service/src/main/java/com/diagbot/client/CdssCoreClient.java

@@ -224,4 +224,12 @@ public interface CdssCoreClient {
     //在集合业务中，搜索术语
     @PostMapping("/klDisease/searchCollectionConceptVO")
     RespDTO<List<GetAllForRelationDTO>> searchCollectionConcept(SearchCollectionConceptVO searchCollectionConceptVO);
+
+    //查询所有有效的规则
+    @PostMapping("/klRule/getRulePage")
+    RespDTO<Page<RuleQueryDTO>> getRulePage(@RequestBody RuleQueryVO ruleQueryVO);
+
+    //根据录入内容查询有效规则的明细
+    @PostMapping("/klRule/getRuleDetail")
+    RespDTO<RuleDTO> getRuleDetail(@RequestBody @Valid RuleQueryKeyVO ruleQueryKeyVO);
 }

cdssman-service/src/main/java/com/diagbot/client/hystrix/CdssCoreHystrix.java

@@ -308,4 +308,16 @@ public class CdssCoreHystrix implements CdssCoreClient {
         log.error("【hystrix】调用{}异常", "searchConceptRuleClass");
         return null;
     }
+
+    @Override
+    public RespDTO<Page<RuleQueryDTO>> getRulePage(@RequestBody RuleQueryVO ruleQueryVO) {
+        log.error("【hystrix】调用{}异常", "getRulePage");
+        return null;
+    }
+
+    @Override
+    public RespDTO<RuleDTO> getRuleDetail(@RequestBody @Valid RuleQueryKeyVO ruleQueryKeyVO) {
+        log.error("【hystrix】调用{}异常", "getRuleDetail");
+        return null;
+    }
 }

cdssman-service/src/main/java/com/diagbot/dto/RuleBaseDTO.java

@@ -0,0 +1,28 @@
+package com.diagbot.dto;
+
+import lombok.Getter;
+import lombok.Setter;
+import lombok.ToString;
+
+/**
+ * @Description:
+ * @author: gaodm
+ * @time: 2021/2/3 16:25
+ */
+@Getter
+@Setter
+@ToString(includeFieldNames = false)
+public class RuleBaseDTO {
+    private String baseLibName = "";
+    private Integer baseLibType = 0;
+    private Integer baseType = 0;
+    private String baseMinOperator = "";
+    private String baseMinValue = "";
+    private String baseMinUnit = "";
+    private String baseMaxOperator = "";
+    private String baseMaxValue = "";
+    private String baseMaxUnit = "";
+    private String baseEqOperator = "";
+    private String baseEqValue = "";
+    private String baseEqUnit = "";
+}

cdssman-service/src/main/java/com/diagbot/dto/RuleConditionDTO.java

@@ -0,0 +1,24 @@
+package com.diagbot.dto;
+
+import lombok.Getter;
+import lombok.Setter;
+import lombok.ToString;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * @Description:
+ * @author: gaodm
+ * @time: 2021/2/3 16:32
+ */
+@Getter
+@Setter
+@ToString(exclude = { "ruleGroup", "msg", "description" }, includeFieldNames = false)
+public class RuleConditionDTO {
+    private Integer hasSubCond;
+    private String ruleGroup;
+    private String msg;
+    private String description;
+    private List<RuleBaseDTO> ruleBaseDTOList = new ArrayList<>();
+}

cdssman-service/src/main/java/com/diagbot/dto/RuleDTO.java

@@ -3,39 +3,19 @@ package com.diagbot.dto;
 import lombok.Getter;
 import lombok.Setter;
 
+import java.util.ArrayList;
+import java.util.List;
+
 /**
  * @Description:
- * @Author:zhaops
- * @time: 2021/3/1 15:40
+ * @author: gaodm
+ * @time: 2021/2/3 16:34
  */
 @Getter
 @Setter
 public class RuleDTO {
-    private Long ruleOrderNo;
+    private String libName;
+    private Integer libType;
     private Integer ruleType;
-    private Integer ruleLibType;
-    private String ruleLibTypeName;
-    private String ruleLibName;
-    private Long ruleId;
-    private Long ruleConceptId;
-    private String ruleDescription;
-    private Integer hasSubCond;
-    private String ruleMsg;
-    private Integer groupType;
-    private Long ruleBaseId;
-    private String ruleBaseDescription;
-    private String ruleBaseEqOperator;
-    private String ruleBaseEqUnit;
-    private String ruleBaseEqValue;
-    private String ruleBaseMaxOperator;
-    private String ruleBaseMaxUnit;
-    private Double ruleBaseMaxValue;
-    private String ruleBaseMinOperator;
-    private String ruleBaseMinUnit;
-    private Double ruleBaseMinValue;
-    private Integer ruleBaseType;
-    private Long ruleBaseConceptId;
-    private String ruleBaseLibName;
-    private Integer ruleBaseLibType;
-    private String ruleBaseLibTypeName;
-}
+    private List<RuleConditionDTO> ruleConditionDTOList = new ArrayList<>();
+}

cdssman-service/src/main/java/com/diagbot/dto/RuleGetDTO.java

@@ -0,0 +1,41 @@
+package com.diagbot.dto;
+
+import lombok.Getter;
+import lombok.Setter;
+
+/**
+ * @Description:
+ * @Author:zhaops
+ * @time: 2021/3/1 15:40
+ */
+@Getter
+@Setter
+public class RuleGetDTO {
+    private Long ruleOrderNo;
+    private Integer ruleType;
+    private Integer ruleLibType;
+    private String ruleLibTypeName;
+    private String ruleLibName;
+    private Long ruleId;
+    private Long ruleConceptId;
+    private String ruleDescription;
+    private Integer hasSubCond;
+    private String ruleMsg;
+    private Integer groupType;
+    private Long ruleBaseId;
+    private String ruleBaseDescription;
+    private String ruleBaseEqOperator;
+    private String ruleBaseEqUnit;
+    private String ruleBaseEqValue;
+    private String ruleBaseMaxOperator;
+    private String ruleBaseMaxUnit;
+    private Double ruleBaseMaxValue;
+    private String ruleBaseMinOperator;
+    private String ruleBaseMinUnit;
+    private Double ruleBaseMinValue;
+    private Integer ruleBaseType;
+    private Long ruleBaseConceptId;
+    private String ruleBaseLibName;
+    private Integer ruleBaseLibType;
+    private String ruleBaseLibTypeName;
+}

cdssman-service/src/main/java/com/diagbot/dto/RuleQueryDTO.java

@@ -0,0 +1,19 @@
+package com.diagbot.dto;
+
+import lombok.Getter;
+import lombok.Setter;
+
+/**
+ * @Description:
+ * @author: gaodm
+ * @time: 2021/12/30 13:21
+ */
+@Getter
+@Setter
+public class RuleQueryDTO {
+    private String libName;
+    private Integer libType;
+    private String libTypeName;
+    private Integer ruleType;
+    private String ruleTypeName;
+}

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

@@ -7,6 +7,8 @@ import com.diagbot.client.UserServiceClient;
 import com.diagbot.dto.KlRuleByIdParDTO;
 import com.diagbot.dto.KlRuleInfoDTO;
 import com.diagbot.dto.RespDTO;
+import com.diagbot.dto.RuleDTO;
+import com.diagbot.dto.RuleQueryDTO;
 import com.diagbot.exception.CommonErrorCode;
 import com.diagbot.exception.CommonException;
 import com.diagbot.service.impl.KlRuleServiceImpl;
@@ -17,6 +19,8 @@ import com.diagbot.vo.KlRuleInfoClearVO;
 import com.diagbot.vo.KlRuleInfoSaveVO;
 import com.diagbot.vo.KlRuleInfoVO;
 import com.diagbot.vo.KlRuleSatartOrdisaVO;
+import com.diagbot.vo.RuleQueryKeyVO;
+import com.diagbot.vo.RuleQueryVO;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;
 
@@ -82,4 +86,16 @@ public class KlRuleFacade extends KlRuleServiceImpl {
         RespDTOUtil.respNGDeal(booleanRespDTO, "启用规则失败");
         return booleanRespDTO.data;
     }
+
+    public Page<RuleQueryDTO> getRulePage(RuleQueryVO ruleQueryVO) {
+        RespDTO<Page<RuleQueryDTO>> rulepageRespDTO = cdssCoreClient.getRulePage(ruleQueryVO);
+        RespDTOUtil.respNGDeal(rulepageRespDTO, "查询所有有效的规则失败");
+        return rulepageRespDTO.data;
+    }
+
+    public RuleDTO getRuleDetail(RuleQueryKeyVO ruleQueryKeyVO) {
+        RespDTO<RuleDTO> ruleDTORespDTO = cdssCoreClient.getRuleDetail(ruleQueryKeyVO);
+        RespDTOUtil.respNGDeal(ruleDTORespDTO, "查询规则明细失败");
+        return ruleDTORespDTO.data;
+    }
 }

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

@@ -4,7 +4,7 @@ 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.dto.RuleGetDTO;
 import com.diagbot.entity.KlConcept;
 import com.diagbot.entity.KlRuleBase;
 import com.diagbot.entity.ResultRule;
@@ -68,7 +68,7 @@ public class MedRuleConvertFacade {
      */
     public List<ResultRule> billConvert(Long hospitalId, Long caseId) {
         List<ResultRule> retList = Lists.newLinkedList();
-        List<RuleDTO> groupList = Lists.newLinkedList();
+        List<RuleGetDTO> groupList = Lists.newLinkedList();
         List<ResultRule> inputList = Lists.newLinkedList();
         List<ResultRule> medicineList = Lists.newLinkedList();
         List<ResultRule> containsDiseaseList = Lists.newLinkedList();
@@ -118,7 +118,7 @@ public class MedRuleConvertFacade {
                 }));
             }
         }
-        List<RuleDTO> list = klRuleFacade.getRules(ruleVO);
+        List<RuleGetDTO> list = klRuleFacade.getRules(ruleVO);
 
         if (ListUtil.isEmpty(list)) {
             return retList;
@@ -142,30 +142,30 @@ public class MedRuleConvertFacade {
             list = highrisk_operation_distinct(list);
         }
 
-        Map<String, List<RuleDTO>> map = list
+        Map<String, List<RuleGetDTO>> map = list
                 .stream()
                 .collect(Collectors.groupingBy(k -> k.getRuleId() + "_" + k.getGroupType()));
 
         Long ruleOrderNo = 1L;
-        for (Map.Entry<String, List<RuleDTO>> entry : map.entrySet()) {
+        for (Map.Entry<String, List<RuleGetDTO>> entry : map.entrySet()) {
             //多个条件的痛ruleOrderNo
-            for (RuleDTO item : entry.getValue()) {
+            for (RuleGetDTO item : entry.getValue()) {
                 item.setRuleOrderNo(ruleOrderNo);
                 groupList.add(item);
             }
             ruleOrderNo++;
         }
         groupList = groupList.stream()
-                .sorted(Comparator.comparing(RuleDTO::getRuleOrderNo).thenComparing(RuleDTO::getGroupType))
+                .sorted(Comparator.comparing(RuleGetDTO::getRuleOrderNo).thenComparing(RuleGetDTO::getGroupType))
                 .collect(Collectors.toList());
 
-        Map<Long, List<RuleDTO>> groupMap = groupList
+        Map<Long, List<RuleGetDTO>> groupMap = groupList
                 .stream()
-                .collect(Collectors.groupingBy(RuleDTO::getRuleOrderNo));
-        for (Map.Entry<Long, List<RuleDTO>> entry : groupMap.entrySet()) {
+                .collect(Collectors.groupingBy(RuleGetDTO::getRuleOrderNo));
+        for (Map.Entry<Long, List<RuleGetDTO>> entry : groupMap.entrySet()) {
             Map<Integer, List<ResultRule>> tempMap = new HashMap<>();
             Integer num = 1;
-            for (RuleDTO record : entry.getValue()) {
+            for (RuleGetDTO record : entry.getValue()) {
                 System.out.println(FastJsonUtils.getBeanToJson(record));
                 List<ResultRule> tempList = Lists.newLinkedList();
 
@@ -786,8 +786,8 @@ public class MedRuleConvertFacade {
      * @param list
      * @return
      */
-    public List<RuleDTO> highrisk_operation_distinct(List<RuleDTO> list) {
-        List<RuleDTO> retList = Lists.newLinkedList();
+    public List<RuleGetDTO> highrisk_operation_distinct(List<RuleGetDTO> list) {
+        List<RuleGetDTO> retList = Lists.newLinkedList();
 
         if (ListUtil.isEmpty(list)) {
             return list;
@@ -799,7 +799,7 @@ public class MedRuleConvertFacade {
                 .collect(Collectors.toList()));
 
         //带子条件的规则
-        List<RuleDTO> listWithCond = list.stream()
+        List<RuleGetDTO> listWithCond = list.stream()
                 .filter(i -> i.getHasSubCond() != null && i.getHasSubCond().equals(1))
                 .collect(Collectors.toList());
         if (ListUtil.isEmpty(listWithCond)) {
@@ -826,13 +826,13 @@ public class MedRuleConvertFacade {
                         + v.getEqValue() + "_"
                         + v.getEqUnit()));
 
-        Map<Long, List<RuleDTO>> ruleIdMap = listWithCond.stream()
-                .collect(Collectors.groupingBy(RuleDTO::getRuleId));
-        Map<Long, Map<String, RuleDTO>> baseNestMap = new HashMap<>();
+        Map<Long, List<RuleGetDTO>> ruleIdMap = listWithCond.stream()
+                .collect(Collectors.groupingBy(RuleGetDTO::getRuleId));
+        Map<Long, Map<String, RuleGetDTO>> baseNestMap = new HashMap<>();
         Map<Long, String> baseCondMap = new HashMap<>();
-        for (Map.Entry<Long, List<RuleDTO>> entry : ruleIdMap.entrySet()) {
-            Map<String, RuleDTO> subMap = new HashMap<>();
-            for (RuleDTO result : entry.getValue()) {
+        for (Map.Entry<Long, List<RuleGetDTO>> entry : ruleIdMap.entrySet()) {
+            Map<String, RuleGetDTO> subMap = new HashMap<>();
+            for (RuleGetDTO result : entry.getValue()) {
                 subMap.put(ruleBaseMap.get(result.getRuleBaseId()), result);
             }
             baseNestMap.put(entry.getKey(), subMap);

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

@@ -4,7 +4,7 @@ import com.diagbot.aggregate.RuleTestAggregate;
 import com.diagbot.client.CdssCoreClient;
 import com.diagbot.dto.IndexBatchDTO;
 import com.diagbot.dto.RespDTO;
-import com.diagbot.dto.RuleDTO;
+import com.diagbot.dto.RuleGetDTO;
 import com.diagbot.entity.DiseaseConfig;
 import com.diagbot.entity.DrugConfig;
 import com.diagbot.entity.LisConfig;
@@ -241,7 +241,7 @@ public class RuleTestFacade {
     public void exportExcel(HttpServletResponse response, HospitalIdVO hospitalIdVO) {
         Long hospitalId = hospitalIdVO.getHospitalId();
 
-        List<RuleDTO> list = klRuleFacade.getRules(new RuleVO());
+        List<RuleGetDTO> list = klRuleFacade.getRules(new RuleVO());
 
         List<MappingConfigWrapper> lisConfigList = mappingConfigFacade.getListByHospitalIdAndType(hospitalId, ConceptTypeEnum.LisPack.getKey());
         List<MappingConfigWrapper> pacsConfigList = mappingConfigFacade.getListByHospitalIdAndType(hospitalId, ConceptTypeEnum.Pacs.getKey());

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

@@ -2,7 +2,7 @@
 package com.diagbot.facade;
 
 import com.diagbot.dto.MedClassMedDTO;
-import com.diagbot.dto.RuleDTO;
+import com.diagbot.dto.RuleGetDTO;
 import com.diagbot.enums.LexiconEnum;
 import com.diagbot.util.BeanUtil;
 import com.diagbot.util.EntityUtil;
@@ -57,7 +57,7 @@ public class UnUsedMappingFacade {
      * @param list
      * @return
      */
-    public Map<String, List<String>> usedNames(List<RuleDTO> list) {
+    public Map<String, List<String>> usedNames(List<RuleGetDTO> list) {
         Map<String, List<String>> retMap = new HashMap<>();
 
         if (ListUtil.isEmpty(list)) {
@@ -65,31 +65,31 @@ public class UnUsedMappingFacade {
         }
         List<String> lisNames = list.stream()
                 .filter(i -> i.getRuleLibType().equals(LexiconEnum.LisName.getKey()) || i.getRuleLibType().equals(LexiconEnum.LisSubName.getKey()))
-                .map(RuleDTO::getRuleLibName)
+                .map(RuleGetDTO::getRuleLibName)
                 .collect(Collectors.toList());
         lisNames.addAll(list.stream()
                 .filter(i -> i.getHasSubCond() != null && i.getHasSubCond().equals(1) && (i.getRuleBaseLibType().equals(LexiconEnum.LisName.getKey()) || i.getRuleBaseLibType().equals(LexiconEnum.LisSubName.getKey())))
-                .map(RuleDTO::getRuleBaseLibName)
+                .map(RuleGetDTO::getRuleBaseLibName)
                 .collect(Collectors.toList()));
         lisNames = lisNames.stream().distinct().collect(Collectors.toList());
 
         List<String> pacsNames = list.stream()
                 .filter(i -> i.getRuleLibType().equals(LexiconEnum.PacsName.getKey()) || i.getRuleLibType().equals(LexiconEnum.PacsSubName.getKey()))
-                .map(RuleDTO::getRuleLibName)
+                .map(RuleGetDTO::getRuleLibName)
                 .collect(Collectors.toList());
         pacsNames.addAll(list.stream()
                 .filter(i -> i.getHasSubCond() != null && i.getHasSubCond().equals(1) && (i.getRuleBaseLibType().equals(LexiconEnum.PacsName.getKey()) || i.getRuleBaseLibType().equals(LexiconEnum.PacsSubName.getKey())))
-                .map(RuleDTO::getRuleBaseLibName)
+                .map(RuleGetDTO::getRuleBaseLibName)
                 .collect(Collectors.toList()));
         pacsNames = pacsNames.stream().distinct().collect(Collectors.toList());
 
         List<String> diseaseNames = list.stream()
                 .filter(i -> i.getRuleLibType().equals(LexiconEnum.Disease.getKey()))
-                .map(RuleDTO::getRuleLibName)
+                .map(RuleGetDTO::getRuleLibName)
                 .collect(Collectors.toList());
         diseaseNames.addAll(list.stream()
                 .filter(i -> i.getHasSubCond() != null && i.getHasSubCond().equals(1) && (i.getRuleBaseLibType().equals(LexiconEnum.Disease.getKey())))
-                .map(RuleDTO::getRuleBaseLibName)
+                .map(RuleGetDTO::getRuleBaseLibName)
                 .collect(Collectors.toList()));
         diseaseNames = diseaseNames.stream().distinct().collect(Collectors.toList());
 
@@ -99,8 +99,8 @@ public class UnUsedMappingFacade {
                 medClassMedList.stream().collect(Collectors.groupingBy(MedClassMedDTO::getMedClassLibName,
                         HashMap::new,
                         Collectors.mapping(MedClassMedDTO::getMedLibName, Collectors.toList())));
-        List<RuleDTO> medList = Lists.newLinkedList();
-        for (RuleDTO result : list) {
+        List<RuleGetDTO> medList = Lists.newLinkedList();
+        for (RuleGetDTO result : list) {
             if (result.getHasSubCond() != null && result.getHasSubCond().equals(1)) {
                 if (result.getRuleBaseLibType().equals(LexiconEnum.MedChemClass.getKey())
                         || result.getRuleBaseLibType().equals(LexiconEnum.MedZhiLiaoClass.getKey())
@@ -108,7 +108,7 @@ public class UnUsedMappingFacade {
                     List<String> medicines = medClassMedMap.get(result.getRuleBaseLibName());
                     if (ListUtil.isNotEmpty(medicines)) {
                         for (String med : medicines) {
-                            RuleDTO medResult = new RuleDTO();
+                            RuleGetDTO medResult = new RuleGetDTO();
                             BeanUtil.copyProperties(result, medResult);
                             medResult.setRuleBaseLibName(med);
                             medResult.setRuleBaseLibType(LexiconEnum.Medicine.getKey());
@@ -128,31 +128,31 @@ public class UnUsedMappingFacade {
 
         List<String> drugNames = medList.stream()
                 .filter(i -> i.getRuleLibType().equals(LexiconEnum.Medicine.getKey()))
-                .map(RuleDTO::getRuleLibName)
+                .map(RuleGetDTO::getRuleLibName)
                 .collect(Collectors.toList());
         drugNames.addAll(medList.stream()
                 .filter(i -> i.getHasSubCond() != null && i.getHasSubCond().equals(1) && (i.getRuleBaseLibType().equals(LexiconEnum.Medicine.getKey())))
-                .map(RuleDTO::getRuleBaseLibName)
+                .map(RuleGetDTO::getRuleBaseLibName)
                 .collect(Collectors.toList()));
         drugNames = drugNames.stream().distinct().collect(Collectors.toList());
 
         List<String> operationNames = list.stream()
                 .filter(i -> i.getRuleLibType().equals(LexiconEnum.Operation.getKey()))
-                .map(RuleDTO::getRuleLibName)
+                .map(RuleGetDTO::getRuleLibName)
                 .collect(Collectors.toList());
         operationNames.addAll(list.stream()
                 .filter(i -> i.getHasSubCond() != null && i.getHasSubCond().equals(1) && (i.getRuleBaseLibType().equals(LexiconEnum.Operation.getKey())))
-                .map(RuleDTO::getRuleBaseLibName)
+                .map(RuleGetDTO::getRuleBaseLibName)
                 .collect(Collectors.toList()));
         operationNames = operationNames.stream().distinct().collect(Collectors.toList());
 
         List<String> transfusionNames = list.stream()
                 .filter(i -> i.getRuleLibType().equals(LexiconEnum.Transfusion.getKey()))
-                .map(RuleDTO::getRuleLibName)
+                .map(RuleGetDTO::getRuleLibName)
                 .collect(Collectors.toList());
         transfusionNames.addAll(list.stream()
                 .filter(i -> i.getHasSubCond() != null && i.getHasSubCond().equals(1) && (i.getRuleBaseLibType().equals(LexiconEnum.Transfusion.getKey())))
-                .map(RuleDTO::getRuleBaseLibName)
+                .map(RuleGetDTO::getRuleBaseLibName)
                 .collect(Collectors.toList()));
         transfusionNames = transfusionNames.stream().distinct().collect(Collectors.toList());
 
@@ -171,7 +171,7 @@ public class UnUsedMappingFacade {
      * @param list
      * @return
      */
-    public Map<String, List<Long>> usedConceptIds(List<RuleDTO> list) {
+    public Map<String, List<Long>> usedConceptIds(List<RuleGetDTO> list) {
         Map<String, List<Long>> retMap = new HashMap<>();
 
         if (ListUtil.isEmpty(list)) {
@@ -179,31 +179,31 @@ public class UnUsedMappingFacade {
         }
         List<Long> lisIds = list.stream()
                 .filter(i -> i.getRuleLibType().equals(LexiconEnum.LisName.getKey()) || i.getRuleLibType().equals(LexiconEnum.LisSubName.getKey()))
-                .map(RuleDTO::getRuleConceptId)
+                .map(RuleGetDTO::getRuleConceptId)
                 .collect(Collectors.toList());
         lisIds.addAll(list.stream()
                 .filter(i -> i.getHasSubCond() != null && i.getHasSubCond().equals(1) && (i.getRuleBaseLibType().equals(LexiconEnum.LisName.getKey()) || i.getRuleBaseLibType().equals(LexiconEnum.LisSubName.getKey())))
-                .map(RuleDTO::getRuleBaseConceptId)
+                .map(RuleGetDTO::getRuleBaseConceptId)
                 .collect(Collectors.toList()));
         lisIds = lisIds.stream().distinct().collect(Collectors.toList());
 
         List<Long> pacsIds = list.stream()
                 .filter(i -> i.getRuleLibType().equals(LexiconEnum.PacsName.getKey()) || i.getRuleLibType().equals(LexiconEnum.PacsSubName.getKey()))
-                .map(RuleDTO::getRuleConceptId)
+                .map(RuleGetDTO::getRuleConceptId)
                 .collect(Collectors.toList());
         pacsIds.addAll(list.stream()
                 .filter(i -> i.getHasSubCond() != null && i.getHasSubCond().equals(1) && (i.getRuleBaseLibType().equals(LexiconEnum.PacsName.getKey()) || i.getRuleBaseLibType().equals(LexiconEnum.PacsSubName.getKey())))
-                .map(RuleDTO::getRuleBaseConceptId)
+                .map(RuleGetDTO::getRuleBaseConceptId)
                 .collect(Collectors.toList()));
         pacsIds = pacsIds.stream().distinct().collect(Collectors.toList());
 
         List<Long> diseaseIds = list.stream()
                 .filter(i -> i.getRuleLibType().equals(LexiconEnum.Disease.getKey()))
-                .map(RuleDTO::getRuleConceptId)
+                .map(RuleGetDTO::getRuleConceptId)
                 .collect(Collectors.toList());
         diseaseIds.addAll(list.stream()
                 .filter(i -> i.getHasSubCond() != null && i.getHasSubCond().equals(1) && (i.getRuleBaseLibType().equals(LexiconEnum.Disease.getKey())))
-                .map(RuleDTO::getRuleBaseConceptId)
+                .map(RuleGetDTO::getRuleBaseConceptId)
                 .collect(Collectors.toList()));
         diseaseIds = diseaseIds.stream().distinct().collect(Collectors.toList());
 
@@ -213,8 +213,8 @@ public class UnUsedMappingFacade {
                 medClassMedList.stream().collect(Collectors.groupingBy(MedClassMedDTO::getMedClassLibName,
                         HashMap::new,
                         Collectors.mapping(MedClassMedDTO::getMedLibName, Collectors.toList())));
-        List<RuleDTO> medList = Lists.newLinkedList();
-        for (RuleDTO result : list) {
+        List<RuleGetDTO> medList = Lists.newLinkedList();
+        for (RuleGetDTO result : list) {
             if (result.getHasSubCond() != null && result.getHasSubCond().equals(1)) {
                 if (result.getRuleBaseLibType().equals(LexiconEnum.MedChemClass.getKey())
                         || result.getRuleBaseLibType().equals(LexiconEnum.MedZhiLiaoClass.getKey())
@@ -222,7 +222,7 @@ public class UnUsedMappingFacade {
                     List<String> medicines = medClassMedMap.get(result.getRuleBaseLibName());
                     if (ListUtil.isNotEmpty(medicines)) {
                         for (String med : medicines) {
-                            RuleDTO medResult = new RuleDTO();
+                            RuleGetDTO medResult = new RuleGetDTO();
                             BeanUtil.copyProperties(result, medResult);
                             medResult.setRuleBaseLibName(med);
                             medResult.setRuleBaseLibType(LexiconEnum.Medicine.getKey());
@@ -242,31 +242,31 @@ public class UnUsedMappingFacade {
 
         List<Long> drugIds = medList.stream()
                 .filter(i -> i.getRuleLibType().equals(LexiconEnum.Medicine.getKey()))
-                .map(RuleDTO::getRuleConceptId)
+                .map(RuleGetDTO::getRuleConceptId)
                 .collect(Collectors.toList());
         drugIds.addAll(medList.stream()
                 .filter(i -> i.getHasSubCond() != null && i.getHasSubCond().equals(1) && (i.getRuleBaseLibType().equals(LexiconEnum.Medicine.getKey())))
-                .map(RuleDTO::getRuleBaseConceptId)
+                .map(RuleGetDTO::getRuleBaseConceptId)
                 .collect(Collectors.toList()));
         drugIds = drugIds.stream().distinct().collect(Collectors.toList());
 
         List<Long> operationIds = list.stream()
                 .filter(i -> i.getRuleLibType().equals(LexiconEnum.Operation.getKey()))
-                .map(RuleDTO::getRuleConceptId)
+                .map(RuleGetDTO::getRuleConceptId)
                 .collect(Collectors.toList());
         operationIds.addAll(list.stream()
                 .filter(i -> i.getHasSubCond() != null && i.getHasSubCond().equals(1) && (i.getRuleBaseLibType().equals(LexiconEnum.Operation.getKey())))
-                .map(RuleDTO::getRuleBaseConceptId)
+                .map(RuleGetDTO::getRuleBaseConceptId)
                 .collect(Collectors.toList()));
         operationIds = operationIds.stream().distinct().collect(Collectors.toList());
 
         List<Long> transfusionIds = list.stream()
                 .filter(i -> i.getRuleLibType().equals(LexiconEnum.Transfusion.getKey()))
-                .map(RuleDTO::getRuleConceptId)
+                .map(RuleGetDTO::getRuleConceptId)
                 .collect(Collectors.toList());
         transfusionIds.addAll(list.stream()
                 .filter(i -> i.getHasSubCond() != null && i.getHasSubCond().equals(1) && (i.getRuleBaseLibType().equals(LexiconEnum.Transfusion.getKey())))
-                .map(RuleDTO::getRuleBaseConceptId)
+                .map(RuleGetDTO::getRuleBaseConceptId)
                 .collect(Collectors.toList()));
         transfusionIds = transfusionIds.stream().distinct().collect(Collectors.toList());
 

cdssman-service/src/main/java/com/diagbot/mapper/KlRuleMapper.java

@@ -1,6 +1,6 @@
 package com.diagbot.mapper;
 
-import com.diagbot.dto.RuleDTO;
+import com.diagbot.dto.RuleGetDTO;
 import com.diagbot.entity.KlRule;
 import com.baomidou.mybatisplus.core.mapper.BaseMapper;
 import com.diagbot.vo.RuleVO;
@@ -16,5 +16,5 @@ import java.util.List;
  * @since 2021-03-01
  */
 public interface KlRuleMapper extends BaseMapper<KlRule> {
-    List<RuleDTO> getRules(RuleVO ruleVO);
+    List<RuleGetDTO> getRules(RuleVO ruleVO);
 }

cdssman-service/src/main/java/com/diagbot/service/KlRuleService.java

@@ -1,7 +1,7 @@
 package com.diagbot.service;
 
 import com.baomidou.mybatisplus.extension.service.IService;
-import com.diagbot.dto.RuleDTO;
+import com.diagbot.dto.RuleGetDTO;
 import com.diagbot.entity.KlRule;
 import com.diagbot.vo.RuleVO;
 
@@ -16,5 +16,5 @@ import java.util.List;
  * @since 2021-03-01
  */
 public interface KlRuleService extends IService<KlRule> {
-    List<RuleDTO> getRules(RuleVO ruleVO);
+    List<RuleGetDTO> getRules(RuleVO ruleVO);
 }

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

@@ -2,7 +2,7 @@ package com.diagbot.service.impl;
 
 import com.baomidou.dynamic.datasource.annotation.DS;
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
-import com.diagbot.dto.RuleDTO;
+import com.diagbot.dto.RuleGetDTO;
 import com.diagbot.entity.KlRule;
 import com.diagbot.mapper.KlRuleMapper;
 import com.diagbot.service.KlRuleService;
@@ -22,7 +22,7 @@ import java.util.List;
 @Service
 @DS("med")
 public class KlRuleServiceImpl extends ServiceImpl<KlRuleMapper, KlRule> implements KlRuleService {
-    public List<RuleDTO> getRules(RuleVO ruleVO) {
+    public List<RuleGetDTO> getRules(RuleVO ruleVO) {
         return baseMapper.getRules(ruleVO);
     }
 }

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

@@ -0,0 +1,29 @@
+package com.diagbot.vo;
+
+import lombok.Getter;
+import lombok.Setter;
+
+import javax.validation.constraints.NotBlank;
+import javax.validation.constraints.NotNull;
+
+/**
+ * @Description:
+ * @author: gaodm
+ * @time: 2021/12/30 13:21
+ */
+@Getter
+@Setter
+public class RuleQueryKeyVO {
+    @NotBlank(message = "医学标准术语不可为空")
+    private String libName;
+    @NotNull(message = "术语类型不可为空")
+    private Integer libType;
+    @NotNull(message = "规则类型不可为空")
+    private Integer ruleType;
+    //规则名称
+    private String description;
+    //基础规则术语类型
+    private String baseLibName;
+    //基础医学标准术语
+    private Integer baseLibType;
+}

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

@@ -0,0 +1,27 @@
+package com.diagbot.vo;
+
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import lombok.Getter;
+import lombok.Setter;
+
+/**
+ * @Description:
+ * @author: gaodm
+ * @time: 2021/12/30 13:21
+ */
+@Getter
+@Setter
+public class RuleQueryVO extends Page {
+    //医学标准术语
+    private String libName;
+    //术语类型
+    private Integer libType;
+    //规则类型
+    private Integer ruleType;
+    //规则名称
+    private String description;
+    //基础规则术语类型
+    private String baseLibName;
+    //基础医学标准术语
+    private Integer baseLibType;
+}

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

@@ -1,19 +1,21 @@
 package com.diagbot.web;
 
 
-import com.baomidou.mybatisplus.core.metadata.IPage;
 import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
 import com.diagbot.annotation.SysLogger;
 import com.diagbot.dto.KlRuleByIdParDTO;
 import com.diagbot.dto.KlRuleInfoDTO;
 import com.diagbot.dto.RespDTO;
-import com.diagbot.enums.StatusEnum;
+import com.diagbot.dto.RuleDTO;
+import com.diagbot.dto.RuleQueryDTO;
 import com.diagbot.facade.KlRuleFacade;
 import com.diagbot.vo.KlRuleByIdVO;
 import com.diagbot.vo.KlRuleInfoClearVO;
 import com.diagbot.vo.KlRuleInfoSaveVO;
 import com.diagbot.vo.KlRuleInfoVO;
 import com.diagbot.vo.KlRuleSatartOrdisaVO;
+import com.diagbot.vo.RuleQueryKeyVO;
+import com.diagbot.vo.RuleQueryVO;
 import io.swagger.annotations.Api;
 import io.swagger.annotations.ApiOperation;
 import org.springframework.beans.factory.annotation.Autowired;
@@ -86,4 +88,17 @@ public class KlRuleController {
         return RespDTO.onSuc(klRuleFacade.startRuleInfos(klRuleSatartOrdisaVO));
     }
 
+    @ApiOperation(value = "查询所有有效的规则[by:gaodm]")
+    @PostMapping("/getRulePage")
+    @SysLogger("getRulePage")
+    public RespDTO<Page<RuleQueryDTO>> getRulePage(@RequestBody RuleQueryVO ruleQueryVO) {
+        return RespDTO.onSuc(klRuleFacade.getRulePage(ruleQueryVO));
+    }
+
+    @ApiOperation(value = "根据录入内容查询有效规则的明细[by:gaodm]")
+    @PostMapping("/getRuleDetail")
+    @SysLogger("getRuleDetail")
+    public RespDTO<RuleDTO> getRuleDetail(@RequestBody @Valid RuleQueryKeyVO ruleQueryKeyVO) {
+        return RespDTO.onSuc(klRuleFacade.getRuleDetail(ruleQueryKeyVO));
+    }
 }

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

@@ -18,7 +18,7 @@
         <result column="msg" property="msg" />
     </resultMap>
 
-    <select id="getRules" resultType="com.diagbot.dto.RuleDTO">
+    <select id="getRules" resultType="com.diagbot.dto.RuleGetDTO">
         SELECT
         t1.rule_type AS ruleType,
         t1.lib_type AS ruleLibType,