治疗方案

aipt-service/src/main/java/com/diagbot/client/bean/AdverseReaction.java

@@ -0,0 +1,22 @@
+package com.diagbot.client.bean;
+
+import lombok.Getter;
+import lombok.Setter;
+
+import java.util.List;
+
+/**
+ * @Description: 不良反应
+ * @Author:zhaops
+ * @time: 2019/3/14 11:14
+ */
+@Getter
+@Setter
+public class AdverseReaction {
+    private Long conceptId;
+    private String name;  //名称
+    private Integer libType;
+    private String showInfo = "0";//是否显示提示信息
+    private Integer controlType; //控件类型
+    private List<AdverseReactionDetail> details;
+}

aipt-service/src/main/java/com/diagbot/client/bean/AdverseReactionDetail.java

@@ -0,0 +1,16 @@
+package com.diagbot.client.bean;
+
+import lombok.Getter;
+import lombok.Setter;
+
+/**
+ * @Description: 不良反应明细
+ * @Author:zhaops
+ * @time: 2019/3/14 11:19
+ */
+@Getter
+@Setter
+public class AdverseReactionDetail {
+    private String name;
+    private Integer value; //是否选中：0-未选中，1-选中
+}

aipt-service/src/main/java/com/diagbot/client/bean/Medicition.java

@@ -0,0 +1,26 @@
+package com.diagbot.client.bean;
+
+import lombok.Getter;
+import lombok.Setter;
+
+/**
+ * @Description:药品信息
+ * @Author:zhaops
+ * @time: 2018/12/17 13:27
+ */
+@Getter
+@Setter
+public class Medicition {
+    private Long conceptId;
+    private String medicitionName;
+    /**
+     * 1-显示，0-隐藏
+     */
+    private String isShow;
+    private String forbidden;
+    /**
+     * 1-有提示信息，0-没有提示信息
+     */
+    private String showInfo = "0";
+    private String rate;
+}

aipt-service/src/main/java/com/diagbot/client/bean/MedicitionClass.java

@@ -0,0 +1,25 @@
+package com.diagbot.client.bean;
+
+import lombok.Getter;
+import lombok.Setter;
+
+import java.util.LinkedList;
+
+/**
+ * @Description:药品分类
+ * @Author:zhaops
+ * @time: 2018/12/17 13:32
+ */
+@Getter
+@Setter
+public class MedicitionClass {
+    private String showInfo = "0";
+    private String drugsForbidden;
+    private Long bigdrugsConceptId;//药品分类概念id-大类
+    private String bigdrugsName;//药类名
+    private Integer bigdrgusLibType;
+    private Long subdrugsConceptId;//药品分类概念id-小类
+    private String subdrugsName;//药类名-小类
+    private Integer subdrugsLibType;
+    private LinkedList<Medicition> medicitionsList;
+}

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

