推理

aipt-service/src/main/java/com/diagbot/dto/PushDTO.java

@@ -17,11 +17,12 @@ public class PushDTO {
     private List<ConceptPushDTO> symptom;
     private List<ConceptPushDTO> other;
     private List<ConceptPushDTO> vital;
-    private List<Long> markedVitalIds;
+    private List<ConceptPushDTO> moduleVital;
     private List<ConceptPushDTO> lab;
     private List<ConceptPushDTO> pacs;
     private Map<String, List<ConceptPushDTO>> dis;
     private Map<String, Object> treat;
+    private String deptName;
     //private List<MedicalIndicationDTO> medicalIndications;
     //private List<EvaluationModuleMappingDTO> evaluationModule;
 }

aipt-service/src/main/java/com/diagbot/enums/ConceptTypeEnum.java

@@ -20,6 +20,7 @@ public enum  ConceptTypeEnum implements KeyedNamed {
     Drug_Category_Big(9, "药品分类-大类"),
     SIDE_EFFECTS(10, "不良反应"),
     Drug_Category_Small(11, "药品分类-小类"),
+    LIS_TABLES(12,"化验公表项"),
     Scale(21, "量表"),
     Indication(22, "指标");
 

aipt-service/src/main/java/com/diagbot/enums/IntroducePositionEnum.java

@@ -0,0 +1,53 @@
+package com.diagbot.enums;
+
+import com.diagbot.core.KeyedNamed;
+import lombok.Setter;
+
+/**
+ * @Description:提示信息展示位置
+ * @Author:zhaops
+ * @time: 2018/11/23 10:12
+ */
+public enum IntroducePositionEnum implements KeyedNamed {
+    Push(1, "推送展示"),
+    More(2, "更多展示"),
+    CommonTreatment(3, "一般治疗展示"),
+    SurgeryTreatment(4, "手术治疗展示"),
+    Drug(5, "药品说明书"),
+    AdverseReaction(6, "不良反应");
+
+    @Setter
+    private Integer key;
+
+    @Setter
+    private String name;
+
+    IntroducePositionEnum(Integer key, String name) {
+        this.key = key;
+        this.name = name;
+    }
+
+    public static IntroducePositionEnum getEnum(Integer key) {
+        for (IntroducePositionEnum item : IntroducePositionEnum.values()) {
+            if (item.key == key) {
+                return item;
+            }
+        }
+        return null;
+    }
+
+    public static String getName(Integer key) {
+        IntroducePositionEnum item = getEnum(key);
+        return item != null ? item.name : null;
+    }
+
+    @Override
+    public int getKey() {
+        return key;
+    }
+
+    @Override
+    public String getName() {
+        return name;
+    }
+}

aipt-service/src/main/java/com/diagbot/facade/ConceptDetailFacade.java

@@ -60,4 +60,23 @@ public class ConceptDetailFacade extends ConceptDetailServiceImpl {
         conceptIntroduceDTO.setDetails(conceptDetailDTOList);
         return conceptIntroduceDTO;
     }
+
+    /**
+     * 获取静态知识明细
+     * @param conceptIntroduceVO
+     * @return
+     */
+    public List<ConceptDetail> getConceptDetailList(ConceptIntroduceVO conceptIntroduceVO) {
+        //验证存在并且获取概念基本信息
+        Concept concept = conceptFacade.exist(conceptIntroduceVO);
+
+        //获取概念提示信息
+        QueryWrapper<ConceptDetail> conceptDetailQueryWrapper = new QueryWrapper<>();
+        conceptDetailQueryWrapper.eq("is_deleted", IsDeleteEnum.N.getKey())
+                .eq("concept_id", concept.getId())
+                .apply("find_in_set({0},position)", conceptIntroduceVO.getPosition())
+                .orderByAsc("order_no");
+        List<ConceptDetail> conceptDetailList = this.list(conceptDetailQueryWrapper);
+        return conceptDetailList;
+    }
 }

aipt-service/src/main/java/com/diagbot/facade/PushFacade.java

@@ -1,24 +1,38 @@
 package com.diagbot.facade;
 
+import com.alibaba.fastjson.JSONObject;
 import com.diagbot.client.TranServiceClient;
+import com.diagbot.client.bean.Feature;
 import com.diagbot.client.bean.FeatureRate;
