治疗方案采用异步并发处理

aipt-service/src/main/java/com/diagbot/aggregate/TreatmentAggregate.java

@@ -0,0 +1,199 @@
+package com.diagbot.aggregate;
+
+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.entity.Concept;
+import com.diagbot.entity.ConceptDetail;
+import com.diagbot.enums.ConceptTypeEnum;
+import com.diagbot.enums.LexiconTypeEnum;
+import com.diagbot.enums.PositionTypeEnum;
+import com.diagbot.util.BeanUtil;
+import com.diagbot.util.ListUtil;
+import io.github.lvyahui8.spring.annotation.DataConsumer;
+import io.github.lvyahui8.spring.annotation.DataProvider;
+import io.github.lvyahui8.spring.annotation.InvokeParameter;
+import org.springframework.stereotype.Component;
+
+import java.util.Arrays;
+import java.util.LinkedHashMap;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * @Description:
+ * @Author:zhaops
+ * @time: 2019/10/24 10:01
+ */
+@Component
+public class TreatmentAggregate {
+
+    @DataProvider("setTreatmentAll")
+    public Map<String, Object> setTreatmentAll(@InvokeParameter("treatmentMap") Map<String, Object> treatmentMap,
+                                               @DataConsumer("setCommonTreatment") ConceptDetailDTO commonTreatment,
+                                               @DataConsumer("setSurgeryTreatment") ConceptDetailDTO surgeryTreatment,
+                                               @DataConsumer("setDrugs") List<MedicitionClass> drugsList,
+                                               @DataConsumer("setAdverseReactions") List<AdverseReaction> adverseReactionList) {
+        if (treatmentMap == null) {
+            treatmentMap = new LinkedHashMap<>();
+        }
+        treatmentMap.put("commonTreatment", commonTreatment);
+        treatmentMap.put("surgeryTreatment", surgeryTreatment);
+        treatmentMap.put("treatment", drugsList);
+        treatmentMap.put("adverseReactions", adverseReactionList);
+
+        return treatmentMap;
+    }
+
+    @DataProvider("setCommonTreatment")
+    public ConceptDetailDTO setCommonTreatment(@InvokeParameter("diseaseName") String diseaseName,
+                                               @InvokeParameter("hasConDetailMap") Map<String, Map<Long, List<ConceptDetail>>> hasConDetailMap) {
+        ConceptDetailDTO conceptDetailDTO = null;
+        if (hasConDetailMap != null && hasConDetailMap.get(diseaseName) != null
+                && ListUtil.isNotEmpty(hasConDetailMap
+                .get(diseaseName)
+                .get(Long.valueOf(LexiconTypeEnum.DIAGNOSIS.getKey())))) {
+            List<ConceptDetail> diseaseConDetailList
+                    = hasConDetailMap.get(diseaseName).get(Long.valueOf(LexiconTypeEnum.DIAGNOSIS.getKey()));
+            for (ConceptDetail conceptDetail : diseaseConDetailList) {
+                List<String> positionList = Arrays.asList(conceptDetail.getPosition().split(",|，"));
+                if (positionList.contains(String.valueOf(PositionTypeEnum.T3.getKey()))) {
+                    conceptDetailDTO = new ConceptDetailDTO();
+                    BeanUtil.copyProperties(conceptDetail, conceptDetailDTO);
+                    break;
+                }
+            }
+        }
+        return conceptDetailDTO;
+    }
+
+    @DataProvider("setSurgeryTreatment")
+    public ConceptDetailDTO setSurgeryTreatment(@InvokeParameter("diseaseName") String diseaseName,
+                                                @InvokeParameter("hasConDetailMap") Map<String, Map<Long, List<ConceptDetail>>> hasConDetailMap) {
+        ConceptDetailDTO conceptDetailDTO = null;
+        if (hasConDetailMap != null && hasConDetailMap.get(diseaseName) != null
+                && ListUtil.isNotEmpty(hasConDetailMap
+                .get(diseaseName)
+                .get(Long.valueOf(LexiconTypeEnum.DIAGNOSIS.getKey())))) {
+            List<ConceptDetail> diseaseConDetailList
+                    = hasConDetailMap.get(diseaseName).get(Long.valueOf(LexiconTypeEnum.DIAGNOSIS.getKey()));
+            for (ConceptDetail conceptDetail : diseaseConDetailList) {
+                List<String> positionList = Arrays.asList(conceptDetail.getPosition().split(",|，"));
+                if (positionList.contains(String.valueOf(PositionTypeEnum.T4.getKey()))) {
+                    conceptDetailDTO = new ConceptDetailDTO();
+                    BeanUtil.copyProperties(conceptDetail, conceptDetailDTO);
+                    break;
+                }
+            }
+        }
+        return conceptDetailDTO;
+    }
+
+    @DataProvider("setDrugs")
+    public List<MedicitionClass> setDrugs(@InvokeParameter("drugsList") List<MedicitionClass> drugsList,
+                                          @InvokeParameter("conceptMap") Map<String, Map<Long, Concept>> conceptMap,
+                                          @InvokeParameter("hasConDetailMap") Map<String, Map<Long, List<ConceptDetail>>> hasConDetailMap) {
+        if (ListUtil.isNotEmpty(drugsList)) {
+            for (MedicitionClass medicitionClass : drugsList) {
+                if (conceptMap != null
+                        && conceptMap.get(medicitionClass.getBigdrugsName()) != null
+                        && conceptMap.get(medicitionClass
+                        .getBigdrugsName())
+                        .containsKey(Long.valueOf(LexiconTypeEnum.DRUG_CATEGORY_BIG.getKey()))) {
+                    Concept cateBigConcept = conceptMap
+                            .get(medicitionClass.getBigdrugsName())
+                            .get(Long.valueOf(LexiconTypeEnum.DRUG_CATEGORY_BIG.getKey()));
+                    if (cateBigConcept != null) {
+                        medicitionClass.setBigdrugsConceptId(cateBigConcept.getId());
+                        if (hasConDetailMap != null
+                                && hasConDetailMap.get(cateBigConcept.getLibName()) != null
+                                && hasConDetailMap.get(cateBigConcept.getLibName())
+                                .containsKey(Long.valueOf(LexiconTypeEnum.DRUG_CATEGORY_BIG.getKey()))) {
+                            medicitionClass.setShowInfo("1");
+                        } else {
+                            medicitionClass.setShowInfo("0");
+                        }
+                    }
+                }
+                medicitionClass.setBigdrgusLibType(LexiconTypeEnum.DRUG_CATEGORY_BIG.getKey());
+                medicitionClass.setBigdrugsType(ConceptTypeEnum.Drug_Category_Big.getKey());
+                if (conceptMap != null
+                        && conceptMap.get(medicitionClass.getSubdrugsName()) != null
+                        && conceptMap.get(medicitionClass.getSubdrugsName())
+                        .containsKey(Long.valueOf(LexiconTypeEnum.DRUG_CATEGORY_SMALL.getKey()))) {
+                    Concept cateSmallConcept = conceptMap
+                            .get(medicitionClass.getSubdrugsName())
+                            .get(Long.valueOf(LexiconTypeEnum.DRUG_CATEGORY_SMALL.getKey()));
+                    if (cateSmallConcept != null) {
+                        medicitionClass.setSubdrugsConceptId(cateSmallConcept.getId());
+                    }
+                }
+                medicitionClass.setSubdrugsLibType(LexiconTypeEnum.DRUG_CATEGORY_SMALL.getKey());
+                medicitionClass.setSubdrugsType(ConceptTypeEnum.Drug_Category_Small.getKey());
+
+                LinkedList<Medicition> medicitionList = medicitionClass.getMedicitionsList();
+                for (Medicition medicition : medicitionList) {
+                    if (conceptMap != null
+                            && conceptMap.get(medicition.getMedicitionName()) != null
+                            && conceptMap.get(medicition.getMedicitionName())
+                            .containsKey(Long.valueOf(LexiconTypeEnum.DRUGS.getKey()))) {
+                        Concept drugConcept = conceptMap
+                                .get(medicition.getMedicitionName())
+                                .get(Long.valueOf(LexiconTypeEnum.DRUGS.getKey()));
+                        if (drugConcept != null) {
+                            medicition.setConceptId(drugConcept.getId());
+                        }
+                    }
+                    medicition.setLibType(LexiconTypeEnum.DRUGS.getKey());
+                    medicition.setType(ConceptTypeEnum.Drug.getKey());
+                    if (hasConDetailMap != null
+                            && hasConDetailMap.get(medicition.getMedicitionName()) != null
+                            && hasConDetailMap.get(medicition.getMedicitionName())
+                            .containsKey(Long.valueOf(LexiconTypeEnum.DRUGS.getKey()))) {
+                        medicition.setShowInfo("1");
+                    } else {
+                        medicition.setShowInfo("0");
+                    }
+                }
+                medicitionClass.setMedicitionsList(medicitionList);
+            }
+        }
+        return drugsList;
+    }
+
+    @DataProvider("setAdverseReactions")
+    public List<AdverseReaction> setAdverseReactions(@InvokeParameter("adverseReactionList") List<AdverseReaction> adverseReactionList,
+                                                     @InvokeParameter("conceptMap") Map<String, Map<Long, Concept>> conceptMap,
+                                                     @InvokeParameter("hasConDetailMap") Map<String, Map<Long, List<ConceptDetail>>> hasConDetailMap,
+                                                     @InvokeParameter("isChronic") Boolean isChronic) {
+        if (isChronic) {
+            //不良反应
+            for (AdverseReaction adverseReaction : adverseReactionList) {
+                if (conceptMap != null
+                        && conceptMap.get(adverseReaction.getName()) != null
+                        && conceptMap.get(adverseReaction.getName())
+                        .containsKey(Long.valueOf(LexiconTypeEnum.SIDE_EFFECTS.getKey()))) {
+                    Concept adConcept = conceptMap
+                            .get(adverseReaction.getName())
+                            .get(Long.valueOf(LexiconTypeEnum.SIDE_EFFECTS.getKey()));
+                    if (adConcept != null) {
+                        adverseReaction.setConceptId(adConcept.getId());
+                    }
+                }
+                adverseReaction.setLibType(LexiconTypeEnum.SIDE_EFFECTS.getKey());
+                adverseReaction.setType(ConceptTypeEnum.SIDE_EFFECTS.getKey());
+                if (hasConDetailMap != null
+                        && hasConDetailMap.get(adverseReaction.getName()) != null
+                        && hasConDetailMap.get(adverseReaction.getName())
+                        .containsKey(Long.valueOf(LexiconTypeEnum.SIDE_EFFECTS.getKey()))) {
+                    adverseReaction.setShowInfo("1");
+                } else {
+                    adverseReaction.setShowInfo("0");
+                }
+            }
+        }
+        return adverseReactionList;
+    }
+}

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