@@ -86,8 +86,9 @@ public class ClinicalFacade {
                 lisres.setOtherValue(lisres.getDetailName() + Otherval);
             } else {
                 Otherval = (Otherval.trim().length() > 0) ? Otherval.trim() + "\n" : "";
-
-                if (lisres.getMaxValue() != null && lisres.getValue() > lisres.getMaxValue()) {
+                if (lisres.getValue() == null) {
+                    continue;
+                } else if (lisres.getMaxValue() != null && lisres.getValue() > lisres.getMaxValue()) {
                     lisres.setOtherValue(Otherval + lisres.getDetailName() + up);
                 } else if (lisres.getMinValue() != null && lisres.getValue() < lisres.getMinValue()) {
                     lisres.setOtherValue(Otherval + lisres.getDetailName() + down);

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

@@ -10,14 +10,19 @@ import com.diagbot.exception.CommonErrorCode;
 import com.diagbot.exception.CommonException;
 import com.diagbot.service.impl.ConceptDetailServiceImpl;
 import com.diagbot.util.BeanUtil;
+import com.diagbot.util.EntityUtil;
 import com.diagbot.util.ListUtil;
 import com.diagbot.util.ParamConvertUtil;
 import com.diagbot.util.StringUtil;
+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;
+import java.util.stream.Collectors;
 
 /**
  * @Description:
@@ -63,6 +68,7 @@ public class ConceptDetailFacade extends ConceptDetailServiceImpl {
 
     /**
      * 获取静态知识明细
+     *
      * @param conceptIntroduceVO
      * @return
      */
@@ -79,4 +85,52 @@ public class ConceptDetailFacade extends ConceptDetailServiceImpl {
         List<ConceptDetail> conceptDetailList = this.list(conceptDetailQueryWrapper);
         return conceptDetailList;
     }
+
+    /**
+     * 是否存在提示信息
+     *
+     * @param conceptBaseVO
+     * @return
+     */
+    public Boolean exist(ConceptBaseVO conceptBaseVO) {
+        //验证存在并且获取概念基本信息
+        Concept concept = conceptFacade.exist(conceptBaseVO);
+        QueryWrapper<ConceptDetail> conceptDetailQueryWrapper = new QueryWrapper<>();
+        conceptDetailQueryWrapper.eq("is_deleted", IsDeleteEnum.N.getKey())
+                .eq("concept_id", concept.getId());
+        List<ConceptDetail> conceptDetailList = this.list(conceptDetailQueryWrapper);
+        if (ListUtil.isNotEmpty(conceptDetailList)) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    /**
+     * 是否存在提示信息-列表
+     *
+     * @param nameList
+     * @param libType
+     * @return
+     */
+    public Map<String, Concept> existList(List<String> nameList, Integer libType) {
+        List<Concept> concepts = conceptFacade.getListByNamesAndType(nameList, libType);
+        Map<String, Concept> retMap = new LinkedHashMap<>();
+        if (ListUtil.isNotEmpty(concepts)) {
+            List<Long> conceptIds = concepts.stream().map(concept -> concept.getId()).collect(Collectors.toList());
+            QueryWrapper<ConceptDetail> conceptDetailQueryWrapper = new QueryWrapper<>();
+            conceptDetailQueryWrapper.eq("is_deleted", IsDeleteEnum.N.getKey())
+                    .in("concept_id", conceptIds);
+            List<ConceptDetail> conceptDetailList = this.list(conceptDetailQueryWrapper);
+            if (ListUtil.isNotEmpty(conceptDetailList)) {
+                Map<Long, ConceptDetail> conceptDetailMap = EntityUtil.makeEntityMap(conceptDetailList, "conceptId");
+                for (Concept concept : concepts) {
+                    if (conceptDetailMap.containsKey(concept.getId()) && conceptDetailMap.get(concept.getId()) != null) {
+                        retMap.put(concept.getLibName(), concept);
+                    }
+                }
+            }
+        }
+        return retMap;
+    }
 }

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

@@ -2,25 +2,20 @@ 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;
@@ -48,6 +43,8 @@ public class PushFacade {
     @Autowired
     private ConceptFacade conceptFacade;
     @Autowired
+    private TreatmentFacade treatmentFacade;
+    @Autowired
     private TranServiceClient tranServiceClient;
 
     /**
@@ -88,9 +85,8 @@ public class PushFacade {
             List<FeatureRate> symptom = data.getSymptom();
             if (ListUtil.isNotEmpty(symptom)) {
                 List<String> nameList = symptom.stream().map(featureRate -> featureRate.getFeatureName()).collect(Collectors.toList());
-                List<Concept> concepts = conceptFacade.getListByNamesAndType(nameList, ParamConvertUtil.conceptConvert2Lib(ConceptTypeEnum.Symptom.getKey()));
-                if (ListUtil.isNotEmpty(concepts)) {
-                    pushDTO.setSymptom(getConceptDTOList(concepts, LexiconTypeEnum.SYMPTOM.getKey()));
+                if (ListUtil.isNotEmpty(nameList)) {
+                    pushDTO.setSymptom(getConceptDTOList(nameList, LexiconTypeEnum.SYMPTOM.getKey()));
                 }
             }
         }
@@ -99,9 +95,8 @@ public class PushFacade {
             List<FeatureRate> vital = data.getVitals();
             if (ListUtil.isNotEmpty(vital)) {
                 List<String> nameList = vital.stream().map(featureRate -> featureRate.getFeatureName()).collect(Collectors.toList());
-                List<Concept> concepts = conceptFacade.getListByNamesAndType(nameList, ParamConvertUtil.conceptConvert2Lib(ConceptTypeEnum.Vital.getKey()));
-                if (ListUtil.isNotEmpty(concepts)) {
-                    pushDTO.setVital(getConceptDTOList(concepts, LexiconTypeEnum.VITAL_INDEX.getKey()));
+                if (ListUtil.isNotEmpty(nameList)) {
+                    pushDTO.setVital(getConceptDTOList(nameList, LexiconTypeEnum.VITAL_INDEX.getKey()));
                 }
             }
         }
@@ -110,9 +105,8 @@ public class PushFacade {
             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 (ListUtil.isNotEmpty(nameList)) {
+                    pushDTO.setLab(getConceptDTOList(nameList, LexiconTypeEnum.LIS_TABLES.getKey()));
                 }
             }
         }
@@ -121,14 +115,13 @@ public class PushFacade {
             List<FeatureRate> pacs = data.getPacs();
             if (ListUtil.isNotEmpty(pacs)) {
                 List<String> nameList = pacs.stream().map(featureRate -> featureRate.getFeatureName()).collect(Collectors.toList());
-                List<Concept> concepts = conceptFacade.getListByNamesAndType(nameList, ParamConvertUtil.conceptConvert2Lib(ConceptTypeEnum.Pacs.getKey()));
-                if (ListUtil.isNotEmpty(concepts)) {
-                    pushDTO.setPacs(getConceptDTOList(concepts, LexiconTypeEnum.PACS_ITEMS.getKey()));
+                if (ListUtil.isNotEmpty(nameList)) {
+                    pushDTO.setPacs(getConceptDTOList(nameList, LexiconTypeEnum.PACS_ITEMS.getKey()));
                 }
             }
         }
         //诊断 map
-        if(featureTypeSet.contains(String.valueOf(FeatureTypeEnum.Feature_Type_Disease.getKey()))){
+        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<>();
@@ -139,7 +132,7 @@ public class PushFacade {
                 SearchData searchData = new SearchData();
                 searchData.setDiag(String.join(",", nameList));
                 GdbResponse graphRes = clinicalFacade.highRiskPageData(searchVo);
-                if (graphRes!=null) {
+                if (graphRes != null) {
                     Map<String, String> graphResult = graphRes.getResult();
                     if (graphResult.size() > 0) {
                         List<String> hrNameList = Lists.newLinkedList();
@@ -148,9 +141,8 @@ public class PushFacade {
                                 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());
+                        if (ListUtil.isNotEmpty(hrNameList)) {
+                            List<ConceptPushDTO> hrDisDTO = getConceptDTOList(hrNameList, LexiconTypeEnum.DIAGNOSIS.getKey());
                             disMapDTO.put("警惕", hrDisDTO);
                         }
                     }
@@ -172,38 +164,42 @@ public class PushFacade {
                 }
                 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());
+                    if (ListUtil.isNotEmpty(nameListByDisClass)) {
+                        List<ConceptPushDTO> disDTO = getConceptDTOList(nameListByDisClass, LexiconTypeEnum.DIAGNOSIS.getKey());
                         disMapDTO.put(entry.getKey(), disDTO);
                     }
                 }
                 pushDTO.setDis(disMapDTO);
             }
-
         }
-
     }
 
-    public Map<String, Object>  getTreatment(SearchVo searchVo) {
+    /**
+     * 获取治疗方案
+     *
+     * @param searchVo
+     * @return
+     */
+    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;
+        Map<String, Object> treatmentMap = treatmentFacade.getTreatment(treat, searchVo.getDiseaseName(), searchVo.getDisType());
+        return treatmentMap;
     }
 
     /**
-     * 概念转成返回格式
+     * 推理返回概念
      *
-     * @param concepts
+     * @param nameList
      * @param libType
      * @return
      */
-    public List<ConceptPushDTO> getConceptDTOList(List<Concept> concepts, Integer libType) {
+    public List<ConceptPushDTO> getConceptDTOList(List<String> nameList, Integer libType) {
+        List<Concept> concepts = conceptFacade.getListByNamesAndType(nameList, libType);
         List<ConceptPushDTO> conceptDTOS = Lists.newLinkedList();
         if (ListUtil.isNotEmpty(concepts)) {
             for (Concept concept : concepts) {

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

@@ -0,0 +1,13 @@
+package com.diagbot.facade;
+
+import org.springframework.stereotype.Component;
+
+/**
+ * @Description:
+ * @Author:zhaops
+ * @time: 2019/5/9 13:39
+ */
+@Component
+public class RelationFacade {
+
+}

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

@@ -2,14 +2,24 @@ package com.diagbot.facade;
 
 import com.alibaba.fastjson.JSONObject;
 import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.diagbot.client.bean.AdverseReaction;
+import com.diagbot.client.bean.Medicition;
+import com.diagbot.client.bean.MedicitionClass;
 import com.diagbot.dto.ConceptDetailDTO;
+import com.diagbot.dto.ConceptRes;
 import com.diagbot.entity.Concept;
 import com.diagbot.entity.ConceptDetail;
+import com.diagbot.entity.wrapper.ConceptWrapper;
+import com.diagbot.enums.ConceptTypeEnum;
+import com.diagbot.enums.DisTypeEnum;
 import com.diagbot.enums.IntroducePositionEnum;
+import com.diagbot.enums.LexiconRSTypeEnum;
 import com.diagbot.enums.LexiconTypeEnum;
 import com.diagbot.exception.CommonErrorCode;
 import com.diagbot.exception.CommonException;
 import com.diagbot.util.BeanUtil;
+import com.diagbot.util.EntityUtil;
+import com.diagbot.util.FastJsonUtils;
 import com.diagbot.util.ListUtil;
 import com.diagbot.vo.ConceptBaseVO;
 import com.diagbot.vo.ConceptIntroduceVO;
@@ -17,8 +27,10 @@ import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;
 
 import java.util.LinkedHashMap;
+import java.util.LinkedList;
 import java.util.List;
 import java.util.Map;
+import java.util.stream.Collectors;
 
 /**
  * @Description:治疗方案业务处理
@@ -32,24 +44,23 @@ public class TreatmentFacade {
     @Autowired
     ConceptDetailFacade conceptDetailFacade;
 
-
     /**
      * 获取治疗方案
      *
      * @param
      * @return
      */
-    public Map<String, Object> getTreatment(Map<String, JSONObject> treatmentMap, String diseaseName) {
+    public Map<String, Object> getTreatment(Map<String, JSONObject> treatmentMap, String diseaseName, Integer disType) {
         Map<String, Object> retMap = new LinkedHashMap<>();
-        QueryWrapper<Concept> conceptQueryWrapper=new QueryWrapper<>();
-        ConceptBaseVO conceptBaseVO=new ConceptBaseVO();
+        QueryWrapper<Concept> conceptQueryWrapper = new QueryWrapper<>();
+        ConceptBaseVO conceptBaseVO = new ConceptBaseVO();
         conceptBaseVO.setName(diseaseName);
         conceptBaseVO.setLibType(LexiconTypeEnum.DIAGNOSIS.getKey());
-        Concept disease =conceptFacade.exist(conceptBaseVO);
+        Concept disease = conceptFacade.exist(conceptBaseVO);
         if (disease == null) {
             throw new CommonException(CommonErrorCode.NOT_EXISTS, "诊断不存在");
         }
-        if (treatmentMap==null||treatmentMap.size() == 0) {
+        if (treatmentMap == null || treatmentMap.size() == 0) {
             throw new CommonException(CommonErrorCode.NOT_EXISTS, "未找到治疗方案");
         }
         if (!treatmentMap.containsKey(diseaseName)) {
@@ -57,12 +68,12 @@ public class TreatmentFacade {
         }
 
         //一般治疗
-        ConceptIntroduceVO conceptIntroduceVO=new ConceptIntroduceVO();
+        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();
+        List<ConceptDetail> commonTreatmentDetailList = conceptDetailFacade.getConceptDetailList(conceptIntroduceVO);
+        ConceptDetailDTO commonDetailDTO = new ConceptDetailDTO();
         if (ListUtil.isNotEmpty(commonTreatmentDetailList)) {
             BeanUtil.copyProperties(commonTreatmentDetailList.get(0), commonDetailDTO);
         }
@@ -84,8 +95,84 @@ public class TreatmentFacade {
             return retMap;
         }
 
+        List<MedicitionClass> drugsList = FastJsonUtils.getJsonToListByKey(treatmentJson.toString(), "treatment", MedicitionClass.class);
+        List<String> cateBigNameList = drugsList.stream().map(drugs -> drugs.getBigdrugsName()).collect(Collectors.toList());
+        List<Concept> cateBigConceptList = conceptFacade.getListByNamesAndType(cateBigNameList, LexiconTypeEnum.DRUG_CATEGORY_BIG.getKey());
+        Map<String, Concept> cateBigConceptMap = EntityUtil.makeEntityMap(cateBigConceptList, "libName");
+        List<String> cateSmallNameList = drugsList.stream().map(drugs -> drugs.getSubdrugsName()).collect(Collectors.toList());
+        List<Concept> cateSmallConceptList = conceptFacade.getListByNamesAndType(cateSmallNameList, LexiconTypeEnum.DRUG_CATEGORY_SMALL.getKey());
+        Map<String, Concept> cateSmallConceptMap = EntityUtil.makeEntityMap(cateSmallConceptList, "libName");
+
+        for (MedicitionClass medicitionClass : drugsList) {
+            Concept cateBigConcept = cateBigConceptMap.get(medicitionClass.getBigdrugsName());
+            medicitionClass.setBigdrugsConceptId(cateBigConcept.getId());
+            medicitionClass.setBigdrgusLibType(ConceptTypeEnum.Drug_Category_Big.getKey());
+            Concept cateSmallConcept = cateSmallConceptMap.get(medicitionClass.getSubdrugsName());
+            medicitionClass.setSubdrugsConceptId(cateSmallConcept.getId());
+            medicitionClass.setSubdrugsLibType(ConceptTypeEnum.Drug_Category_Small.getKey());
+
+            if (cateBigConcept != null) {
+                conceptBaseVO.setLibType(LexiconTypeEnum.DRUG_CATEGORY_BIG.getKey());
+                conceptBaseVO.setName(cateBigConcept.getLibName());
+                if (conceptDetailFacade.exist(conceptBaseVO)) {
+                    medicitionClass.setShowInfo("1");
+                }
+            }
+            LinkedList<Medicition> medicitionList = medicitionClass.getMedicitionsList();
+            List<String> drugNameList = medicitionList.stream().map(medicition -> medicition.getMedicitionName()).collect(Collectors.toList());
+            List<Concept> drugList = conceptFacade.getListByNamesAndType(drugNameList, LexiconTypeEnum.DRUGS.getKey());
+            Map<String, Concept> drugMap = EntityUtil.makeEntityMap(drugList, "libName");
+            Map<String, Concept> drugDetailMap = conceptDetailFacade.existList(drugNameList, LexiconTypeEnum.DRUGS.getKey());
+            for (Medicition medicition : medicitionList) {
+                Concept drugConcept = drugMap.get(medicition.getMedicitionName());
+                if (drugConcept != null) {
+                    medicition.setConceptId(drugConcept.getId());
+                }
+                if (drugDetailMap != null && drugDetailMap.containsKey(medicition.getMedicitionName())) {
+                    medicition.setShowInfo("1");
+                }
+            }
+            medicitionClass.setMedicitionsList(medicitionList);
+        }
+        retMap.put("treatment", drugsList);
 
+        //判断是否慢病，慢病增加回访时间，上次用药，不良反应
+        if (disType.equals(DisTypeEnum.CHRONIC.getKey())) {
+            //验证是否慢病
+            conceptBaseVO.setName("慢病");
+            conceptBaseVO.setLibType(LexiconTypeEnum.TYPES_OF_DISEASE.getKey());
+            Concept chronicConcept = conceptFacade.exist(conceptBaseVO);
+            ConceptWrapper conceptWrapper = new ConceptWrapper();
+            conceptWrapper.setStartId(disease.getId());
+            conceptWrapper.setStartName(diseaseName);
+            conceptWrapper.setStartType(LexiconTypeEnum.DIAGNOSIS.getKey());
+            conceptWrapper.setEndId(chronicConcept.getId());
+            conceptWrapper.setEndName(chronicConcept.getLibName());
+            conceptWrapper.setEndType(LexiconTypeEnum.TYPES_OF_DISEASE.getKey());
+            conceptWrapper.setRelationType(LexiconRSTypeEnum.BELONG_TO.getKey());
+            List<ConceptRes> conceptResList = conceptFacade.getConcept(conceptWrapper);
+            Boolean isChronic = ListUtil.isNotEmpty(conceptResList);
+            if (isChronic) {
+                //慢病，增加回访时间，暂时前端写死， 以后由只是图谱返回
+                retMap.put("followUp", null);
+                //上次用药-icss层处理
+                retMap.put("drugHistory", null);
+                //不良反应
+                List<AdverseReaction> adverseReactionList = FastJsonUtils.getJsonToListByKey(treatmentJson.toString(), "adverseEvent", AdverseReaction.class);
+                List<String> adNameList = adverseReactionList.stream().map(adverseReaction -> adverseReaction.getName()).collect(Collectors.toList());
+                List<Concept> adConceptList = conceptFacade.getListByNamesAndType(adNameList, LexiconTypeEnum.SIDE_EFFECTS.getKey());
+                Map<String, Concept> adConceptMap = EntityUtil.makeEntityMap(adConceptList, "libName");
+                Map<String, Concept> adConceptDetailMap = conceptDetailFacade.existList(adNameList, LexiconTypeEnum.SIDE_EFFECTS.getKey());
+                for (AdverseReaction adverseReaction : adverseReactionList) {
+                    Concept adConcept = adConceptMap.get(adverseReaction.getName());
+                    adverseReaction.setConceptId(adConcept.getId());
+                    if (adConceptDetailMap != null && adConceptDetailMap.containsKey(adverseReaction.getName())) {
+                        adverseReaction.setShowInfo("1");
+                    }
+                }
+                retMap.put("adverseReactions", adverseReactionList);
+            }
+        }
         return retMap;
     }
-
-}
+}