+import com.diagbot.client.bean.GdbResponse;
 import com.diagbot.client.bean.ResponseData;
+import com.diagbot.client.bean.SearchData;
 import com.diagbot.dto.ConceptPushDTO;
 import com.diagbot.dto.PushDTO;
+import com.diagbot.dto.RespDTO;
 import com.diagbot.entity.Concept;
 import com.diagbot.enums.ConceptTypeEnum;
 import com.diagbot.enums.FeatureTypeEnum;
 import com.diagbot.enums.LexiconTypeEnum;
+import com.diagbot.exception.CommonErrorCode;
+import com.diagbot.exception.CommonException;
+import com.diagbot.util.DateUtil;
+import com.diagbot.util.FastJsonUtils;
 import com.diagbot.util.ListUtil;
 import com.diagbot.util.ParamConvertUtil;
+import com.diagbot.util.RespDTOUtil;
+import com.diagbot.util.StringUtil;
 import com.diagbot.vo.SearchVo;
 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.HashMap;
 import java.util.HashSet;
+import java.util.LinkedHashMap;
 import java.util.List;
+import java.util.Map;
 import java.util.Set;
 import java.util.stream.Collectors;
 
@@ -45,13 +59,30 @@ public class PushFacade {
     public void pushInner(SearchVo searchVo) {
         PushDTO pushDTO = new PushDTO();
         ResponseData data = clinicalFacade.processClinicalData(searchVo);
-        //大数据返回内容
-        List<FeatureRate> dis = data.getDis();
 
         String featureType = searchVo.getFeatureType();
         String[] featureTypes = featureType.split(",|，");
         Set<String> featureTypeSet = new HashSet(Arrays.asList(featureTypes));
 
+        //诊断
+        List<FeatureRate> dis = data.getDis();
+        //推送科室
+        String deptName = "";
+        if (ListUtil.isNotEmpty(dis)) {
+            for (FeatureRate featureRate : dis) {
+                if (StringUtil.isNotBlank(featureRate.getExtraProperty())) {
+                    deptName = featureRate.getExtraProperty();
+                    break;
+                }
+            }
+        }
+        //没有推送信息时，默认取全科模板
+        if (StringUtil.isBlank(deptName)) {
+            deptName = "全科";
+        }
+        pushDTO.setDeptName(deptName);
+
+
         //症状 概念列表
         if (featureTypeSet.contains(String.valueOf(FeatureTypeEnum.Feature_Type_Symptom.getKey()))) {
             List<FeatureRate> symptom = data.getSymptom();
@@ -74,6 +105,17 @@ public class PushFacade {
                 }
             }
         }
+        //化验 概念列表-公表项
+        if (featureTypeSet.contains(String.valueOf(FeatureTypeEnum.Feature_Type_Lis.getKey()))) {
+            List<FeatureRate> lis = data.getLabs();
+            if (ListUtil.isNotEmpty(lis)) {
+                List<String> nameList = lis.stream().map(featureRate -> featureRate.getFeatureName()).collect(Collectors.toList());
+                List<Concept> concepts = conceptFacade.getListByNamesAndType(nameList, LexiconTypeEnum.LIS_TABLES.getKey());
+                if (ListUtil.isNotEmpty(concepts)) {
+                    pushDTO.setLab(getConceptDTOList(concepts, LexiconTypeEnum.LIS_TABLES.getKey()));
+                }
+            }
+        }
         //辅检 概念列表
         if (featureTypeSet.contains(String.valueOf(FeatureTypeEnum.Feature_Type_Pacs.getKey()))) {
             List<FeatureRate> pacs = data.getPacs();
@@ -85,6 +127,73 @@ public class PushFacade {
                 }
             }
         }
