Merge remote-tracking branch 'origin/master'

src/main/java/com/diagbot/config/ResourceServerConfigurer.java

@@ -117,6 +117,11 @@ public class ResourceServerConfigurer extends ResourceServerConfigurerAdapter {
                 .antMatchers("/sys/plan/revStopPlans").permitAll()
                 .antMatchers("/sys/tokenHospital/getTokenHospital").permitAll()
                 .antMatchers("/demo/retrieval/index").permitAll()
+                .antMatchers("/graph/conceptInfo/staticKnowledgeIndex").permitAll()
+                .antMatchers("/graph/conceptInfo/staticKnowledgeIndexWithoutInfo").permitAll()
+                .antMatchers("/graph/conceptInfo/getStaticKnowledge").permitAll()
+                .antMatchers("/graph/conceptInfo/getStaticKnowledgeForHIS").permitAll()
+                .antMatchers("/graph/conceptInfo/getPage").permitAll()
                 .antMatchers("/sys/planDetail/getPlanDetailDatas").permitAll()
                 .antMatchers("/sys/planDetail/savePlanDetails").permitAll()
                 .antMatchers("/sys/planDetail/cancelPlanDetails").permitAll()

src/main/java/com/diagbot/config/security/UrlAccessDecisionManager.java

@@ -159,6 +159,11 @@ public class UrlAccessDecisionManager implements AccessDecisionManager {
                 || matchers("/sys/plan/revStopPlans", request)
                 || matchers("/sys/tokenHospital/getTokenHospital", request)
                 || matchers("/demo/retrieval/index", request)
+                || matchers("/graph/conceptInfo/staticKnowledgeIndex", request)
+                || matchers("/graph/conceptInfo/staticKnowledgeIndexWithoutInfo", request)
+                || matchers("/graph/conceptInfo/getStaticKnowledge", request)
+                || matchers("/graph/conceptInfo/getStaticKnowledgeForHIS", request)
+                || matchers("/graph/conceptInfo/getPage", request)
                 || matchers("/sys/planDetail/getPlanDetailDatas", request)
                 || matchers("/sys/planDetail/savePlanDetails", request)
                 || matchers("/sys/planDetail/cancelPlanDetails", request)

src/main/java/com/diagbot/dto/BillMsg.java

@@ -16,8 +16,8 @@ public class BillMsg {
     private String orderName;
     // 开单标准名称
     private String orderStandName;
-    // 匹配名称
-    private String compareName;
-    // 匹配标准名称
-    private String compareStandName;
+    // 匹配的内容
+    private String content;
+    // 类型
+    private String type;
 }

src/main/java/com/diagbot/dto/ConceptDetailDTO.java

@@ -0,0 +1,43 @@
+package com.diagbot.dto;
+
+import lombok.Getter;
+import lombok.Setter;
+
+/**
+ * @Description:
+ * @Author:zhaops
+ * @time: 2020/8/21 10:28
+ */
+@Getter
+@Setter
+public class ConceptDetailDTO {
+    /**
+     * 提示概念id
+     */
+    private Long conceptId;
+
+    /**
+     * 提示明细标题
+     */
+    private String title;
+
+    /**
+     * 提示明细内容
+     */
+    private String content;
+
+    /**
+     * 纯文本
+     */
+    private String text;
+
+    /**
+     * 提示明细序号
+     */
+    private Integer orderNo;
+
+    /**
+     * 内容类型（多选）：1-化验、辅检、手术和操作、诊断、药品静态信息，2-注意事项，3-临床路径
+     */
+    private String contentType;
+}

src/main/java/com/diagbot/dto/ConceptInfoDTO.java

@@ -0,0 +1,52 @@
+package com.diagbot.dto;
+
+import lombok.Getter;
+import lombok.Setter;
+
+import java.util.Date;
+
+/**
+ * @Description:
+ * @Author:zhaops
+ * @time: 2020/8/21 10:33
+ */
+@Getter
+@Setter
+public class ConceptInfoDTO {
+    /**
+     * 术语id
+     */
+    private Long id;
+    /**
+     * 术语名称
+     */
+    private String name;
+    /**
+     * 术语类型（词性）
+     */
+    private String type;
+    /**
+     * 术语类型（词性）
+     */
+    private String typeName;
+    /**
+     * 临床路径名称
+     */
+    private String clinicalPathwayName;
+    /**
+     * 注意事项名称
+     */
+    private String noticeName;
+    /**
+     * 修改时间
+     */
+    private Date gmtModified;
+    /**
+     * 修改人
+     */
+    private String modifier;
+    /**
+     * 启用状态
+     */
+    private String isDeleted;
+}

src/main/java/com/diagbot/dto/IndicationDTO.java

@@ -3,7 +3,9 @@ package com.diagbot.dto;
 import lombok.Data;
 
 import java.util.ArrayList;
+import java.util.LinkedHashMap;
 import java.util.List;
+import java.util.Map;
 
 /**
  * @description: 提示信息出参
@@ -19,5 +21,5 @@ public class IndicationDTO {
     // 高危药品、手术
     private List<BillMsg> highRiskList = new ArrayList<>();
     // 记录调试信息
-    private List<String> dubugStr = new ArrayList<>();
+    private Map<String, Object> debug = new LinkedHashMap<>();
 }

src/main/java/com/diagbot/dto/StaticKnowledgeDTO.java

@@ -0,0 +1,45 @@
+package com.diagbot.dto;
+
+import lombok.Getter;
+import lombok.Setter;
+
+import java.util.List;
+import java.util.Map;
+
+/**
+ * @Description:
+ * @Author:zhaops
+ * @time: 2020/8/20 15:51
+ */
+@Getter
+@Setter
+public class StaticKnowledgeDTO {
+    /**
+     * 标准术语id
+     */
+    private Long id;
+    /**
+     * 标准术语
+     */
+    private String name;
+
+    /**
+     * 词性
+     */
+    private String type;
+
+    /**
+     * 临床路径名称
+     */
+    private String clinicalPathwayName;
+
+    /**
+     * 注意事项名称
+     */
+    private String noticeName;
+
+    /**
+     * 静态知识明细
+     */
+    private Map<String, List<StaticKnowledgeDetailDTO>> details;
+}

src/main/java/com/diagbot/dto/StaticKnowledgeDetailDTO.java

@@ -0,0 +1,43 @@
+package com.diagbot.dto;
+
+import lombok.Getter;
+import lombok.Setter;
+
+/**
+ * @Description:
+ * @Author:zhaops
+ * @time: 2020/8/20 15:52
+ */
+@Getter
+@Setter
+public class StaticKnowledgeDetailDTO {
+    /**
+     * 提示概念id
+     */
+    private Long conceptId;
+
+    /**
+     * 提示明细标题
+     */
+    private String title;
+
+    /**
+     * 提示明细内容
+     */
+    private String content;
+
+    /**
+     * 纯文本
+     */
+    private String text;
+
+    /**
+     * 提示明细序号
+     */
+    private Integer orderNo;
+
+    /**
+     * 内容类型（多选）：1-化验、辅检、手术和操作、诊断、药品静态信息，2-注意事项，3-临床路径
+     */
+    private String contentType;
+}

src/main/java/com/diagbot/entity/ConceptDetail.java

@@ -79,7 +79,7 @@ public class ConceptDetail implements Serializable {
     /**
      * 内容类型（多选）：1-化验、辅检、手术和操作、诊断、药品静态信息，2-注意事项，3-临床路径
      */
-    private String concentType;
+    private String contentType;
 
     public Long getId() {
         return id;
@@ -158,12 +158,12 @@ public class ConceptDetail implements Serializable {
     public void setOrderNo(Integer orderNo) {
         this.orderNo = orderNo;
     }
-    public String getConcentType() {
-        return concentType;
+    public String getContentType() {
+        return contentType;
     }
 
-    public void setConcentType(String concentType) {
-        this.concentType = concentType;
+    public void setContentType(String contentType) {
+        this.contentType = contentType;
     }
 
     @Override
@@ -180,7 +180,7 @@ public class ConceptDetail implements Serializable {
             ", content=" + content +
             ", text=" + text +
             ", orderNo=" + orderNo +
-            ", concentType=" + concentType +
+            ", contentType=" + contentType +
         "}";
     }
 }

src/main/java/com/diagbot/enums/ConceptTypeEnum.java

@@ -12,9 +12,10 @@ public enum ConceptTypeEnum implements KeyedNamed {
     All(0, "全部"),
     Disease(1, "诊断"),
     Drug(2, "药品"),
-    Lis(3, "检验"),
-    Pacs(4, "检查"),
-    Opeartion(5, "手术和操作");
+    Lis(3, "检验套餐"),
+    LisPack(4, "检验明细"),
+    Pacs(5, "检查"),
+    Opeartion(6, "手术和操作");
 
     @Setter
     private int key;

src/main/java/com/diagbot/facade/AssembleFacade.java

@@ -33,7 +33,7 @@ public class AssembleFacade {
         HospitalInfo hospitalInfo = hospitalInfoFacade.getById(searchData.getHospitalId());
         Integer isConnect = 0;
         if (hospitalInfo != null && hospitalInfo.getIsDeleted().equals(IsDeleteEnum.N.getKey())) {
-            isConnect = 1;
+            isConnect = hospitalInfo.getConnect();
         }
         if (isConnect.equals(1)) {
             try {
@@ -58,7 +58,7 @@ public class AssembleFacade {
         HospitalInfo hospitalInfo = hospitalInfoFacade.getById(hospitalId);
         Integer isConnect = 0;
         if (hospitalInfo != null && hospitalInfo.getIsDeleted().equals(IsDeleteEnum.N.getKey())) {
-            isConnect = 1;
+            isConnect = hospitalInfo.getConnect();
         }
         if (isConnect.equals(1)) {
             try {

src/main/java/com/diagbot/facade/ConceptInfoFacade.java

@@ -1,8 +1,42 @@
 package com.diagbot.facade;
 
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.baomidou.mybatisplus.core.metadata.IPage;
+import com.diagbot.client.CdssCoreClient;
+import com.diagbot.dto.ConceptInfoDTO;
+import com.diagbot.dto.DictionaryInfoDTO;
+import com.diagbot.dto.RespDTO;
+import com.diagbot.dto.StaticKnowledgeDTO;
+import com.diagbot.dto.StaticKnowledgeDetailDTO;
+import com.diagbot.dto.StaticKnowledgeIndexDTO;
+import com.diagbot.entity.ConceptDetail;
+import com.diagbot.entity.ConceptInfo;
+import com.diagbot.enums.ConceptTypeEnum;
+import com.diagbot.enums.IsDeleteEnum;
+import com.diagbot.exception.CommonErrorCode;
+import com.diagbot.exception.CommonException;
 import com.diagbot.service.impl.ConceptInfoServiceImpl;
+import com.diagbot.util.BeanUtil;
+import com.diagbot.util.EntityUtil;
+import com.diagbot.util.ListUtil;
+import com.diagbot.util.RespDTOUtil;
+import com.diagbot.util.StringUtil;
+import com.diagbot.util.SysUserUtils;
+import com.diagbot.vo.ConceptInfoPageVO;
+import com.diagbot.vo.StaticKnowledgeHISVO;
+import com.diagbot.vo.StaticKnowledgeIndexVO;
+import com.diagbot.vo.StaticKnowledgeVO;
+import com.google.common.collect.Lists;
+import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;
 
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
 /**
  * @Description:
  * @Author:zhaops
@@ -10,4 +44,414 @@ import org.springframework.stereotype.Component;
  */
 @Component
 public class ConceptInfoFacade extends ConceptInfoServiceImpl {
-}
+    @Autowired
+    private CdssCoreClient cdssCoreClient;
+    @Autowired
+    private DictionaryFacade dictionaryFacade;
+    @Autowired
+    private ConceptDetailFacade conceptDetailFacade;
+    @Autowired
+    private LisConfigFacade lisConfigFacade;
+    @Autowired
+    private PacsConfigFacade pacsConfigFacade;
+    @Autowired
+    private DrugConfigFacade drugConfigFacade;
+    @Autowired
+    private DiseaseConfigFacade diseaseConfigFacade;
+    @Autowired
+    private OperationConfigFacade operationConfigFacade;
+
+    /**
+     * 返回带静态知识的检索结果
+     *
+     * @param staticKnowledgeIndexVO
+     * @return
+     */
+    public List<StaticKnowledgeIndexDTO> staticKnowledgeIndexWithInfo(StaticKnowledgeIndexVO staticKnowledgeIndexVO) {
+        List<StaticKnowledgeIndexDTO> staticKnowledgeIndexDTOList = staticKnowledgeIndex(staticKnowledgeIndexVO);
+        //过滤没有静态知识的检索结果
+        staticKnowledgeIndexDTOList = staticKnowledgeIndexDTOList
+                .stream()
+                .filter(i -> i.getHasInfomation().equals(1)
+                        || i.getHasNotice().equals(1)
+                        || i.getHasClinicalPathway().equals(1))
+                .collect(Collectors.toList());
+        return staticKnowledgeIndexDTOList;
+    }
+
+    /**
+     * 返回不带静态知识的检索结果
+     *
+     * @param staticKnowledgeIndexVO
+     * @return
+     */
+    public List<StaticKnowledgeIndexDTO> staticKnowledgeIndexWithoutInfo(StaticKnowledgeIndexVO staticKnowledgeIndexVO) {
+        List<StaticKnowledgeIndexDTO> staticKnowledgeIndexDTOList = staticKnowledgeIndex(staticKnowledgeIndexVO);
+        //过滤没有静态知识的检索结果
+        staticKnowledgeIndexDTOList = staticKnowledgeIndexDTOList
+                .stream()
+                .filter(i -> i.getHasInfomation().equals(0)
+                        && i.getHasNotice().equals(0)
+                        && i.getHasClinicalPathway().equals(0))
+                .collect(Collectors.toList());
+        return staticKnowledgeIndexDTOList;
+    }
+
+    /**
+     * 医学知识（静态信息）检索
+     *
+     * @param staticKnowledgeIndexVO
+     * @return
+     */
+    public List<StaticKnowledgeIndexDTO> staticKnowledgeIndex(StaticKnowledgeIndexVO staticKnowledgeIndexVO) {
+        List<StaticKnowledgeIndexDTO> retList = Lists.newLinkedList();
+        //静态知识检索顺序
+        List<DictionaryInfoDTO> dicStaticIndexList = dictionaryFacade.getListByGroupType(7);
+        //页面术语类型和图谱映射
+        List<DictionaryInfoDTO> dicTypeMappingList = dictionaryFacade.getListByGroupType(8);
+
+        List<StaticKnowledgeIndexDTO> staticKnowledgeIndexDTOList = Lists.newLinkedList();
+        RespDTO<List<StaticKnowledgeIndexDTO>> respDTO = cdssCoreClient.staticKnowledgeIndex(staticKnowledgeIndexVO);
+        RespDTOUtil.respNGDealCover(respDTO, "检索失败");
+        staticKnowledgeIndexDTOList = respDTO.data;
+        if (ListUtil.isNotEmpty(staticKnowledgeIndexDTOList)) {
+            //typeName转换
+            staticKnowledgeIndexDTOList.forEach(item -> {
+                item.setTypeName(convertTypeName(item.getTypeName(), 2, dicTypeMappingList));
+            });
+            //是否有静态知识
+            List<String> conNameList = staticKnowledgeIndexDTOList
+                    .stream()
+                    .map(i -> i.getName())
+                    .collect(Collectors.toList());
+            QueryWrapper<ConceptInfo> conceptInfoQueryWrapper = new QueryWrapper<>();
+            conceptInfoQueryWrapper.eq("is_deleted", IsDeleteEnum.N.getKey())
+                    .in("name", conNameList);
+            List<ConceptInfo> conceptInfoList = this.list(conceptInfoQueryWrapper);
+            if(ListUtil.isNotEmpty(conceptInfoList)) {
+                //typeName转换
+                conceptInfoList.forEach(item -> {
+                    item.setType(convertTypeName(item.getType(), 2, dicTypeMappingList));
+                });
+                Map<String, ConceptInfo> infoMap
+                        = EntityUtil.makeEntityMapByKeys(conceptInfoList, "_", "name", "type");
+                for (StaticKnowledgeIndexDTO item : staticKnowledgeIndexDTOList) {
+                    if (infoMap.containsKey(item.getName() + "_" + item.getTypeName())) {
+                        item.setId(infoMap.get(item.getName() + "_" + item.getTypeName()).getId());
+                    }
+                }
+                List<Long> conceptIdList = conceptInfoList.stream()
+                        .map(i -> i.getId())
+                        .collect(Collectors.toList());
+                if (ListUtil.isNotEmpty(conceptIdList)) {
+                    QueryWrapper<ConceptDetail> conceptDetailQueryWrapper = new QueryWrapper<>();
+                    conceptDetailQueryWrapper.eq("is_deleted", IsDeleteEnum.N.getKey())
+                            .in("concept_id", conceptIdList);
+                    List<ConceptDetail> conceptDetailList = conceptDetailFacade.list(conceptDetailQueryWrapper);
+                    Map<Long, List<ConceptDetail>> detailMap
+                            = EntityUtil.makeEntityListMap(conceptDetailList, "conceptId");
+                    for (StaticKnowledgeIndexDTO item : staticKnowledgeIndexDTOList) {
+                        if (item.getId() == null
+                                || !detailMap.containsKey(item.getId())) {
+                            item.setHasInfomation(0);
+                            item.setHasClinicalPathway(0);
+                            item.setHasNotice((0));
+                            continue;
+                        }
+                        for (ConceptDetail detail : detailMap.get(item.getId())) {
+                            List<String> contentTypeList = Arrays.asList(detail.getContentType().split(","));
+                            if (contentTypeList.contains("1")) {
+                                item.setHasInfomation(1);
+                            }
+                            if (contentTypeList.contains("2")) {
+                                item.setHasNotice(1);
+                            }
+                            if (contentTypeList.contains("3")) {
+                                item.setHasClinicalPathway(1);
+                            }
+                        }
+                    }
+                }
+            }
+
+            //排序
+            Map<String, List<StaticKnowledgeIndexDTO>> map
+                    = EntityUtil.makeEntityListMap(staticKnowledgeIndexDTOList, "typeName");
+            for (DictionaryInfoDTO dic : dicStaticIndexList) {
+                if (dic.getName().equals("检验")) {
+                    if (map.containsKey("检验套餐")) {
+                        retList.addAll(map.get("检验套餐"));
+                    }
+                    if (map.containsKey("检验明细")) {
+                        retList.addAll(map.get("检验明细"));
+                    }
+                } else if (map.containsKey(dic.getName())) {
+                    retList.addAll(map.get(dic.getName()));
+                }
+            }
+        }
+        return retList;
+    }
+
+
+    /**
+     * 页面获取静态知识
+     *
+     * @param staticKnowledgeVO
+     * @return
+     */
+    public StaticKnowledgeDTO getStaticKnowledge(StaticKnowledgeVO staticKnowledgeVO) {
+        StaticKnowledgeDTO staticKnowledgeDTO = new StaticKnowledgeDTO();
+        String typeName = ConceptTypeEnum.getName(staticKnowledgeVO.getType());
+        List<DictionaryInfoDTO> dicList = dictionaryFacade.getListByGroupType(8);
+        typeName = convertTypeName(typeName, 1, dicList);
+
+        QueryWrapper<ConceptInfo> conceptInfoQueryWrapper = new QueryWrapper<>();
+        conceptInfoQueryWrapper.eq("is_deleted", IsDeleteEnum.N.getKey())
+                .eq("name", staticKnowledgeVO.getName())
+                .eq("type", typeName);
+        ConceptInfo conceptInfo = this.getOne(conceptInfoQueryWrapper);
+
+        if (conceptInfo == null) {
+            throw new CommonException(CommonErrorCode.IS_EXISTS, "缺少静态信息");
+        }
+
+        BeanUtil.copyProperties(conceptInfo, staticKnowledgeDTO);
+        Long conceptId = conceptInfo.getId();
+        QueryWrapper<ConceptDetail> conceptDetailQueryWrapper = new QueryWrapper<>();
+        conceptDetailQueryWrapper.eq("is_deleted", IsDeleteEnum.N.getKey())
+                .eq("concept_id", conceptId);
+        if (ListUtil.isNotEmpty(staticKnowledgeVO.getContentTypes())) {
+            String sql = "";
+            for (Integer contentType : staticKnowledgeVO.getContentTypes()) {
+                if (StringUtil.isNotBlank(sql)) {
+                    sql += " or ";
+                }
+                sql += "find_in_set(" + contentType + ",content_type)";
+            }
+            sql = "(" + sql + ")";
+            conceptDetailQueryWrapper.apply(sql);
+        }
+        conceptDetailQueryWrapper.orderByAsc("order_no");
+        List<ConceptDetail> conceptDetailList = conceptDetailFacade.list(conceptDetailQueryWrapper);
+        List<StaticKnowledgeDetailDTO> detailList
+                = BeanUtil.listCopyTo(conceptDetailList, StaticKnowledgeDetailDTO.class);
+        List<StaticKnowledgeDetailDTO> introduceList = detailList
+                .stream()
+                .filter(i -> Arrays.asList(i.getContentType().split(",")).contains("1"))
+                .collect(Collectors.toList());
+        List<StaticKnowledgeDetailDTO> noticeList = detailList
+                .stream()
+                .filter(i -> Arrays.asList(i.getContentType().split(",")).contains("2"))
+                .collect(Collectors.toList());
+        List<StaticKnowledgeDetailDTO> clinicalPathwayList = detailList
+                .stream()
+                .filter(i -> Arrays.asList(i.getContentType().split(",")).contains("3"))
+                .collect(Collectors.toList());
+        Map<String, List<StaticKnowledgeDetailDTO>> detailMap = new HashMap<>();
+        if (ListUtil.isNotEmpty(introduceList) && staticKnowledgeVO.getContentTypes().contains(1)) {
+            detailMap.put("静态知识", introduceList);
+        }
+        if (ListUtil.isNotEmpty(noticeList) && staticKnowledgeVO.getContentTypes().contains(2)) {
+            detailMap.put("注意事项", noticeList);
+        }
+        if (ListUtil.isNotEmpty(clinicalPathwayList) && staticKnowledgeVO.getContentTypes().contains(3)) {
+            detailMap.put("临床路径", clinicalPathwayList);
+        }
+        staticKnowledgeDTO.setDetails(detailMap);
+        return staticKnowledgeDTO;
+    }
+
+    /**
+     * 医院端获取静态知识（对接）
+     *
+     * @param staticKnowledgeHISVO
+     * @return
+     */
+    public List<StaticKnowledgeDTO> getStaticKnowledgeForHIS(StaticKnowledgeHISVO staticKnowledgeHISVO) {
+
+        List<StaticKnowledgeDTO> retList = Lists.newArrayList();
+        String typeName = ConceptTypeEnum.getName(staticKnowledgeHISVO.getType());
+        List<DictionaryInfoDTO> dicList = dictionaryFacade.getListByGroupType(8);
+        typeName = convertTypeName(typeName, 1, dicList);
+
+        //术语映射
+        List<String> uniqueNameList = getUniqueNames(staticKnowledgeHISVO);
+        if (ListUtil.isEmpty(uniqueNameList)) {
+            return retList;
+        }
+
+        QueryWrapper<ConceptInfo> conceptInfoQueryWrapper = new QueryWrapper<>();
+        conceptInfoQueryWrapper.eq("is_deleted", IsDeleteEnum.N.getKey())
+                .in("name", uniqueNameList)
+                .eq("type", typeName);
+        List<ConceptInfo> conceptInfoList = this.list(conceptInfoQueryWrapper);
+
+        if (ListUtil.isEmpty(conceptInfoList)) {
+            return retList;
+        }
+
+        retList = BeanUtil.listCopyTo(conceptInfoList, StaticKnowledgeDTO.class);
+        List<Long> conceptIdList = conceptInfoList.stream().map(i -> i.getId()).collect(Collectors.toList());
+        QueryWrapper<ConceptDetail> conceptDetailQueryWrapper = new QueryWrapper<>();
+        conceptDetailQueryWrapper.eq("is_deleted", IsDeleteEnum.N.getKey())
+                .in("concept_id", conceptIdList);
+        if (ListUtil.isNotEmpty(staticKnowledgeHISVO.getContentTypes())) {
+            String sql = "";
+            for (Integer contentType : staticKnowledgeHISVO.getContentTypes()) {
+                if (StringUtil.isNotBlank(sql)) {
+                    sql += " or ";
+                }
+                sql += "find_in_set(" + contentType + ",content_type)";
+            }
+            sql = "(" + sql + ")";
+            conceptDetailQueryWrapper.apply(sql);
+        }
+        conceptDetailQueryWrapper.orderByAsc("concept_id", "order_no");
+        List<ConceptDetail> conceptDetailList = conceptDetailFacade.list(conceptDetailQueryWrapper);
+        List<StaticKnowledgeDetailDTO> detailList
+                = BeanUtil.listCopyTo(conceptDetailList, StaticKnowledgeDetailDTO.class);
+        Map<Long, List<StaticKnowledgeDetailDTO>> conceptMap
+                = EntityUtil.makeEntityListMap(detailList, "conceptId");
+        for (StaticKnowledgeDTO staticKnowledgeDTO : retList) {
+            List<StaticKnowledgeDetailDTO> subDetailList = conceptMap.get(staticKnowledgeDTO.getId());
+            if (ListUtil.isNotEmpty(subDetailList)) {
+                List<StaticKnowledgeDetailDTO> introduceList = subDetailList
+                        .stream()
+                        .filter(i -> Arrays.asList(i.getContentType().split(",")).contains("1"))
+                        .collect(Collectors.toList());
+                List<StaticKnowledgeDetailDTO> noticeList = subDetailList
+                        .stream()
+                        .filter(i -> Arrays.asList(i.getContentType().split(",")).contains("2"))
+                        .collect(Collectors.toList());
+                List<StaticKnowledgeDetailDTO> clinicalPathwayList = subDetailList
+                        .stream()
+                        .filter(i -> Arrays.asList(i.getContentType().split(",")).contains("3"))
+                        .collect(Collectors.toList());
+                Map<String, List<StaticKnowledgeDetailDTO>> subDetailMap = new HashMap<>();
+                if (ListUtil.isNotEmpty(introduceList) && staticKnowledgeHISVO.getContentTypes().contains(1)) {
+                    subDetailMap.put("静态知识", introduceList);
+                }
+                if (ListUtil.isNotEmpty(noticeList) && staticKnowledgeHISVO.getContentTypes().contains(2)) {
+                    subDetailMap.put("注意事项", noticeList);
+                }
+                if (ListUtil.isNotEmpty(clinicalPathwayList) && staticKnowledgeHISVO.getContentTypes().contains(3)) {
+                    subDetailMap.put("临床路径", clinicalPathwayList);
+                }
+                staticKnowledgeDTO.setDetails(subDetailMap);
+            }
+        }
+        return retList;
+    }
+
+    /**
+     * 页面术语类型和图谱标签名称相互转换
+     *
+     * @param typeName
+     * @param flag     1-页面术语类型转图谱标签名称,2- 图谱标签名称转页面术语类型
+     * @param dicList
+     * @return
+     */
+    public String convertTypeName(String typeName, Integer flag, List<DictionaryInfoDTO> dicList) {
+        if (ListUtil.isNotEmpty(dicList)) {
+            Map<String, String> nameValMap = new HashMap<>();
+            if (flag.equals(1)) {
+                nameValMap = EntityUtil.makeMapWithKeyValue(dicList, "name", "val");
+            } else if (flag.equals(2)) {
+                nameValMap = EntityUtil.makeMapWithKeyValue(dicList, "val", "name");
+            }
+            if (nameValMap.containsKey(typeName)) {
+                return nameValMap.get(typeName);
+            }
+        }
+        return typeName;
+    }
+
+    /**
+     * @param staticKnowledgeHISVO
+     * @return
+     */
+    public List<String> getUniqueNames(StaticKnowledgeHISVO staticKnowledgeHISVO) {
+        String hospitalId = SysUserUtils.getCurrentHospitalID();
+        List<String> nameList = null;
+        switch (staticKnowledgeHISVO.getType()) {
+            case 1:
+                Map<String, Map<String, Long>> disConfigMap
+                        = diseaseConfigFacade.getConfigMap(Long.valueOf(hospitalId),
+                        ListUtil.arrayToList(new String[] { staticKnowledgeHISVO.getHisName() }), null);
+                if (disConfigMap != null) {
+                    nameList = new ArrayList<>(disConfigMap.get(staticKnowledgeHISVO.getHisName()).keySet());
+                }
+                break;
+            case 2:
+                Map<String, Map<String, Long>> drugConfigMap
+                        = drugConfigFacade.getConfigMap(Long.valueOf(hospitalId),
+                        ListUtil.arrayToList(new String[] { staticKnowledgeHISVO.getHisName() }), null);
+                if (drugConfigMap != null) {
+                    nameList = new ArrayList<>(drugConfigMap.get(staticKnowledgeHISVO.getHisName()).keySet());
+                }
+                break;
+            case 3:
+            case 4:
+                Map<String, Map<String, Map<String, Long>>> lisConfigMap
+                        = lisConfigFacade.getConfigMap(Long.valueOf(hospitalId),
+                        ListUtil.arrayToList(new String[] { staticKnowledgeHISVO.getHisName() }), null);
+                if (lisConfigMap != null) {
+                    if (StringUtil.isBlank(staticKnowledgeHISVO.getHisDetailName())) {
+                        staticKnowledgeHISVO.setHisDetailName("");
+                    }
+                    if (lisConfigMap.containsKey(staticKnowledgeHISVO.getHisName())) {
+                        if (lisConfigMap.get(staticKnowledgeHISVO.getHisName()).containsKey(staticKnowledgeHISVO.getHisDetailName())) {
+                            nameList = new ArrayList<>(lisConfigMap.get(staticKnowledgeHISVO.getHisName())
+                                    .get(staticKnowledgeHISVO.getHisDetailName()).keySet());
+                        }
+                    }
+                }
+                break;
+            case 5:
+                Map<String, Map<String, Long>> pacsConfigMap
+                        = pacsConfigFacade.getConfigMap(Long.valueOf(hospitalId),
+                        ListUtil.arrayToList(new String[] { staticKnowledgeHISVO.getHisName() }), null);
+                if (pacsConfigMap != null) {
+                    nameList = new ArrayList<>(pacsConfigMap.get(staticKnowledgeHISVO.getHisName()).keySet());
+                }
+                break;
+            case 6:
+                Map<String, Map<String, Long>> operationConfigMap
+                        = operationConfigFacade.getConfigMap(Long.valueOf(hospitalId),
+                        ListUtil.arrayToList(new String[] { staticKnowledgeHISVO.getHisName() }), null);
+                if (operationConfigMap != null) {
+                    nameList = new ArrayList<>(operationConfigMap.get(staticKnowledgeHISVO.getHisName()).keySet());
+                }
+                break;
+            default:
+                break;
+
+        }
+        return nameList;
+    }
+
+    /**
+     * 列表
+     *
+     * @param conceptInfoPageVO
+     * @return
+     */
+    public IPage<ConceptInfoDTO> getPage(ConceptInfoPageVO conceptInfoPageVO) {
+        List<DictionaryInfoDTO> dicList = dictionaryFacade.getListByGroupType(8);
+        if (StringUtil.isNotBlank(conceptInfoPageVO.getType())) {
+            String typeName
+                    = convertTypeName(ConceptTypeEnum.getName(Integer.valueOf(conceptInfoPageVO.getType())), 1, dicList);
+            conceptInfoPageVO.setTypeName(typeName);
+        }
+        IPage<ConceptInfoDTO> page = super.getPage(conceptInfoPageVO);
+        List<ConceptInfoDTO> records = page.getRecords();
+        if (ListUtil.isNotEmpty(records)) {
+            records.forEach(record -> {
+                record.setTypeName(convertTypeName(record.getTypeName(), 2, dicList));
+            });
+        }
+        page.setRecords(records);
+        return page;
+    }
+}

src/main/java/com/diagbot/facade/DictionaryFacade.java

@@ -34,4 +34,19 @@ public class DictionaryFacade extends DictionaryInfoServiceImpl {
         List<DictionaryInfoDTO> listRes = BeanUtil.listCopyTo(list, DictionaryInfoDTO.class);
         return EntityUtil.makeEntityListMap(listRes, "groupType");
     }
-}
+
+    /**
+     * 返回指定字典信息
+     *
+     * @param groupType
+     * @return
+     */
+    public List<DictionaryInfoDTO> getListByGroupType(Integer groupType) {
+        List<DictionaryInfo> list = this.list(new QueryWrapper<DictionaryInfo>()
+                .eq("group_type", groupType)
+                .eq("is_deleted", IsDeleteEnum.N.getKey())
+                .orderByAsc("order_no"));
+        List<DictionaryInfoDTO> listRes = BeanUtil.listCopyTo(list, DictionaryInfoDTO.class);
+        return listRes;
+    }
+}

src/main/java/com/diagbot/facade/PushFacade.java

@@ -1,12 +1,12 @@
 package com.diagbot.facade;
 
 import com.diagbot.client.CdssCoreClient;
-import com.diagbot.dto.BillMsg;
 import com.diagbot.dto.IndicationDTO;
 import com.diagbot.dto.PushBaseDTO;
 import com.diagbot.dto.PushDTO;
 import com.diagbot.dto.RespDTO;
 import com.diagbot.util.BeanUtil;
+import com.diagbot.util.RespDTOUtil;
 import com.diagbot.vo.IndicationPushVO;
 import com.diagbot.vo.PushVO;
 import com.diagbot.vo.SearchData;
@@ -45,6 +45,7 @@ public class PushFacade {
         //RespDTOUtil.respNGDealCover(resp, "远程调用推理接口失败");
         //PushDTO data = resp.data;
         PushDTO data = new PushDTO();
+        //症状
         List<PushBaseDTO> symptom = Lists.newArrayList();
         PushBaseDTO sympItem1 = new PushBaseDTO();
         sympItem1.setName("发热");
@@ -53,6 +54,52 @@ public class PushFacade {
         sympItem2.setName("咳嗽");
         symptom.add(sympItem2);
         data.setSymptom(symptom);
+        //体格检查
+        List<PushBaseDTO> vital = Lists.newArrayList();
+        PushBaseDTO vital1 = new PushBaseDTO();
+        vital1.setName("肾区叩痛阳性");
+        vital.add(vital1);
+        PushBaseDTO vital2 = new PushBaseDTO();
+        vital2.setName("血压升高");
+        vital.add(vital2);
+        data.setVital(vital);
+        //检验
+        List<PushBaseDTO> lis = Lists.newArrayList();
+        PushBaseDTO lis1 = new PushBaseDTO();
+        lis1.setName("血常规");
+        lis.add(lis1);
+        PushBaseDTO lis2 = new PushBaseDTO();
+        lis2.setName("尿常规");
+        lis.add(lis2);
+        data.setLis(lis);
+        //检查
+        List<PushBaseDTO> pacs = Lists.newArrayList();
+        PushBaseDTO pacs1 = new PushBaseDTO();
+        pacs1.setName("脊柱X线检查");
+        pacs.add(pacs1);
+        PushBaseDTO pacs2 = new PushBaseDTO();
+        pacs2.setName("经直肠前列腺彩超检查");
+        pacs.add(pacs2);
+        data.setPacs(pacs);
+        //药品
+        List<PushBaseDTO> medicines = Lists.newArrayList();
+        PushBaseDTO medicines1 = new PushBaseDTO();
+        medicines1.setName("钙通道阻滞剂");
+        medicines.add(medicines1);
+        PushBaseDTO medicines2 = new PushBaseDTO();
+        medicines2.setName("盐酸肾上腺素注射液");
+        medicines.add(medicines2);
+        data.setMedicines(medicines);
+        //手术和操作
+        List<PushBaseDTO> operations = Lists.newArrayList();
+        PushBaseDTO operations1 = new PushBaseDTO();
+        operations1.setName("前列腺按摩");
+        operations.add(operations1);
+        PushBaseDTO operations2 = new PushBaseDTO();
+        operations2.setName("经皮冠状动脉介入治疗(PCI)");
+        operations.add(operations2);
+        data.setOperations(operations);
+        //诊断
         List<PushBaseDTO> dis = Lists.newArrayList();
         PushBaseDTO disItem1 = new PushBaseDTO();
         disItem1.setName("急性胰腺炎");
@@ -79,19 +126,37 @@ public class PushFacade {
         //TODO 入参映射
         searchData = assembleFacade.assembleData(searchData);
         BeanUtil.copyProperties(searchData, indicationPushVO);
-        IndicationDTO indicationDTO = new IndicationDTO();
-        List<BillMsg> billMsgList = Lists.newArrayList();
-        BillMsg item1 = new BillMsg();
-        item1.setMsg("不宜做胃镜");
-        item1.setOrderName("胃镜");
-        item1.setOrderStandName("胃镜");
-        item1.setCompareName("妊娠");
-        item1.setCompareStandName("妊娠");
-        billMsgList.add(item1);
-        indicationDTO.setBillMsgList(billMsgList);
-        //RespDTO<IndicationDTO> resp = cdssCoreClient.indication(indicationPushVO);
-        //RespDTOUtil.respNGDealCover(resp, "远程调用推理接口失败");
-        //IndicationDTO indicationDTO=resp.data;
+        //        IndicationDTO indicationDTO = new IndicationDTO();
+        //        List<BillMsg> billMsgList = Lists.newArrayList();
+        //        BillMsg item1 = new BillMsg();
+        //        item1.setMsg("该患者年龄15,不宜开左氧氟沙星");
+        //        item1.setOrderName("左氧氟沙星");
+        //        item1.setOrderStandName("左氧氟沙星");
+        //        item1.setContent("年龄15");
+        //        item1.setType("禁忌年龄");
+        //        billMsgList.add(item1);
+        //        indicationDTO.setBillMsgList(billMsgList);
+        //        List<BillMsg> criticalValList = Lists.newArrayList();
+        //        BillMsg item2 = new BillMsg();
+        //        item2.setMsg("该患者血常规血小板计数30,请留意");
+        //        item2.setOrderName("");
+        //        item2.setOrderStandName("");
+        //        item2.setContent("血常规血小板计数30");
+        //        item2.setType("血常规血小板计数30");
+        //        criticalValList.add(item2);
+        //        indicationDTO.setCriticalValList(criticalValList);
+        //        List<BillMsg> highRiskList = Lists.newArrayList();
+        //        BillMsg item3 = new BillMsg();
+        //        item3.setMsg("盐酸肾上腺素注射液为高风险药品，请留意");
+        //        item3.setOrderName("盐酸肾上腺素注射液");
+        //        item3.setOrderStandName("盐酸肾上腺素注射液");
+        //        item3.setContent("");
+        //        item3.setType("药品");
+        //        highRiskList.add(item3);
+        //        indicationDTO.setHighRiskList(highRiskList);
+        RespDTO<IndicationDTO> resp = cdssCoreClient.indication(indicationPushVO);
+        RespDTOUtil.respNGDealCover(resp, "远程调用推理接口失败");
+        IndicationDTO indicationDTO = resp.data;
         return indicationDTO;
     }
 }

src/main/java/com/diagbot/facade/RetrievalFacade.java

@@ -1,28 +1,13 @@
 package com.diagbot.facade;
 
-import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
 import com.diagbot.client.CdssCoreClient;
 import com.diagbot.dto.RespDTO;
 import com.diagbot.dto.RetrievalDTO;
-import com.diagbot.dto.StaticKnowledgeIndexDTO;
-import com.diagbot.entity.ConceptDetail;
-import com.diagbot.entity.ConceptInfo;
-import com.diagbot.entity.DictionaryInfo;
-import com.diagbot.enums.IsDeleteEnum;
-import com.diagbot.util.EntityUtil;
-import com.diagbot.util.ListUtil;
 import com.diagbot.util.RespDTOUtil;
 import com.diagbot.vo.RetrievalVO;
-import com.diagbot.vo.StaticKnowledgeIndexVO;
-import com.google.common.collect.Lists;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;
 
-import java.util.Arrays;
-import java.util.List;
-import java.util.Map;
-import java.util.stream.Collectors;
-
 /**
  * @Description:
  * @Author:zhaops
@@ -32,13 +17,6 @@ import java.util.stream.Collectors;
 public class RetrievalFacade {
     @Autowired
     private CdssCoreClient cdssCoreClient;
-    @Autowired
-    private DictionaryFacade dictionaryFacade;
-    @Autowired
-    private ConceptInfoFacade conceptInfoFacade;
-    @Autowired
-    private ConceptDetailFacade conceptDetailFacade;
-
 
     /**
      * 检索
@@ -53,85 +31,4 @@ public class RetrievalFacade {
         retrievalDTO = respDTO.data;
         return retrievalDTO;
     }
-
-    /**
-     * 医学知识（静态信息）检索
-     *
-     * @param staticKnowledgeIndexVO
-     * @return
-     */
-    public List<StaticKnowledgeIndexDTO> staticKnowledgeIndex(StaticKnowledgeIndexVO staticKnowledgeIndexVO) {
-        List<StaticKnowledgeIndexDTO> retList = Lists.newLinkedList();
-        QueryWrapper<DictionaryInfo> dictionaryInfoQueryWrapper = new QueryWrapper<>();
-        dictionaryInfoQueryWrapper.eq("is_deleted", IsDeleteEnum.N.getKey())
-                .eq("group_type", 7)
-                .eq("return_type", 2)
-                .orderByAsc("order_no");
-        List<DictionaryInfo> dicList = dictionaryFacade.list(dictionaryInfoQueryWrapper);
-
-        List<StaticKnowledgeIndexDTO> staticKnowledgeIndexDTOList = Lists.newLinkedList();
-        RespDTO<List<StaticKnowledgeIndexDTO>> respDTO = cdssCoreClient.staticKnowledgeIndex(staticKnowledgeIndexVO);
-        RespDTOUtil.respNGDealCover(respDTO, "检索失败");
-        staticKnowledgeIndexDTOList = respDTO.data;
-        if (ListUtil.isNotEmpty(staticKnowledgeIndexDTOList)) {
-            //是否有静态知识
-            List<String> conNameList = staticKnowledgeIndexDTOList
-                    .stream()
-                    .map(i -> i.getName())
-                    .collect(Collectors.toList());
-            QueryWrapper<ConceptInfo> conceptInfoQueryWrapper = new QueryWrapper<>();
-            conceptInfoQueryWrapper.eq("is_deleted", IsDeleteEnum.N.getKey())
-                    .in("name", conNameList);
-            List<ConceptInfo> conceptInfoList = conceptInfoFacade.list(conceptInfoQueryWrapper);
-            Map<String, ConceptInfo> infoMap
-                    = EntityUtil.makeEntityMapByKeys(conceptInfoList, "_", "name", "type");
-            for (StaticKnowledgeIndexDTO item : staticKnowledgeIndexDTOList) {
-                if (infoMap.containsKey(item.getName() + "_" + item.getTypeName())) {
-                    item.setId(infoMap.get(item.getName() + "_" + item.getTypeName()).getId());
-                }
-            }
-            List<Long> conceptIdList = conceptInfoList.stream()
-                    .map(i -> i.getId())
-                    .collect(Collectors.toList());
-            if (ListUtil.isNotEmpty(conceptIdList)) {
-                QueryWrapper<ConceptDetail> conceptDetailQueryWrapper = new QueryWrapper<>();
-                conceptDetailQueryWrapper.eq("is_deleted", IsDeleteEnum.N.getKey())
-                        .in("concept_id", conceptIdList);
-                List<ConceptDetail> conceptDetailList = conceptDetailFacade.list(conceptDetailQueryWrapper);
-                Map<Long, List<ConceptDetail>> detailMap
-                        = EntityUtil.makeEntityListMap(conceptDetailList, "conceptId");
-                for (StaticKnowledgeIndexDTO item : staticKnowledgeIndexDTOList) {
-                    if (item.getId() == null
-                            || !detailMap.containsKey(item.getId())) {
-                        item.setHasInfomation(0);
-                        item.setHasClinicalPathway(0);
-                        item.setHasNotice((0));
-                        continue;
-                    }
-                    for (ConceptDetail detail : detailMap.get(item.getId())) {
-                        List<String> contentTypeList = Arrays.asList(detail.getConcentType().split(","));
-                        if (contentTypeList.contains(1)) {
-                            item.setHasInfomation(1);
-                        }
-                        if (contentTypeList.contains(2)) {
-                            item.setHasNotice(1);
-                        }
-                        if (contentTypeList.contains(3)) {
-                            item.setHasClinicalPathway(1);
-                        }
-                    }
-                }
-            }
-
-            //排序
-            Map<String, List<StaticKnowledgeIndexDTO>> map
-                    = EntityUtil.makeEntityListMap(staticKnowledgeIndexDTOList, "typeName");
-            for (DictionaryInfo dic : dicList) {
-                if (map.containsKey(dic.getName())) {
-                    retList.addAll(map.get(dic.getName()));
-                }
-            }
-        }
-        return retList;
-    }
 }

src/main/java/com/diagbot/mapper/ConceptInfoMapper.java

@@ -1,7 +1,11 @@
 package com.diagbot.mapper;
 
-import com.diagbot.entity.ConceptInfo;
 import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.baomidou.mybatisplus.core.metadata.IPage;
+import com.diagbot.dto.ConceptInfoDTO;
+import com.diagbot.entity.ConceptInfo;
+import com.diagbot.vo.ConceptInfoPageVO;
+import org.apache.ibatis.annotations.Param;
 
 /**
  * <p>
@@ -12,5 +16,11 @@ import com.baomidou.mybatisplus.core.mapper.BaseMapper;
  * @since 2020-08-18
  */
 public interface ConceptInfoMapper extends BaseMapper<ConceptInfo> {
-
-}
+    /**
+     * 列表
+     *
+     * @param conceptInfoPageVO
+     * @return
+     */
+    IPage<ConceptInfoDTO> getPage(@Param("conceptInfoPageVO") ConceptInfoPageVO conceptInfoPageVO);
+}

src/main/java/com/diagbot/service/ConceptInfoService.java

@@ -1,7 +1,11 @@
 package com.diagbot.service;
 
+import com.baomidou.mybatisplus.core.metadata.IPage;
+import com.diagbot.dto.ConceptInfoDTO;
 import com.diagbot.entity.ConceptInfo;
 import com.baomidou.mybatisplus.extension.service.IService;
+import com.diagbot.vo.ConceptInfoPageVO;
+import org.apache.ibatis.annotations.Param;
 
 /**
  * <p>
@@ -12,5 +16,11 @@ import com.baomidou.mybatisplus.extension.service.IService;
  * @since 2020-08-18
  */
 public interface ConceptInfoService extends IService<ConceptInfo> {
-
+    /**
+     * 列表
+     *
+     * @param conceptInfoPageVO
+     * @return
+     */
+    IPage<ConceptInfoDTO> getPage(@Param("conceptInfoPageVO") ConceptInfoPageVO conceptInfoPageVO);
 }

src/main/java/com/diagbot/service/impl/ConceptInfoServiceImpl.java

@@ -1,9 +1,13 @@
 package com.diagbot.service.impl;
 
+import com.baomidou.mybatisplus.core.metadata.IPage;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.diagbot.dto.ConceptInfoDTO;
 import com.diagbot.entity.ConceptInfo;
 import com.diagbot.mapper.ConceptInfoMapper;
 import com.diagbot.service.ConceptInfoService;
-import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.diagbot.vo.ConceptInfoPageVO;
+import org.apache.ibatis.annotations.Param;
 import org.springframework.stereotype.Service;
 
 /**
@@ -16,5 +20,14 @@ import org.springframework.stereotype.Service;
  */
 @Service
 public class ConceptInfoServiceImpl extends ServiceImpl<ConceptInfoMapper, ConceptInfo> implements ConceptInfoService {
-
+    /**
+     * 列表
+     *
+     * @param conceptInfoPageVO
+     * @return
+     */
+    @Override
+    public IPage<ConceptInfoDTO> getPage(@Param("conceptInfoPageVO") ConceptInfoPageVO conceptInfoPageVO) {
+        return baseMapper.getPage(conceptInfoPageVO);
+    }
 }

src/main/java/com/diagbot/vo/ConceptInfoPageVO.java

@@ -0,0 +1,33 @@
+package com.diagbot.vo;
+
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Getter;
+import lombok.Setter;
+
+/**
+ * @Description:
+ * @Author:zhaops
+ * @time: 2020/8/21 14:53
+ */
+@Getter
+@Setter
+public class ConceptInfoPageVO extends Page {
+    /**
+     * 标准术语
+     */
+    private String name;
+    /**
+     * 术语类型
+     */
+    private String type;
+    /**
+     * 术语类型
+     */
+    @ApiModelProperty(hidden = true)
+    private String typeName;
+    /**
+     * 启用状态
+     */
+    private String isDeleted;
+}

src/main/java/com/diagbot/vo/StaticKnowledgeHISVO.java

@@ -0,0 +1,28 @@
+package com.diagbot.vo;
+
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Getter;
+import lombok.Setter;
+
+/**
+ * @Description:
+ * @Author:zhaops
+ * @time: 2020/8/20 14:54
+ */
+@Getter
+@Setter
+public class StaticKnowledgeHISVO extends StaticKnowledgeVO {
+    /**
+     * his名称
+     */
+    private String hisName;
+    /**
+     * his明细名称
+     */
+    private String hisDetailName;
+    /**
+     * 医院id
+     */
+    @ApiModelProperty(hidden = true)
+    private Long hospitalId;
+}

src/main/java/com/diagbot/vo/StaticKnowledgeIndexVO.java

@@ -19,7 +19,7 @@ public class StaticKnowledgeIndexVO {
      */
     private String inputStr;
     /**
-     * 检索类型（多选）
+     * 检索类型（多选）:0-全部、1-诊断、2-药品、3-检验、5-检查、6-手术和操作
      */
     @NotNull(message = "请输入检索类型")
     private List<Integer> types;

src/main/java/com/diagbot/vo/StaticKnowledgeVO.java

@@ -0,0 +1,31 @@
+package com.diagbot.vo;
+
+import lombok.Getter;
+import lombok.Setter;
+
+import javax.validation.constraints.NotBlank;
+import javax.validation.constraints.NotNull;
+import java.util.List;
+
+/**
+ * @Description:
+ * @Author:zhaops
+ * @time: 2020/8/20 14:50
+ */
+@Getter
+@Setter
+public class StaticKnowledgeVO {
+    /**
+     * 标准术语名称
+     */
+    private String name;
+    /**
+     * 术语类型
+     */
+    @NotNull(message = "请输入术语类型")
+    private Integer type;
+    /**
+     * 内容类型
+     */
+    private List<Integer> contentTypes;
+}

src/main/java/com/diagbot/vo/TemplateInfosVO.java

@@ -1,6 +1,5 @@
 package com.diagbot.vo;
 
-import com.fasterxml.jackson.annotation.JsonFormat;
 import io.swagger.annotations.ApiModelProperty;
 import lombok.Getter;
 import lombok.Setter;

src/main/java/com/diagbot/web/ConceptDetailController.java

@@ -1,9 +1,11 @@
 package com.diagbot.web;
 
 
+import io.swagger.annotations.Api;
 import org.springframework.web.bind.annotation.RequestMapping;
 
 import org.springframework.stereotype.Controller;
+import org.springframework.web.bind.annotation.RestController;
 
 /**
  * <p>
@@ -13,8 +15,9 @@ import org.springframework.stereotype.Controller;
  * @author zhaops
  * @since 2020-08-18
  */
-@Controller
+@RestController
 @RequestMapping("/conceptDetail")
+@Api(value = "静态知识内容相关API", tags = { "静态知识内容相关API" })
 public class ConceptDetailController {
 
 }

src/main/java/com/diagbot/web/ConceptInfoController.java

@@ -1,9 +1,27 @@
 package com.diagbot.web;
 
 
+import com.baomidou.mybatisplus.core.metadata.IPage;
+import com.diagbot.annotation.SysLogger;
+import com.diagbot.dto.ConceptInfoDTO;
+import com.diagbot.dto.RespDTO;
+import com.diagbot.dto.StaticKnowledgeDTO;
+import com.diagbot.dto.StaticKnowledgeIndexDTO;
+import com.diagbot.facade.ConceptInfoFacade;
+import com.diagbot.vo.ConceptInfoPageVO;
+import com.diagbot.vo.StaticKnowledgeHISVO;
+import com.diagbot.vo.StaticKnowledgeIndexVO;
+import com.diagbot.vo.StaticKnowledgeVO;
+import io.swagger.annotations.Api;
+import io.swagger.annotations.ApiOperation;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
 import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
 
-import org.springframework.stereotype.Controller;
+import javax.validation.Valid;
+import java.util.List;
 
 /**
  * <p>
@@ -13,8 +31,66 @@ import org.springframework.stereotype.Controller;
  * @author zhaops
  * @since 2020-08-18
  */
-@Controller
-@RequestMapping("/conceptInfo")
+@RestController
+@RequestMapping("/graph/conceptInfo")
+@Api(value = "静态知识标准术语相关API", tags = { "静态知识标准术语相关API" })
 public class ConceptInfoController {
 
-}
+    @Autowired
+    private ConceptInfoFacade conceptInfoFacade;
+
+    @ApiOperation(value = "医学知识（静态知识）检索[zhaops]",
+            notes = "types： 类型（多选）：0-全部、1-诊断、2-药品、3-检验、5-检查、6-手术和操作 <br>" +
+                    "inputStr： 检索内容<br>")
+    @PostMapping("/staticKnowledgeIndex")
+    @SysLogger("staticKnowledgeIndex")
+    public RespDTO<List<StaticKnowledgeIndexDTO>> staticKnowledgeIndex(@Valid @RequestBody StaticKnowledgeIndexVO staticKnowledgeIndexVO) {
+        List<StaticKnowledgeIndexDTO> data = conceptInfoFacade.staticKnowledgeIndexWithInfo(staticKnowledgeIndexVO);
+        return RespDTO.onSuc(data);
+    }
+
+    @ApiOperation(value = "医学术语检索-新增静态知识[zhaops]",
+            notes = "types： 类型（多选）：0-全部、1-诊断、2-药品、3-检验、5-检查、6-手术和操作 <br>" +
+                    "inputStr： 检索内容<br>")
+    @PostMapping("/staticKnowledgeIndexWithoutInfo")
+    @SysLogger("staticKnowledgeIndexWithoutInfo")
+    public RespDTO<List<StaticKnowledgeIndexDTO>> staticKnowledgeIndexWithoutInfo(@Valid @RequestBody StaticKnowledgeIndexVO staticKnowledgeIndexVO) {
+        List<StaticKnowledgeIndexDTO> data = conceptInfoFacade.staticKnowledgeIndexWithoutInfo(staticKnowledgeIndexVO);
+        return RespDTO.onSuc(data);
+    }
+
+
+    @ApiOperation(value = "页面获取静态知识[zhaops]",
+            notes = "type： 类型：1-诊断、2-药品、3-检验套餐、4-检验明细、5-检查、6-手术和操作 <br>" +
+                    "contentTypes： 内容类型（多选）：1-静态信息、2-注意事项、3-临床路径 <br>" +
+                    "name： 标准术语名称<br>")
+    @PostMapping("/getStaticKnowledge")
+    @SysLogger("getStaticKnowledge")
+    public RespDTO<StaticKnowledgeDTO> getStaticKnowledge(@Valid @RequestBody StaticKnowledgeVO staticKnowledgeVO) {
+        StaticKnowledgeDTO data = conceptInfoFacade.getStaticKnowledge(staticKnowledgeVO);
+        return RespDTO.onSuc(data);
+    }
+
+    @ApiOperation(value = "对接获取静态知识[zhaops]",
+            notes = "type： 类型：1-诊断、2-药品、3-检验套餐、4-检验明细、5-检查、6-手术和操作 <br>" +
+                    "contentTypes： 内容类型（多选）：1-静态信息、2-注意事项、3-临床路径 <br>" +
+                    "hisName： HIS大项名称<br>" +
+                    "hisDetailName： HIS小项名称<br>")
+    @PostMapping("/getStaticKnowledgeForHIS")
+    @SysLogger("getStaticKnowledgeForHIS")
+    public RespDTO<List<StaticKnowledgeDTO>> getStaticKnowledgeForHIS(@Valid @RequestBody StaticKnowledgeHISVO staticKnowledgeHISVO) {
+        List<StaticKnowledgeDTO> data = conceptInfoFacade.getStaticKnowledgeForHIS(staticKnowledgeHISVO);
+        return RespDTO.onSuc(data);
+    }
+
+    @ApiOperation(value = "获取静态知识列表[zhaops]",
+            notes = "type： 类型：1-诊断、2-药品、3-检验套餐、4-检验明细、5-检查、6-手术和操作 <br>" +
+                    "name： 术语名称<br>" +
+                    "isDeleted： 启用状态：N-启用中、Y-已删除<br>")
+    @PostMapping("/getPage")
+    @SysLogger("getPage")
+    public RespDTO<IPage<ConceptInfoDTO>> getPage(@Valid @RequestBody ConceptInfoPageVO conceptInfoPageVO) {
+        IPage<ConceptInfoDTO> data = conceptInfoFacade.getPage(conceptInfoPageVO);
+        return RespDTO.onSuc(data);
+    }
+}

src/main/java/com/diagbot/web/PushController.java

@@ -31,7 +31,7 @@ public class PushController {
     @Autowired
     private PushFacade pushFacade;
 
-    @ApiOperation(value = "基础推理[by:zhaops]", notes = "类型(多选必填)，1：症状，4：查体结果，5：检验，6：检查，7：诊断，8：药品，9：手术")
+    @ApiOperation(value = "基础推理[by:zhaops]", notes = "featureType 类型(多选必填)，1：症状，4：查体结果，5：检验，6：检查，7：诊断，8：药品，9：手术")
     @PostMapping("/push")
     @SysLogger("push")
     @TokenAuth

src/main/java/com/diagbot/web/RetrievalController.java

@@ -2,10 +2,8 @@ package com.diagbot.web;
 
 import com.diagbot.dto.RespDTO;
 import com.diagbot.dto.RetrievalDTO;
-import com.diagbot.dto.StaticKnowledgeIndexDTO;
 import com.diagbot.facade.RetrievalFacade;
 import com.diagbot.vo.RetrievalVO;
-import com.diagbot.vo.StaticKnowledgeIndexVO;
 import io.swagger.annotations.Api;
 import io.swagger.annotations.ApiOperation;
 import org.springframework.beans.factory.annotation.Autowired;
@@ -15,7 +13,6 @@ import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.RestController;
 
 import javax.validation.Valid;
-import java.util.List;
 
 /**
  * @Description:
@@ -40,13 +37,4 @@ public class RetrievalController {
         RetrievalDTO data = retrievalFacade.index(retrievalVO);
         return RespDTO.onSuc(data);
     }
-
-    @ApiOperation(value = "医学知识（静态知识）检索[zhaops]",
-            notes = "types： 类型（多选）：0-全部、1-诊断、2-药品、3-检验、4-检查、5-手术和操作 <br>" +
-                    "inputStr： 检索内容<br>")
-    @PostMapping("/staticKnowledgeIndex")
-    public RespDTO<List<StaticKnowledgeIndexDTO>> staticKnowledgeIndex(@Valid @RequestBody StaticKnowledgeIndexVO staticKnowledgeIndexVO) {
-        List<StaticKnowledgeIndexDTO> data = retrievalFacade.staticKnowledgeIndex(staticKnowledgeIndexVO);
-        return RespDTO.onSuc(data);
-    }
 }

src/main/resources/mapper/ConceptDetailMapper.xml

@@ -15,7 +15,7 @@
         <result column="content" property="content" />
         <result column="text" property="text" />
         <result column="order_no" property="orderNo" />
-        <result column="concent_type" property="concentType" />
+        <result column="content_type" property="contentType" />
     </resultMap>
 
 </mapper>

src/main/resources/mapper/ConceptInfoMapper.xml

@@ -16,4 +16,46 @@
         <result column="notice_name" property="noticeName" />
     </resultMap>
 
+    <!-- 分页查询 -->
+    <select id="getPage" resultType="com.diagbot.dto.ConceptInfoDTO">
+        SELECT
+        t1.NAME,
+        t1.clinicalPathwayName,
+        t1.noticeName,
+        t1.type,
+        t1.isDeleted,
+        t1.title,
+        t1.gmtModified,
+        t2.linkman AS modifier
+        FROM
+        (
+        SELECT
+        a.NAME,
+        a.clinical_pathway_name AS clinicalPathwayName,
+        a.notice_name AS noticeName,
+        a.type,
+        a.is_deleted AS isDeleted,
+        GROUP_CONCAT( b.title SEPARATOR '、' ) AS title,
+        b.gmt_modified AS gmtModified,
+        b.modifier
+        FROM
+        graph_concept_info a,
+        graph_concept_detail b
+        WHERE
+        a.id = b.concept_id
+        <if test="conceptInfoPageVO.isDeleted!=null and conceptInfoPageVO.isDeleted!=''">
+            AND a.is_deleted = #{conceptInfoPageVO.isDeleted}
+        </if>
+        <if test="conceptInfoPageVO.name!=null and conceptInfoPageVO.name!=''">
+            AND a.name like concat('%', #{conceptInfoPageVO.name},'%')
+        </if>
+        <if test="conceptInfoPageVO.typeName!=null and conceptInfoPageVO.typeName!=''">
+            AND a.type = #{conceptInfoPageVO.typeName}
+        </if>
+        GROUP BY
+        a.id
+        ) t1
+        LEFT JOIN sys_user t2 ON t1.modifier = t2.id
+    </select>
+
 </mapper>