新推送逻辑(主症状细致拆分)

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

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

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

@@ -16,6 +16,7 @@ public enum RedisEnum implements KeyedNamed {
     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();
+
+    }
+
     /**
      * 加载图谱中的体征缓存
      *

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

@@ -47,6 +47,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
@@ -181,6 +183,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)) {
@@ -200,6 +214,7 @@ public class NeoFacade {
                     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());
@@ -497,14 +512,86 @@ public class NeoFacade {
         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())){
+            /*if(ListUtil.isEmpty(disBySymptom_main) && ListUtil.isNotEmpty(pushVO.getSymptoms())){
                 String s_second = pushVO.getSymptoms().get(0);
                 disBySymptom_main = nodeRepository.getDisBySymptom_main(s_second);
+            }*/
+            if(ListUtil.isEmpty(disBySymptom_main)){
+                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(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);
+                        });
+                    }
+                    if(MapUtils.isNotEmpty(min_filds)){
+                        Map<Integer, List<String>> fild_pailie = Maps.newHashMap();
+                        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);
+                                }
+                            }
+                        });
+                        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());
+                                if(ListUtil.isNotEmpty(sv)){
+                                    disBySymptom_main = nodeRepository.getDisBySymptom_main(sv.get(0));
+                                    break;
+                                }
+                            }
+                        }
+                    }
+                }
             }
         }
         return disBySymptom_main;
     }
 
+    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();

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();
 

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,6 +36,7 @@ public class CacheController {
         cacheFacade.loadDrugTypeCache();
         cacheFacade.loadDiseaseTypeCache();
         cacheFacade.getSymptomCache();
+        cacheFacade.getSymptomMainCache();
         cacheFacade.getVitalCache();
         cacheFacade.getSymptomNumCache();
         cacheFacade.getSymptomFeatureCache();