Merge remote-tracking branch 'origin/master' into innerDevelop

doc/001.00000000初始化脚本/symptom_feature.sql

@@ -0,0 +1,38 @@
+/*
+Navicat MySQL Data Transfer
+
+Source Server         : 236
+Source Server Version : 50731
+Source Host           : 192.168.2.236:3306
+Source Database       : cdss
+
+Target Server Type    : MYSQL
+Target Server Version : 50731
+File Encoding         : 65001
+
+Date: 2020-11-10 09:54:31
+*/
+
+SET FOREIGN_KEY_CHECKS=0;
+
+-- ----------------------------
+-- Table structure for symptom_feature
+-- ----------------------------
+DROP TABLE IF EXISTS `symptom_feature`;
+CREATE TABLE `symptom_feature` (
+  `id` bigint(20) NOT NULL AUTO_INCREMENT,
+  `is_deleted` char(1) CHARACTER SET utf8mb4 NOT NULL DEFAULT 'N' COMMENT '是否删除,N:未删除，Y:删除',
+  `gmt_create` datetime NOT NULL DEFAULT '1970-01-01 12:00:00' COMMENT '记录创建时间',
+  `gmt_modified` datetime NOT NULL DEFAULT '1970-01-01 12:00:00' COMMENT '记录修改时间,如果时间是1970年则表示纪录未修改',
+  `min_combine_element` varchar(255) CHARACTER SET utf8mb4 NOT NULL DEFAULT '' COMMENT '最小组合单元',
+  `body_part` varchar(1000) CHARACTER SET utf8mb4 NOT NULL DEFAULT '' COMMENT '部位',
+  `position` varchar(1000) CHARACTER SET utf8mb4 NOT NULL DEFAULT '' COMMENT '方位',
+  `shape_propety` varchar(1000) CHARACTER SET utf8mb4 NOT NULL DEFAULT '' COMMENT '形状性质',
+  `degree` varchar(1000) CHARACTER SET utf8mb4 NOT NULL DEFAULT '' COMMENT '程度',
+  `color` varchar(1000) CHARACTER SET utf8mb4 NOT NULL DEFAULT '' COMMENT '颜色',
+  `variety` varchar(1000) CHARACTER SET utf8mb4 NOT NULL DEFAULT '' COMMENT '变化',
+  `radiation_situation` varchar(1000) CHARACTER SET utf8mb4 NOT NULL DEFAULT '' COMMENT '放射情况',
+  `frequency` varchar(1000) CHARACTER SET utf8mb4 NOT NULL DEFAULT '' COMMENT '频率',
+  PRIMARY KEY (`id`),
+  UNIQUE KEY `min_ce` (`min_combine_element`) USING BTREE
+) ENGINE=InnoDB AUTO_INCREMENT=5155 DEFAULT CHARSET=utf8;

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