@@ -4,29 +4,25 @@ import com.alibaba.fastjson.JSONObject;
 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.LexiconRSTypeEnum;
 import com.diagbot.enums.LexiconTypeEnum;
-import com.diagbot.enums.PositionTypeEnum;
 import com.diagbot.exception.CommonErrorCode;
 import com.diagbot.exception.CommonException;
-import com.diagbot.util.BeanUtil;
 import com.diagbot.util.FastJsonUtils;
 import com.diagbot.util.ListUtil;
 import com.diagbot.vo.ConceptBaseVO;
 import com.google.common.collect.Lists;
+import io.github.lvyahui8.spring.aggregate.facade.DataBeanAggregateQueryFacade;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;
 
-import java.util.Arrays;
+import java.util.HashMap;
 import java.util.LinkedHashMap;
-import java.util.LinkedList;
 import java.util.List;
 import java.util.Map;
 import java.util.stream.Collectors;
@@ -38,10 +34,13 @@ import java.util.stream.Collectors;
  */
 @Component
 public class TreatmentFacade {
+
     @Autowired
     ConceptFacade conceptFacade;
     @Autowired
     ConceptDetailFacade conceptDetailFacade;
+    @Autowired
+    DataBeanAggregateQueryFacade dataBeanAggregateQueryFacade;
 
     /**
      * 获取治疗方案
@@ -118,103 +117,8 @@ public class TreatmentFacade {
         //说明信息是否存在
         Map<String, Map<Long, List<ConceptDetail>>> hasConDetailMap = conceptDetailFacade.hasConDetail(conceptList);
 
-        //一般治疗&&手术治疗
-        if (hasConDetailMap != null && hasConDetailMap.get(diseaseName) != null
-                && ListUtil.isNotEmpty(hasConDetailMap
-                .get(diseaseName)
-                .get(Long.valueOf(LexiconTypeEnum.DIAGNOSIS.getKey())))) {
-            List<ConceptDetail> diseaseConDetailList
-                    = hasConDetailMap.get(diseaseName).get(Long.valueOf(LexiconTypeEnum.DIAGNOSIS.getKey()));
-            for (ConceptDetail conceptDetail : diseaseConDetailList) {
-                ConceptDetailDTO conceptDetailDTO = new ConceptDetailDTO();
-                List<String> positionList = Arrays.asList(conceptDetail.getPosition().split(",|，"));
-                if (positionList.contains(String.valueOf(PositionTypeEnum.T3.getKey()))
-                        && retMap.get("commonTreatment") == null) {
-                    BeanUtil.copyProperties(conceptDetail, conceptDetailDTO);
-                    retMap.put("commonTreatment", conceptDetailDTO);
-                }
-                if (positionList.contains(String.valueOf(PositionTypeEnum.T4.getKey()))
-                        && retMap.get("surgeryTreatment") == null) {
-                    BeanUtil.copyProperties(conceptDetail, conceptDetailDTO);
-                    retMap.put("surgeryTreatment", conceptDetailDTO);
-                }
-            }
-        }
-        if (!retMap.containsKey("commonTreatment")) {
-            retMap.put("commonTreatment", null);
-        }
-        if (!retMap.containsKey("surgeryTreatment")) {
-            retMap.put("surgeryTreatment", null);
-        }
-
-        if (ListUtil.isNotEmpty(drugsList)) {
-            for (MedicitionClass medicitionClass : drugsList) {
-                if (conceptMap != null
-                        && conceptMap.get(medicitionClass.getBigdrugsName()) != null
-                        && conceptMap.get(medicitionClass
-                        .getBigdrugsName())
-                        .containsKey(Long.valueOf(LexiconTypeEnum.DRUG_CATEGORY_BIG.getKey()))) {
-                    Concept cateBigConcept = conceptMap
-                            .get(medicitionClass.getBigdrugsName())
-                            .get(Long.valueOf(LexiconTypeEnum.DRUG_CATEGORY_BIG.getKey()));
-                    if (cateBigConcept != null) {
-                        medicitionClass.setBigdrugsConceptId(cateBigConcept.getId());
-                        if (hasConDetailMap != null
-                                && hasConDetailMap.get(cateBigConcept.getLibName()) != null
-                                && hasConDetailMap.get(cateBigConcept.getLibName())
-                                .containsKey(Long.valueOf(LexiconTypeEnum.DRUG_CATEGORY_BIG.getKey()))) {
-                            medicitionClass.setShowInfo("1");
-                        } else {
-                            medicitionClass.setShowInfo("0");
-                        }
-                    }
-                }
-                medicitionClass.setBigdrgusLibType(LexiconTypeEnum.DRUG_CATEGORY_BIG.getKey());
-                medicitionClass.setBigdrugsType(ConceptTypeEnum.Drug_Category_Big.getKey());
-                if (conceptMap != null
-                        && conceptMap.get(medicitionClass.getSubdrugsName()) != null
-                        && conceptMap.get(medicitionClass.getSubdrugsName())
-                        .containsKey(Long.valueOf(LexiconTypeEnum.DRUG_CATEGORY_SMALL.getKey()))) {
-                    Concept cateSmallConcept = conceptMap
-                            .get(medicitionClass.getSubdrugsName())
-                            .get(Long.valueOf(LexiconTypeEnum.DRUG_CATEGORY_SMALL.getKey()));
-                    if (cateSmallConcept != null) {
-                        medicitionClass.setSubdrugsConceptId(cateSmallConcept.getId());
-                    }
-                }
-                medicitionClass.setSubdrugsLibType(LexiconTypeEnum.DRUG_CATEGORY_SMALL.getKey());
-                medicitionClass.setSubdrugsType(ConceptTypeEnum.Drug_Category_Small.getKey());
-
-                LinkedList<Medicition> medicitionList = medicitionClass.getMedicitionsList();
-                for (Medicition medicition : medicitionList) {
-                    if (conceptMap != null
-                            && conceptMap.get(medicition.getMedicitionName()) != null
-                            && conceptMap.get(medicition.getMedicitionName())
-                            .containsKey(Long.valueOf(LexiconTypeEnum.DRUGS.getKey()))) {
-                        Concept drugConcept = conceptMap
-                                .get(medicition.getMedicitionName())
-                                .get(Long.valueOf(LexiconTypeEnum.DRUGS.getKey()));
-                        if (drugConcept != null) {
-                            medicition.setConceptId(drugConcept.getId());
-                        }
-                    }
-                    medicition.setLibType(LexiconTypeEnum.DRUGS.getKey());
-                    medicition.setType(ConceptTypeEnum.Drug.getKey());
-                    if (hasConDetailMap != null
-                            && hasConDetailMap.get(medicition.getMedicitionName()) != null
-                            && hasConDetailMap.get(medicition.getMedicitionName())
-                            .containsKey(Long.valueOf(LexiconTypeEnum.DRUGS.getKey()))) {
-                        medicition.setShowInfo("1");
-                    } else {
-                        medicition.setShowInfo("0");
-                    }
-                }
-                medicitionClass.setMedicitionsList(medicitionList);
-            }
-        }
-        retMap.put("treatment", drugsList);
-
-        //判断是否慢病，慢病增加回访时间，上次用药，不良反应
+        //判断是否慢病
+        Boolean isChronic = false;
         if (disType != null && disType.equals(DisTypeEnum.CHRONIC.getKey())) {
             //验证是否慢病
             conceptBaseVO.setName("慢病");
@@ -229,39 +133,159 @@ public class TreatmentFacade {
             conceptWrapper.setEndType(LexiconTypeEnum.TYPES_OF_DISEASE.getKey());
             conceptWrapper.setRelationType(LexiconRSTypeEnum.INCLUDE_OF.getKey());
             List<ConceptRes> conceptResList = conceptFacade.getConcept(conceptWrapper);
-            Boolean isChronic = ListUtil.isNotEmpty(conceptResList);
-            if (isChronic) {
-                //慢病，增加回访时间，暂时前端写死， 以后由只是图谱返回
-                retMap.put("followUp", null);
-                //上次用药-icss层处理
-                retMap.put("drugHistory", null);
-                //不良反应
-                for (AdverseReaction adverseReaction : adverseReactionList) {
-                    if (conceptMap != null
-                            && conceptMap.get(adverseReaction.getName()) != null
-                            && conceptMap.get(adverseReaction.getName())
-                            .containsKey(Long.valueOf(LexiconTypeEnum.SIDE_EFFECTS.getKey()))) {
-                        Concept adConcept = conceptMap
-                                .get(adverseReaction.getName())
-                                .get(Long.valueOf(LexiconTypeEnum.SIDE_EFFECTS.getKey()));
-                        if (adConcept != null) {
-                            adverseReaction.setConceptId(adConcept.getId());
-                        }
-                    }
-                    adverseReaction.setLibType(LexiconTypeEnum.SIDE_EFFECTS.getKey());
-                    adverseReaction.setType(ConceptTypeEnum.SIDE_EFFECTS.getKey());
-                    if (hasConDetailMap != null
-                            && hasConDetailMap.get(adverseReaction.getName()) != null
-                            && hasConDetailMap.get(adverseReaction.getName())
-                            .containsKey(Long.valueOf(LexiconTypeEnum.SIDE_EFFECTS.getKey()))) {
-                        adverseReaction.setShowInfo("1");
-                    } else {
-                        adverseReaction.setShowInfo("0");
-                    }
-                }
-                retMap.put("adverseReactions", adverseReactionList);
+            isChronic = ListUtil.isNotEmpty(conceptResList);
+        }
+
+        try {
+            Map<String, Object> invokeParams = new HashMap<>();
+            invokeParams.put("treatmentMap", retMap);
+            invokeParams.put("diseaseName", diseaseName);
+            invokeParams.put("drugsList", drugsList);
+            invokeParams.put("conceptMap", conceptMap);
+            invokeParams.put("hasConDetailMap", hasConDetailMap);
+            invokeParams.put("adverseReactionList", adverseReactionList);
+            invokeParams.put("isChronic", isChronic);
+
+            retMap
+                    = dataBeanAggregateQueryFacade.get("setTreatmentAll", invokeParams, Map.class);
+        } catch (Exception e) {
+            throw new CommonException(CommonErrorCode.SERVER_IS_ERROR);
+        }
+        //判断是否慢病，慢病增加回访时间，上次用药，不良反应
+        if (isChronic) {
+            if (retMap == null) {
+                retMap = new LinkedHashMap<>();
             }
+            //慢病，增加回访时间，暂时前端写死， 以后由只是图谱返回
+            retMap.put("followUp", null);
+            //上次用药-icss层处理
+            retMap.put("drugHistory", null);
         }
+
+        //        //一般治疗&&手术治疗
+        //        if (hasConDetailMap != null && hasConDetailMap.get(diseaseName) != null
+        //                && ListUtil.isNotEmpty(hasConDetailMap
+        //                .get(diseaseName)
+        //                .get(Long.valueOf(LexiconTypeEnum.DIAGNOSIS.getKey())))) {
+        //            List<ConceptDetail> diseaseConDetailList
+        //                    = hasConDetailMap.get(diseaseName).get(Long.valueOf(LexiconTypeEnum.DIAGNOSIS.getKey()));
+        //            for (ConceptDetail conceptDetail : diseaseConDetailList) {
+        //                ConceptDetailDTO conceptDetailDTO = new ConceptDetailDTO();
+        //                List<String> positionList = Arrays.asList(conceptDetail.getPosition().split(",|，"));
+        //                if (positionList.contains(String.valueOf(PositionTypeEnum.T3.getKey()))
+        //                        && retMap.get("commonTreatment") == null) {
+        //                    BeanUtil.copyProperties(conceptDetail, conceptDetailDTO);
+        //                    retMap.put("commonTreatment", conceptDetailDTO);
+        //                }
+        //                if (positionList.contains(String.valueOf(PositionTypeEnum.T4.getKey()))
+        //                        && retMap.get("surgeryTreatment") == null) {
+        //                    BeanUtil.copyProperties(conceptDetail, conceptDetailDTO);
+        //                    retMap.put("surgeryTreatment", conceptDetailDTO);
+        //                }
+        //            }
+        //        }
+        //        if (!retMap.containsKey("commonTreatment")) {
+        //            retMap.put("commonTreatment", null);
+        //        }
+        //        if (!retMap.containsKey("surgeryTreatment")) {
+        //            retMap.put("surgeryTreatment", null);
+        //        }
+
+        //        if (ListUtil.isNotEmpty(drugsList)) {
+        //            for (MedicitionClass medicitionClass : drugsList) {
+        //                if (conceptMap != null
+        //                        && conceptMap.get(medicitionClass.getBigdrugsName()) != null
+        //                        && conceptMap.get(medicitionClass
+        //                        .getBigdrugsName())
+        //                        .containsKey(Long.valueOf(LexiconTypeEnum.DRUG_CATEGORY_BIG.getKey()))) {
+        //                    Concept cateBigConcept = conceptMap
+        //                            .get(medicitionClass.getBigdrugsName())
+        //                            .get(Long.valueOf(LexiconTypeEnum.DRUG_CATEGORY_BIG.getKey()));
+        //                    if (cateBigConcept != null) {
+        //                        medicitionClass.setBigdrugsConceptId(cateBigConcept.getId());
+        //                        if (hasConDetailMap != null
+        //                                && hasConDetailMap.get(cateBigConcept.getLibName()) != null
+        //                                && hasConDetailMap.get(cateBigConcept.getLibName())
+        //                                .containsKey(Long.valueOf(LexiconTypeEnum.DRUG_CATEGORY_BIG.getKey()))) {
+        //                            medicitionClass.setShowInfo("1");
+        //                        } else {
+        //                            medicitionClass.setShowInfo("0");
+        //                        }
+        //                    }
+        //                }
+        //                medicitionClass.setBigdrgusLibType(LexiconTypeEnum.DRUG_CATEGORY_BIG.getKey());
+        //                medicitionClass.setBigdrugsType(ConceptTypeEnum.Drug_Category_Big.getKey());
+        //                if (conceptMap != null
+        //                        && conceptMap.get(medicitionClass.getSubdrugsName()) != null
+        //                        && conceptMap.get(medicitionClass.getSubdrugsName())
+        //                        .containsKey(Long.valueOf(LexiconTypeEnum.DRUG_CATEGORY_SMALL.getKey()))) {
+        //                    Concept cateSmallConcept = conceptMap
+        //                            .get(medicitionClass.getSubdrugsName())
+        //                            .get(Long.valueOf(LexiconTypeEnum.DRUG_CATEGORY_SMALL.getKey()));
+        //                    if (cateSmallConcept != null) {
+        //                        medicitionClass.setSubdrugsConceptId(cateSmallConcept.getId());
+        //                    }
+        //                }
+        //                medicitionClass.setSubdrugsLibType(LexiconTypeEnum.DRUG_CATEGORY_SMALL.getKey());
+        //                medicitionClass.setSubdrugsType(ConceptTypeEnum.Drug_Category_Small.getKey());
+        //
+        //                LinkedList<Medicition> medicitionList = medicitionClass.getMedicitionsList();
+        //                for (Medicition medicition : medicitionList) {
+        //                    if (conceptMap != null
+        //                            && conceptMap.get(medicition.getMedicitionName()) != null
+        //                            && conceptMap.get(medicition.getMedicitionName())
+        //                            .containsKey(Long.valueOf(LexiconTypeEnum.DRUGS.getKey()))) {
+        //                        Concept drugConcept = conceptMap
+        //                                .get(medicition.getMedicitionName())
+        //                                .get(Long.valueOf(LexiconTypeEnum.DRUGS.getKey()));
+        //                        if (drugConcept != null) {
+        //                            medicition.setConceptId(drugConcept.getId());
+        //                        }
+        //                    }
+        //                    medicition.setLibType(LexiconTypeEnum.DRUGS.getKey());
+        //                    medicition.setType(ConceptTypeEnum.Drug.getKey());
+        //                    if (hasConDetailMap != null
+        //                            && hasConDetailMap.get(medicition.getMedicitionName()) != null
+        //                            && hasConDetailMap.get(medicition.getMedicitionName())
+        //                            .containsKey(Long.valueOf(LexiconTypeEnum.DRUGS.getKey()))) {
+        //                        medicition.setShowInfo("1");
+        //                    } else {
+        //                        medicition.setShowInfo("0");
+        //                    }
+        //                }
+        //                medicitionClass.setMedicitionsList(medicitionList);
+        //            }
+        //        }
+        //        retMap.put("treatment", drugsList);
+
+
+        //        //不良反应
+        //        for (AdverseReaction adverseReaction : adverseReactionList) {
+        //            if (conceptMap != null
+        //                    && conceptMap.get(adverseReaction.getName()) != null
+        //                    && conceptMap.get(adverseReaction.getName())
+        //                    .containsKey(Long.valueOf(LexiconTypeEnum.SIDE_EFFECTS.getKey()))) {
+        //                Concept adConcept = conceptMap
+        //                        .get(adverseReaction.getName())
+        //                        .get(Long.valueOf(LexiconTypeEnum.SIDE_EFFECTS.getKey()));
+        //                if (adConcept != null) {
+        //                    adverseReaction.setConceptId(adConcept.getId());
+        //                }
+        //            }
+        //            adverseReaction.setLibType(LexiconTypeEnum.SIDE_EFFECTS.getKey());
+        //            adverseReaction.setType(ConceptTypeEnum.SIDE_EFFECTS.getKey());
+        //            if (hasConDetailMap != null
+        //                    && hasConDetailMap.get(adverseReaction.getName()) != null
+        //                    && hasConDetailMap.get(adverseReaction.getName())
+        //                    .containsKey(Long.valueOf(LexiconTypeEnum.SIDE_EFFECTS.getKey()))) {
+        //                adverseReaction.setShowInfo("1");
+        //            } else {
+        //                adverseReaction.setShowInfo("0");
+        //            }
+        //        }
+        //        retMap.put("adverseReactions", adverseReactionList);
+
+
         return retMap;
     }