+        //诊断 map
+        if(featureTypeSet.contains(String.valueOf(FeatureTypeEnum.Feature_Type_Disease.getKey()))){
+            if (ListUtil.isNotEmpty(dis)) {
+                List<String> nameList = dis.stream().map(featureRate -> featureRate.getFeatureName()).collect(Collectors.toList());
+                Map<String, List<ConceptPushDTO>> disMapDTO = new LinkedHashMap<>();
+                Map<String, List<FeatureRate>> disFeatureMap = new LinkedHashMap<>();
+                //警惕
+                Map<String, String> highRiskMap = new HashMap<>();
+                highRiskMap.put("disease", String.join(",", nameList));
+                SearchData searchData = new SearchData();
+                searchData.setDiag(String.join(",", nameList));
+                GdbResponse graphRes = clinicalFacade.highRiskPageData(searchVo);
+                if (graphRes!=null) {
+                    Map<String, String> graphResult = graphRes.getResult();
+                    if (graphResult.size() > 0) {
+                        List<String> hrNameList = Lists.newLinkedList();
+                        for (Map.Entry<String, String> entry : graphResult.entrySet()) {
+                            if (entry.getValue().equals("1")) {
+                                hrNameList.add(entry.getKey());
+                            }
+                        }
+                        List<Concept> concepts = conceptFacade.getListByNamesAndType(hrNameList, ParamConvertUtil.conceptConvert2Lib(ConceptTypeEnum.Disease.getKey()));
+                        if (ListUtil.isNotEmpty(concepts)) {
+                            List<ConceptPushDTO> hrDisDTO = getConceptDTOList(concepts, LexiconTypeEnum.PACS_ITEMS.getKey());
+                            disMapDTO.put("警惕", hrDisDTO);
+                        }
+                    }
+                }
+                //诊断分类
+                for (FeatureRate featureRate : dis) {
+                    if (StringUtil.isBlank(featureRate.getDesc())) {
+                        featureRate.setDesc("{\"可能诊断\":\"\"}");
+                    }
+                    Map<String, Object> descMap = FastJsonUtils.getJsonToMap(featureRate.getDesc());
+                    for (String disClass : descMap.keySet()) {
+                        List<FeatureRate> featureRateList = Lists.newLinkedList();
+                        if (disFeatureMap.get(disClass) != null) {
+                            featureRateList = disFeatureMap.get(disClass);
+                        }
+                        featureRateList.add(featureRate);
+                        disFeatureMap.put(disClass, featureRateList);
+                    }
+                }
+                for (Map.Entry<String, List<FeatureRate>> entry : disFeatureMap.entrySet()) {
+                    List<String> nameListByDisClass = entry.getValue().stream().map(featureRate -> featureRate.getFeatureName()).collect(Collectors.toList());
+                    List<Concept> concepts = conceptFacade.getListByNamesAndType(nameListByDisClass, ParamConvertUtil.conceptConvert2Lib(ConceptTypeEnum.Disease.getKey()));
+                    if (ListUtil.isNotEmpty(concepts)) {
+                        List<ConceptPushDTO> disDTO = getConceptDTOList(concepts, LexiconTypeEnum.PACS_ITEMS.getKey());
+                        disMapDTO.put(entry.getKey(), disDTO);
+                    }
+                }
+                pushDTO.setDis(disMapDTO);
+            }
+
+        }
+
+    }
+
+    public Map<String, Object>  getTreatment(SearchVo searchVo) {
+        Map<String, Object> treatDTO = new LinkedHashMap<>();
+        ResponseData data = clinicalFacade.processClinicalData(searchVo);
+        Map<String, JSONObject> treat = data.getTreat();
+        if (StringUtil.isBlank(searchVo.getDiseaseName())) {
+            throw new CommonException(CommonErrorCode.PARAM_ERROR, "请输入需获取治疗方案的诊断名称");
+        }
+        //Map<String, Object> treatmentMap = treatmentFacade.getTreatment(treat, pushVO.getDiseaseId(), pushVO.getPatientId());
+        return treatDTO;
     }
 
     /**

aipt-service/src/main/java/com/diagbot/facade/TreatmentFacade.java

@@ -0,0 +1,91 @@
+package com.diagbot.facade;
+
+import com.alibaba.fastjson.JSONObject;
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.diagbot.dto.ConceptDetailDTO;
+import com.diagbot.entity.Concept;
+import com.diagbot.entity.ConceptDetail;
+import com.diagbot.enums.IntroducePositionEnum;
+import com.diagbot.enums.LexiconTypeEnum;
+import com.diagbot.exception.CommonErrorCode;
+import com.diagbot.exception.CommonException;
+import com.diagbot.util.BeanUtil;
+import com.diagbot.util.ListUtil;
+import com.diagbot.vo.ConceptBaseVO;
+import com.diagbot.vo.ConceptIntroduceVO;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * @Description:治疗方案业务处理
+ * @Author:zhaops
+ * @time: 2019/5/8 17:16
+ */
+@Component
+public class TreatmentFacade {
+    @Autowired
+    ConceptFacade conceptFacade;
+    @Autowired
+    ConceptDetailFacade conceptDetailFacade;
+
+
+    /**
+     * 获取治疗方案
+     *
+     * @param
+     * @return
+     */
+    public Map<String, Object> getTreatment(Map<String, JSONObject> treatmentMap, String diseaseName) {
+        Map<String, Object> retMap = new LinkedHashMap<>();
+        QueryWrapper<Concept> conceptQueryWrapper=new QueryWrapper<>();
+        ConceptBaseVO conceptBaseVO=new ConceptBaseVO();
+        conceptBaseVO.setName(diseaseName);
+        conceptBaseVO.setLibType(LexiconTypeEnum.DIAGNOSIS.getKey());
+        Concept disease =conceptFacade.exist(conceptBaseVO);
+        if (disease == null) {
+            throw new CommonException(CommonErrorCode.NOT_EXISTS, "诊断不存在");
+        }
+        if (treatmentMap==null||treatmentMap.size() == 0) {
+            throw new CommonException(CommonErrorCode.NOT_EXISTS, "未找到治疗方案");
+        }
+        if (!treatmentMap.containsKey(diseaseName)) {
+            throw new CommonException(CommonErrorCode.SERVER_IS_ERROR, "诊断名不在诊断列表中");
+        }
+
+        //一般治疗
+        ConceptIntroduceVO conceptIntroduceVO=new ConceptIntroduceVO();
+        conceptIntroduceVO.setName(diseaseName);
+        conceptIntroduceVO.setLibType(LexiconTypeEnum.DIAGNOSIS.getKey());
+        conceptIntroduceVO.setPosition(IntroducePositionEnum.CommonTreatment.getKey());
+        List<ConceptDetail> commonTreatmentDetailList=conceptDetailFacade.getConceptDetailList(conceptIntroduceVO);
+        ConceptDetailDTO commonDetailDTO=new ConceptDetailDTO();
+        if (ListUtil.isNotEmpty(commonTreatmentDetailList)) {
+            BeanUtil.copyProperties(commonTreatmentDetailList.get(0), commonDetailDTO);
+        }
+        retMap.put("commonTreatment", commonDetailDTO);
+
+        //手术治疗
+        conceptIntroduceVO.setPosition(IntroducePositionEnum.SurgeryTreatment.getKey());
+        List<ConceptDetail> surgeryTreatmentDetailList = conceptDetailFacade.getConceptDetailList(conceptIntroduceVO);
+        ConceptDetailDTO surgeryDetailDTO = new ConceptDetailDTO();
+        if (ListUtil.isNotEmpty(surgeryTreatmentDetailList)) {
+            BeanUtil.copyProperties(surgeryTreatmentDetailList.get(0), surgeryDetailDTO);
+        }
+        retMap.put("surgeryTreatment", surgeryDetailDTO);
+
+
+        //获取知识图谱治疗方案
+        JSONObject treatmentJson = treatmentMap.get(diseaseName);
+        if (treatmentJson == null || treatmentJson.isEmpty()) {
+            return retMap;
+        }
+
+
+        return retMap;
+    }
+
+}

aipt-service/src/main/java/com/diagbot/util/ParamConvertUtil.java

@@ -2,6 +2,7 @@ package com.diagbot.util;
 
 import com.diagbot.enums.ConceptTypeEnum;
 import com.diagbot.enums.LexiconTypeEnum;
+import org.apache.ibatis.javassist.compiler.Lex;
 
 /**
  * @Description:参数转换
@@ -32,6 +33,9 @@ public class ParamConvertUtil {
             case Lis:
                 libType = LexiconTypeEnum.LIS_PACKAGE.getKey();
                 break;
+            case LIS_TABLES:
+                libType = LexiconTypeEnum.LIS_TABLES.getKey();
+                break;
             case Pacs:
                 libType = LexiconTypeEnum.PACS_ITEMS.getKey();
                 break;
@@ -83,6 +87,9 @@ public class ParamConvertUtil {
             case LIS_PACKAGE:
                 type = ConceptTypeEnum.Lis.getKey();
                 break;
+            case LIS_TABLES:
+                type = ConceptTypeEnum.LIS_TABLES.getKey();
+                break;
             case PACS_ITEMS:
                 type = ConceptTypeEnum.Pacs.getKey();
                 break;