@@ -38,6 +38,12 @@ public class CacheDeleteInit implements CommandLineRunner {
         cacheFacade.getVitalCache();
         log.info("CDSS-CORE服务启动加载图谱体征缓存成功！");
 
+        cacheFacade.getSymptomFeatureCache();
+        log.info("CDSS-CORE服务启动加载症状特征缓存成功！");
+
+        cacheFacade.getSymptomMainCache();
+        log.info("CDSS-CORE服务启动加载典型症状缓存成功！");
+
         cacheFacade.loadDiseaseTypeCache();
         log.info("CDSS-CORE服务启动加载疾病属性（性别、年龄、发病率）缓存成功！");
 

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

@@ -18,4 +18,5 @@ public class DiseaseProperty {
     private String age;
     private String fbl;
     private String dept;
+    private String clafy;
 }

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

@@ -15,6 +15,8 @@ public enum RedisEnum implements KeyedNamed {
     symptomVitalType(3, "symptomVitalType:"),
     symptomNumType(4, "symptomNumType:"),
     vitalType(5, "vitalType:"),
+    symptomFeature(6, "symptomFeature:"),
+    symptomMainFeature(7, "symptomMainFeature:"),
     diseaseType(2, "diseaseType:");
 
     @Setter

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

@@ -88,6 +88,17 @@ public class CacheFacade {
 
     }
 
+    /**
+     * 加载图谱中的症状缓存
+     *
+     * @return
+     */
+    public void getSymptomMainCache() {
+        redisUtil.deleteByPrex(RedisEnum.symptomMainFeature.getName());
+        neoFacade.symptomMainCache();
+
+    }
+
     /**
      * 加载图谱中的体征缓存
      *
@@ -99,6 +110,16 @@ public class CacheFacade {
 
     }
 
+    /**
+     * 加载数据库中症状特征缓存
+     *
+     * @return
+     */
+    public void getSymptomFeatureCache() {
+        redisUtil.deleteByPrex(RedisEnum.symptomFeature.getName());
+        neoFacade.symptomFeatureCache();
+    }
+
     /**
      * 加载图谱中的疾病对应的症状个数
      *

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

@@ -248,8 +248,8 @@ public class CommonFacade {
         VitalLabel vitalLabel = wordCrfDTO.getVitalLabel();
 
         // 【症状回填】
-        CoreUtil.setPropertyList(chiefLabel.getClinicals(), map.get(StandConvertEnum.symptom.toString()));
-        CoreUtil.setPropertyList(presentLabel.getClinicals(), map.get(StandConvertEnum.symptom.toString()));
+//        CoreUtil.setPropertyList(chiefLabel.getClinicals(), map.get(StandConvertEnum.symptom.toString()));
+//        CoreUtil.setPropertyList(presentLabel.getClinicals(), map.get(StandConvertEnum.symptom.toString()));
 
         // 【诊断回填】
         // 1、主诉诊断
@@ -391,7 +391,7 @@ public class CommonFacade {
             }
             if (ListUtil.isNotEmpty(presentLabel.getDiags())) {
                 List<Diag> presentdiags = presentLabel.getDiags().stream()
-                        .filter(x -> x.getNegative() == null && StringUtils.isNotBlank(x.getStandName())).map
+                        .filter(x -> x.getNegative() == null && StringUtils.isNotBlank(x.getStandName()) && x.getPossible() != null).map
                                 (x -> x.getStandName()).distinct().map(z ->
                         {
                             Diag diag = new Diag();

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

@@ -8,6 +8,7 @@ import com.diagbot.client.StandConvertServiceClient;
 import com.diagbot.dto.*;
 import com.diagbot.entity.DiseaseInfo;
 import com.diagbot.entity.DiseaseProperty;
+import com.diagbot.entity.SymptomFeature;
 import com.diagbot.entity.SymptomNumOfDiS;
 import com.diagbot.entity.node.LisRemind;
 import com.diagbot.entity.relationship.LisRemindGroup;
@@ -17,6 +18,7 @@ import com.diagbot.enums.RedisEnum;
 import com.diagbot.enums.StandConvertEnum;
 import com.diagbot.exception.CommonErrorCode;
 import com.diagbot.exception.CommonException;
+import com.diagbot.mapper.SymptomFeatureMapper;
 import com.diagbot.model.entity.PD;
 import com.diagbot.repository.*;
 import com.diagbot.util.ListUtil;
@@ -30,6 +32,7 @@ import com.google.common.collect.Lists;
 import com.google.common.collect.Maps;
 import io.github.lvyahui8.spring.facade.DataFacade;
 import org.apache.commons.collections.MapUtils;
+import org.apache.commons.lang3.StringUtils;
 import org.springframework.beans.BeanUtils;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.annotation.Qualifier;
@@ -45,6 +48,8 @@ import java.util.function.Function;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
+import static com.diagbot.util.StringUtil.permutationNoRepeat;
+
 /**
  * @Description: 图谱facade
  * @author: Mark
@@ -104,6 +109,8 @@ public class NeoFacade {
     PacsRemindRepository pacsRemindRepository;
     @Autowired
     PacsResultRepository pacsResultRepository;
+    @Autowired
+    SymptomFeatureMapper symptomFeatureMapper;
 
     /**
      * 返回药品缓存信息
@@ -157,6 +164,7 @@ public class NeoFacade {
                         desc.put("age", v.getAge());
                         desc.put("fbl", v.getFbl());
                         desc.put("dept", v.getDept());
+                        desc.put("clafy", v.getClafy());
                         return desc;
                     },
                     (v1, v2) -> (v2)
@@ -177,6 +185,18 @@ public class NeoFacade {
         }
     }
 
+    public void symptomMainCache() {
+        List<String> diseaseProperty = nodeRepository.getSymptomMain();
+        if (ListUtil.isNotEmpty(diseaseProperty)) {
+            Map map = diseaseProperty.stream().collect(Collectors.toMap(
+                    k -> RedisEnum.symptomMainFeature.getName() + k,
+                    v -> v,
+                    (v1, v2) -> (v2)
+            ));
+            redisTemplate.opsForValue().multiSet(map);
+        }
+    }
+
     public void vitalCache() {
         List<String> diseaseProperty = nodeRepository.getVitalClass();
         if (ListUtil.isNotEmpty(diseaseProperty)) {
@@ -189,6 +209,30 @@ public class NeoFacade {
         }
     }
 
+    public void symptomFeatureCache() {
+        List<SymptomFeature> symptomFeatures = symptomFeatureMapper.selectList(null);
+        if (ListUtil.isNotEmpty(symptomFeatures)) {
+            Map map = symptomFeatures.stream().collect(Collectors.toMap(
+                    k -> RedisEnum.symptomFeature.getName() + k.getMinCombineElement(),
+                    v -> {
+                        Map<String, String> desc = new HashMap<>();
+                        desc.put("minCombineElement", v.getMinCombineElement());
+                        desc.put("bodyPart", v.getBodyPart());
+                        desc.put("change", v.getVariety());
+                        desc.put("color", v.getColor());
+                        desc.put("degree", v.getDegree());
+                        desc.put("frequency", v.getFrequency());
+                        desc.put("position", v.getPosition());
+                        desc.put("radiationSituation", v.getRadiationSituation());
+                        desc.put("shapePropety", v.getShapePropety());
+                        return desc;
+                    },
+                    (v1, v2) -> (v2)
+            ));
+            redisTemplate.opsForValue().multiSet(map);
+        }
+    }
+
     public void symptomNumCache() {
         List<SymptomNumOfDiS> diseaseProperty = nodeRepository.getSymptomNum();
         if (ListUtil.isNotEmpty(diseaseProperty)) {
@@ -332,11 +376,11 @@ public class NeoFacade {
             throw new CommonException(CommonErrorCode.SERVER_IS_ERROR, "并行推送疾病出错" + e.getMessage());
         }
 
-        filterAndSort(pushDis, allDis, sex, age, pd,depts);
+        filterAndSort(pushDis, allDis, sex, age, pd, depts);
         //特异值推送的诊断添加到症状推送诊断的头部
         pushDisByPacs.removeAll(pushDisByLis);
         pushDisByLis.addAll(pushDisByPacs);
-        filterAndSort(pushSpeDis,pushDisByLis, sex, age, pd,depts);
+        filterAndSort(pushSpeDis, pushDisByLis, sex, age, pd, depts);
         pushDis.removeAll(pushSpeDis);
         pushSpeDis.addAll(pushDis);
 
@@ -386,6 +430,7 @@ public class NeoFacade {
 
     /**
      * 化验特异性推送疾病
+     *
      * @param pushVO
      * @return
      */
@@ -453,7 +498,8 @@ public class NeoFacade {
             List<Item> pacs = pacsPushVo.getPacs();
             if (ListUtil.isNotEmpty(pacs)) {
                 List<String> pacsNames = pacs.stream().map(x -> x.getUniqueName()).collect(Collectors.toList());
-                allDis_byPacsResult = pacsResultRepository.getDisByPacsResults(pacsNames);;
+                allDis_byPacsResult = pacsResultRepository.getDisByPacsResults(pacsNames);
+                ;
             }
         }
         return allDis_byPacsResult;
@@ -461,37 +507,142 @@ public class NeoFacade {
 
     /**
      * 根据主症状推送诊断
+     *
      * @param pushVO
      * @return
      */
     public List<String> pushDisBySymptom_main(NeoPushVO pushVO) {
         List<String> disBySymptom_main = Lists.newArrayList();
         List<String> symptoms = getSymptoms(pushVO);
-        if(ListUtil.isNotEmpty(symptoms)){
+        String name = RedisEnum.symptomFeature.getName();
+        Set<String> keys = redisUtil.keys(name + "*");
+        List<String> redis_key = keys.stream().map(x -> x.split(name)[1]).collect(Collectors.toList());
+        if (ListUtil.isNotEmpty(symptoms)) {
             String s_m = symptoms.get(0);
             disBySymptom_main = nodeRepository.getDisBySymptom_main(s_m);
-            if(ListUtil.isEmpty(disBySymptom_main) && ListUtil.isNotEmpty(pushVO.getSymptoms())){
-                String s_second = pushVO.getSymptoms().get(0);
-                disBySymptom_main = nodeRepository.getDisBySymptom_main(s_second);
+            Map<Integer, List<String>> fild_pailie = splitSymptom(s_m, redis_key);
+            //拆分主症状找疾病
+            if (ListUtil.isEmpty(disBySymptom_main)) {
+                if (MapUtils.isNotEmpty(fild_pailie)) {
+                    Map<Integer, List<String>> result = fild_pailie.entrySet().stream().sorted(Collections.reverseOrder(Map.Entry.comparingByKey()))
+                            .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (e1, e2) -> e2, LinkedHashMap::new));
+                    for (Map.Entry<Integer, List<String>> fd : result.entrySet()) {
+                        List<String> sv = redisUtil.getSv(fd.getValue(), RedisEnum.symptomMainFeature.getName());
+                        sv = sv.stream().filter(x -> StringUtils.isNotBlank(x)).collect(Collectors.toList());
+                        if (ListUtil.isNotEmpty(sv)) {
+                            disBySymptom_main = nodeRepository.getDisBySymptom_main(sv.get(0));
+                            break;
+                        }
+                    }
+                }
+            }
+            if (ListUtil.isEmpty(disBySymptom_main)) {
+                if (MapUtils.isNotEmpty(fild_pailie)) {
+                    Map<Integer, List<String>> result = fild_pailie.entrySet().stream().sorted(Collections.reverseOrder(Map.Entry.comparingByKey()))
+                            .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (e1, e2) -> e2, LinkedHashMap::new));
+                    for (Map.Entry<Integer, List<String>> fd : result.entrySet()) {
+                        List<String> sv = redisUtil.getSv(fd.getValue(), RedisEnum.symptomVitalType.getName());
+                        sv = sv.stream().filter(x -> StringUtils.isNotBlank(x)).collect(Collectors.toList());
+                        if (ListUtil.isNotEmpty(sv)) {
+                            disBySymptom_main = symptomRepository.getDisBySymptoms_1(Lists.newArrayList(sv.get(0)));
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+        List<String> symptoms1 = pushVO.getSymptoms();
+        if (ListUtil.isEmpty(disBySymptom_main) && ListUtil.isNotEmpty(symptoms1)) {
+            Map<Integer, List<String>> fild_pailie = splitSymptom(symptoms1.get(0), redis_key);
+            if (MapUtils.isNotEmpty(fild_pailie)) {
+                Map<Integer, List<String>> result = fild_pailie.entrySet().stream().sorted(Collections.reverseOrder(Map.Entry.comparingByKey()))
+                        .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (e1, e2) -> e2, LinkedHashMap::new));
+                for (Map.Entry<Integer, List<String>> fd : result.entrySet()) {
+                    List<String> sv = redisUtil.getSv(fd.getValue(), RedisEnum.symptomVitalType.getName());
+                    sv = sv.stream().filter(x -> StringUtils.isNotBlank(x)).collect(Collectors.toList());
+                    if (ListUtil.isNotEmpty(sv)) {
+                        disBySymptom_main = symptomRepository.getDisBySymptoms_1(Lists.newArrayList(sv.get(0)));
+                        break;
+                    }
+                }
             }
         }
         return disBySymptom_main;
     }
 
-    public List<String> getSymptoms(NeoPushVO pushVO){
+
+    private Map<Integer, List<String>> splitSymptom(String s_m, List<String> redis_key) {
+        List<String> filter_keys = redis_key.stream().filter(x -> s_m.contains(x)).collect(Collectors.toList());
+        List<Map<String, String>> redisDatas = redisUtil.getSf(filter_keys, RedisEnum.symptomFeature.getName());
+        Map<String, List<String>> min_filds = Maps.newHashMap();
+        if (ListUtil.isNotEmpty(redisDatas)) {
+            redisDatas.forEach(x -> {
+                List<String> datas = Lists.newArrayList();
+                String minCombineElement = x.get("minCombineElement");
+                String radiationSituation = x.get("radiationSituation");
+                String color = x.get("color");
+                String change = x.get("change");
+                String degree = x.get("degree");
+                String shapePropety = x.get("shapePropety");
+                String position = x.get("position");
+                String bodyPart = x.get("bodyPart");
+                String frequency = x.get("frequency");
+                searchWord(radiationSituation, s_m, "、", datas);
+                searchWord(color, s_m, "、", datas);
+                searchWord(change, s_m, "、", datas);
+                searchWord(degree, s_m, "、", datas);
+                searchWord(shapePropety, s_m, "、", datas);
+                searchWord(position, s_m, "、", datas);
+                searchWord(bodyPart, s_m, "、", datas);
+                searchWord(frequency, s_m, "、", datas);
+                min_filds.put(minCombineElement, datas);
+            });
+        }
+        Map<Integer, List<String>> fild_pailie = Maps.newHashMap();
+        if (MapUtils.isNotEmpty(min_filds)) {
+            min_filds.forEach((k, v) -> {
+                v.add(k);
+                for (int i = v.size(); i > 0; i--) {
+                    List<String> datad = permutationNoRepeat(v, i);
+                    if (fild_pailie.containsKey(i)) {
+                        List<String> strings = fild_pailie.get(i);
+                        datad.removeAll(strings);
+                        strings.addAll(datad);
+                        fild_pailie.put(i, strings);
+                    } else {
+                        fild_pailie.put(i, datad);
+                    }
+                }
+            });
+        }
+        return fild_pailie;
+    }
+
+    public void searchWord(String color, String regionWord, String patternFild, List<String> datas) {
+        if (StringUtil.isNotEmpty(color)) {
+            String[] splitsData = color.split(patternFild);
+            for (String fils : splitsData) {
+                if (regionWord.contains(fils)) {
+                    datas.add(fils);
+                }
+            }
+        }
+    }
+
+    public List<String> getSymptoms(NeoPushVO pushVO) {
         List<String> symptom_chief = Lists.newArrayList();
         List<String> symptom_present = Lists.newArrayList();
         ChiefPushVo chiefPushVo = pushVO.getChiefPushVo();
         PresentPushVo presentPushVo = pushVO.getPresentPushVo();
-        if(chiefPushVo != null){
+        if (chiefPushVo != null) {
             List<Symptom> symptoms = chiefPushVo.getSymptoms();
-            if(ListUtil.isNotEmpty(symptoms)){
+            if (ListUtil.isNotEmpty(symptoms)) {
                 symptom_chief = symptoms.stream().map(x -> x.getName()).collect(Collectors.toList());
             }
         }
-        if(presentPushVo != null){
+        if (presentPushVo != null) {
             List<Symptom> symptoms = presentPushVo.getSymptoms();
-            if(ListUtil.isNotEmpty(symptoms)){
+            if (ListUtil.isNotEmpty(symptoms)) {
                 symptom_present = symptoms.stream().map(x -> x.getName()).collect(Collectors.toList());
             }
         }
@@ -540,7 +691,7 @@ public class NeoFacade {
         if (presentPushVo != null) {
             if (ListUtil.isNotEmpty(presentPushVo.getSymptoms())) {
                 symptom_present = presentPushVo.getSymptoms().stream().map(x -> x.getName()).collect(Collectors.toList());
-                symptom_present = symptom_present.size() >= 5? symptom_present.subList(0,5) : symptom_present;
+                symptom_present = symptom_present.size() >= 5 ? symptom_present.subList(0, 5) : symptom_present;
             }
         }
         symptoms = Stream.of(symptom_chief, symptom_present).flatMap(Collection::stream).distinct().collect(Collectors.toList());
@@ -549,28 +700,28 @@ public class NeoFacade {
         allDis.addAll(allDis_bySymptom);
     }
 
-    public List<String> getDisBySymptom_other(NeoPushVO pushVO){
+    public List<String> getDisBySymptom_other(NeoPushVO pushVO) {
         List<String> disBySymptoms_1 = Lists.newArrayList();
         List<String> symptoms = getSymptoms(pushVO);
-        if(ListUtil.isNotEmpty(symptoms) && symptoms.size() > 2){
-            symptoms = symptoms.size() >= 5?symptoms.subList(1,5):symptoms;
-            List<String> sv = redisUtil.getSv(symptoms,RedisEnum.symptomVitalType.getName());
+        if (ListUtil.isNotEmpty(symptoms) && symptoms.size() > 2) {
+            symptoms = symptoms.size() >= 5 ? symptoms.subList(1, 5) : symptoms;
+            List<String> sv = redisUtil.getSv(symptoms, RedisEnum.symptomVitalType.getName());
             disBySymptoms_1 = symptomRepository.getDisBySymptoms_1(sv);
         }
         return disBySymptoms_1;
     }
 
-    public List<String> getDisByVital(NeoPushVO pushVO){
+    public List<String> getDisByVital(NeoPushVO pushVO) {
         List<String> disByVital = Lists.newArrayList();
         List<String> symptoms = getSymptoms(pushVO);
-        if(ListUtil.isNotEmpty(symptoms)){
-            List<String> sv = redisUtil.getSv(symptoms,RedisEnum.vitalType.getName());
+        if (ListUtil.isNotEmpty(symptoms)) {
+            List<String> sv = redisUtil.getSv(symptoms, RedisEnum.vitalType.getName());
             disByVital = symptomRepository.getDisByVital(sv);
         }
         return disByVital;
     }
 
-    public List<String> getDisByLis_other(NeoPushVO pushVO){
+    public List<String> getDisByLis_other(NeoPushVO pushVO) {
         List<Lis> lises = null;
         LisPushVo lisPushVo = pushVO.getLisPushVo();
         if (lisPushVo != null) {
@@ -589,42 +740,39 @@ public class NeoFacade {
     public void filterAndSort(List<String> dises, List<String> allDis, int gender_code, double age, PD pd, List<String> depts) {
         //推送出的所有疾病进行性别和年龄的过滤
         List<Map<String, String>> diseases = null;
-//        Map<String, Double> dis_fbl = new HashMap<>();
-        Map<String, Integer> dis_symptom_num = new HashMap<>();
+        Map<String, Double> dis_fbl = new HashMap<>();
+
         if (ListUtil.isNotEmpty(allDis)) {
             diseases = redisUtil.geth(allDis);
             allDis = diseases.stream().filter(x -> NeoUtil.matchBasic(x, gender_code, age) && NeoUtil.matchPds(x.get("name"), pd)
-            && NeoUtil.matchDept(x,depts)).map(x -> x.get("name")).collect(Collectors.toList());
+                    && NeoUtil.matchDept(x, depts)).map(x -> x.get("name")).collect(Collectors.toList());
 //            diseases.forEach(x -> dis_fbl.put(x.get("name"), Double.parseDouble(x.get("fbl"))));
-            /*List<Map<String, String>> symptomNumOfDis = redisUtil.getSymptomNumOfDis(allDis);
-            if(ListUtil.isNotEmpty(symptomNumOfDis)){
-                symptomNumOfDis.forEach(x -> {
-                    String name = x.get("name");
-                    Integer num = Integer.parseInt(x.get("num"));
-                    dis_symptom_num.put(name,num);
-                });
-            }*/
+            diseases.forEach(x ->{
+                String name = x.get("name");
+                double clafy = Double.parseDouble(x.get("clafy"));
+                dis_fbl.put(name,clafy);
+            });
         }
 
         Map<Long, List<String>> numberDiseasesMap = disCountSort(allDis);
-        if(MapUtils.isNotEmpty(numberDiseasesMap)){
-            for(Map.Entry<Long, List<String>> ds:numberDiseasesMap.entrySet()){
+        /*if (MapUtils.isNotEmpty(numberDiseasesMap)) {
+            for (Map.Entry<Long, List<String>> ds : numberDiseasesMap.entrySet()) {
                 dises.addAll(ds.getValue());
             }
-        }
-        /*//根据发病率排序
+        }*/
+        //根据发病率排序
         //        Map<String, Double> disdistributionCache = self.getDisdistributionCache();
         Map<Long, Map<String, Double>> disPack = new LinkedHashMap<>();
         numberDiseasesMap.forEach((x, y) -> {
             Map<String, Double> collect = y.stream()
-                    .collect(Collectors.toMap(v -> v, v -> Double.valueOf(dis_symptom_num.get(v)), (e1, e2) -> e2));
+                    .collect(Collectors.toMap(v -> v, v -> dis_fbl.get(v), (e1, e2) -> e2));
             disPack.put(x, collect);
         });
         disPack.forEach((x, y) -> {
             //倒序排序
-            *//*Map<String, Double> collect = y.entrySet().stream()
-                    .sorted(Collections.reverseOrder(Map.Entry.comparingByValue()))
-                    .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (e1, e2) -> e2, LinkedHashMap::new));*//*
+//            Map<String, Double> collect = y.entrySet().stream()
+//                    .sorted(Collections.reverseOrder(Map.Entry.comparingByValue()))
+//                    .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (e1, e2) -> e2, LinkedHashMap::new));
             //正序排序
             Map<String, Double> collect = y.entrySet().stream()
                     .sorted(Map.Entry.comparingByValue())
@@ -633,11 +781,11 @@ public class NeoFacade {
             collect.forEach((k, n) -> {
                 dises.add(k);
             });
-        });*/
+        });
     }
 
     public List<String> getDisBySymptom(List<String> symptoms) {
-        List<String> sv = redisUtil.getSv(symptoms,RedisEnum.symptomVitalType.getName());
+        List<String> sv = redisUtil.getSv(symptoms, RedisEnum.symptomVitalType.getName());
         List<String> allDis_bySymptom = pushDisBySymptom(symptomRepository, sv);
         return allDis_bySymptom;
     }
@@ -1143,7 +1291,7 @@ public class NeoFacade {
      * 类型，疾病: disease，症状: symptom，手术和操作:operation，药品: drug，实验室检查：lis，辅助检查：pacs， 辅助检查：vital"
      *
      * @param standConvert
-     * @return Map<String ,   Map   <   String ,   String>> -->Map<类型, Map<原始词, 标准词>>
+     * @return Map<String, Map < String, String>> -->Map<类型, Map<原始词, 标准词>>
      */
     public Map<String, Map<String, String>> standConvertCrf(StandConvert standConvert) {
         Map<String, Map<String, String>> map = new LinkedHashMap<>();
@@ -1280,7 +1428,7 @@ public class NeoFacade {
      * @param map
      */
     public void getConvertMapDisease(Map<String, Map<String, StandConvertCrfDTO>> crfDTO, String type, List<String> convertList,
-                              List<String> originList, Map<String, Map<String, String>> map) {
+                                     List<String> originList, Map<String, Map<String, String>> map) {
         Map<String, String> typeMap = new LinkedHashMap<>();
 
         if (ListUtil.isNotEmpty(convertList)) {

src/main/java/com/diagbot/repository/BaseNodeRepository.java

@@ -51,6 +51,9 @@ public interface BaseNodeRepository extends Neo4jRepository<BaseNode, Long> {
     @Query("match(d:症状) return distinct d.name")
     List<String> getSymptomClass();
 
+    @Query("match(d:医保疾病名称)-[r:医保疾病名称相关典型症状]->(s) return distinct s.name")
+    List<String> getSymptomMain();
+
     @Query("match(d:体征) return distinct d.name")
     List<String> getVitalClass();
 
@@ -115,7 +118,11 @@ public interface BaseNodeRepository extends Neo4jRepository<BaseNode, Long> {
             "case\n" +
             "when d.dept is not null then d.dept\n" +
             "else '医学全科'\n" +
-            "end as dept"
+            "end as dept,\n" +
+            "case\n" +
+            "when d.分类 is not null then toString(d.分类)\n" +
+            "else '2'\n" +
+            "end as clafy"
     )
     List<DiseaseProperty> getDiseaseProperty();
 

src/main/java/com/diagbot/repository/SymptomNameRepository.java

@@ -36,7 +36,7 @@ public interface SymptomNameRepository extends Neo4jRepository<Symptom, Long> {
 //    @Query("match(d:医保疾病名称)-[r]->(s) where any(label in labels(s) WHERE label in ['症状', '体征']) and s.name in {py} return d.name")
     List<String> getDisBySymptoms(@Param("py")List<String> symptoms);
 
-    @Query("match(d:医保疾病名称)-[r:医保疾病名称相关伴随症状]->(s:症状) where s.name in {py} return d.name")
+    @Query("match(d:医保疾病名称)-[r]->(s:症状) where s.name in {py} return d.name")
     List<String> getDisBySymptoms_1(@Param("py")List<String> symptoms);
 
     @Query("match(d:医保疾病名称)-[r:医保疾病名称相关体征]->(s:体征) where s.name in {py} return d.name")

src/main/java/com/diagbot/util/RedisUtil.java

@@ -120,6 +120,12 @@ public class RedisUtil {
         return list;
     }
 
+    public List<Map<String,String>> getSf(List<String> keys,String type) {
+        keys = keys.stream().map(x ->type+x).collect(Collectors.toList());
+        List<Map<String,String>> list = redisTemplate.opsForValue().multiGet(keys);
+        return list;
+    }
+
     /**
      * 根据指定key获取value
      *

src/main/java/com/diagbot/util/StringUtil.java

@@ -11,6 +11,8 @@ import java.util.Date;
 import java.util.List;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
 
 /**
  * @Description: 字符串有关帮助类 封装了第三方帮助类
@@ -276,6 +278,40 @@ public class StringUtil {
         return token;
     }
 
+    /**
+     * 排列组合（字符重复排列）<br>
+     * 内存占用：需注意结果集大小对内存的占用（list:10位，length:8，结果集:[10 ^ 8 = 100000000]，内存占用:约7G）
+     * @param list 待排列组合字符集合
+     * @param length 排列组合生成的字符串长度
+     * @return 指定长度的排列组合后的字符串集合
+     * @author www@yiynx.cn
+     */
+    public static List<String> permutation(List<String> list, int length) {
+        Stream<String> stream = list.stream();
+        for (int n = 1; n < length; n++) {
+            stream = stream.flatMap(str -> list.stream().map(str::concat));
+        }
+        return stream.collect(Collectors.toList());
+    }
+
+    /**
+     * 排列组合(字符不重复排列)<br>
+     * 内存占用：需注意结果集大小对内存的占用（list:10位，length:8，结果集:[10! / (10-8)! = 1814400]）
+     * @param list 待排列组合字符集合(忽略重复字符)
+     * @param length 排列组合生成长度
+     * @return 指定长度的排列组合后的字符串集合
+     * @author www@yiynx.cn
+     */
+    public static List<String> permutationNoRepeat(List<String> list, int length) {
+        Stream<String> stream = list.stream().distinct();
+        for (int n = 1; n < length; n++) {
+            stream = stream.flatMap(str -> list.stream()
+                    .filter(temp -> !str.contains(temp))
+                    .map(str::concat));
+        }
+        return stream.collect(Collectors.toList());
+    }
+
     // 测试主函数
     public static void main(String args[]) {
         System.out.println(StringUtil.isWord("  "));

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

@@ -36,8 +36,10 @@ public class CacheController {
         cacheFacade.loadDrugTypeCache();
         cacheFacade.loadDiseaseTypeCache();
         cacheFacade.getSymptomCache();
+        cacheFacade.getSymptomMainCache();
         cacheFacade.getVitalCache();
         cacheFacade.getSymptomNumCache();
+        cacheFacade.getSymptomFeatureCache();
         return RespDTO.onSuc(true);
     }