推送优化

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

@@ -35,13 +35,16 @@ public class CacheDeleteInit implements CommandLineRunner {
         neoFacade.getSymptomCache();
         log.info("CDSS-CORE服务启动加载图谱症状缓存成功！");
 
-        neoFacade.getDisSexCache();
+        neoFacade.loadDiseaseTypeCache();
+        log.info("CDSS-CORE服务启动加载疾病属性（性别、年龄、发病率）缓存成功！");
+
+        /*neoFacade.getDisSexCache();
         log.info("CDSS-CORE服务启动加载图谱疾病对应性别信息缓存成功！");
 
         neoFacade.getDisAgeCache();
         log.info("CDSS-CORE服务启动加载图谱疾病对应年龄信息缓存成功！");
 
         neoFacade.getDisdistributionCache();
-        log.info("CDSS-CORE服务启动加载图谱疾病对应发病率缓存成功！");
+        log.info("CDSS-CORE服务启动加载图谱疾病对应发病率缓存成功！");*/
     }
 }

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

@@ -0,0 +1,20 @@
+package com.diagbot.entity;
+
+import lombok.Getter;
+import lombok.Setter;
+import org.springframework.data.neo4j.annotation.QueryResult;
+
+/**
+ * @author kwz
+ * @date 2020/10/15
+ * @time 14:23
+ */
+@Getter
+@Setter
+@QueryResult
+public class DiseaseProperty {
+    private String name;
+    private String sex;
+    private String age;
+    private String fbl;
+}

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

@@ -11,7 +11,8 @@ import lombok.Setter;
 
 public enum RedisEnum implements KeyedNamed {
 
-    drugType(1, "drugType:");
+    drugType(1, "drugType:"),
+    diseaseType(2, "diseaseType:");
 
     @Setter
     private int key;

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

@@ -6,6 +6,7 @@ import com.diagbot.biz.push.entity.Lis;
 import com.diagbot.client.ChiefPresentSimilarityServiceClient;
 import com.diagbot.client.StandConvertServiceClient;
 import com.diagbot.dto.*;
+import com.diagbot.entity.DiseaseProperty;
 import com.diagbot.entity.node.*;
 import com.diagbot.enums.RedisEnum;
 import com.diagbot.enums.StandConvertEnum;
@@ -136,6 +137,27 @@ public class NeoFacade {
         }
         return res;
     }
+
+    public void diseasePropertyCache(){
+        List<DiseaseProperty> diseaseProperty = nodeRepository.getDiseaseProperty();
+        if(ListUtil.isNotEmpty(diseaseProperty)){
+            diseaseProperty.parallelStream().forEach(
+                    x ->{
+                        String name = x.getName();
+                        String sex = x.getSex();
+                        String age = x.getAge();
+                        String fbl = x.getFbl();
+                        Map<String,String> desc = new HashMap<>();
+                        desc.put("name",name);
+                        desc.put("sex",sex);
+                        desc.put("age",age);
+                        desc.put("fbl",fbl);
+                        redisUtil.updateValue(desc,RedisEnum.diseaseType.getName() + name);
+                    }
+            );
+
+        }
+    }
     /**
      * 返回图谱中所有症状缓存信息
      *
@@ -198,6 +220,17 @@ public class NeoFacade {
         }
         return disdistribution;
 
+    }
+
+    /**
+     * 加载疾病类型缓存（疾病的年龄、性别、发病率）
+     *
+     * @return
+     */
+    public void loadDiseaseTypeCache() {
+        redisUtil.deleteByPrex(RedisEnum.diseaseType.getName());
+        this.diseasePropertyCache();
+
     }
     /**
      * 图谱反推的数据
@@ -235,11 +268,13 @@ public class NeoFacade {
         }
         if(ListUtil.isNotEmpty(lises)){
             List<String> lis_dis = lises.parallelStream()
-                    .map(x -> nodeRepository.getDisByLis_Special(x.getUniqueName(), x.getDetailName()))
+                    .map(x -> nodeRepository.getDisByLis_Special(x.getName(), x.getUniqueName()+x.getResult()))
                     .flatMap(List::stream).collect(Collectors.toList());
-            filterAndSort(neoPushDTOS,lis_dis);
-            if(ListUtil.isNotEmpty(neoPushDTOS)){
-                return neoPushDTOS;
+            if(ListUtil.isNotEmpty(lis_dis)){
+                filterAndSort(neoPushDTOS,lis_dis,sex,age);
+                if(ListUtil.isNotEmpty(neoPushDTOS)){
+                    return neoPushDTOS;
+                }
             }
         }
 
@@ -286,20 +321,28 @@ public class NeoFacade {
                 allDis.addAll(allDis_byPacsResult);
             }
         }
-        filterAndSort(neoPushDTOS, allDis);
+        filterAndSort(neoPushDTOS, allDis,sex,age);
 
         return neoPushDTOS;
     }
 
-    private void filterAndSort(List<NeoPushDTO> neoPushDTOS, List<String> allDis) {
+    private void filterAndSort(List<NeoPushDTO> neoPushDTOS, List<String> allDis, int gender_code, double age) {
         //推送出的所有疾病进行性别和年龄的过滤
+        List<Map<String,String>> diseases = null;
+        Map<String,Double> dis_fbl = new HashMap<>();
+        if(ListUtil.isNotEmpty(allDis)){
+            diseases = redisUtil.get(allDis);
+            allDis = diseases.stream().filter(x -> NeoUtil.matchBasic(x,gender_code,age)).map(x -> x.get("name")).collect(Collectors.toList());
+            diseases.forEach(x -> dis_fbl.put(x.get("name"),Double.parseDouble(x.get("fbl"))));
+        }
+
         Map<Long,List<String>> numberDiseasesMap = disCountSort(allDis);
         //根据发病率排序
-        Map<String, Double> disdistributionCache = self.getDisdistributionCache();
+//        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 -> disdistributionCache.get(v) != null?disdistributionCache.get(v):0.0, (e1, e2) -> e2));
+                    .collect(Collectors.toMap(v -> v, v -> dis_fbl.get(v), (e1, e2) -> e2));
             disPack.put(x,collect);
         });
         disPack.forEach((x,y)->{

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

@@ -5,6 +5,7 @@ import com.diagbot.dto.PushPlanDTO;
 import com.diagbot.dto.WordCrfDTO;
 import com.diagbot.process.PushProcess;
 import com.diagbot.util.CoreUtil;
+import com.diagbot.util.ParamUtil;
 import com.diagbot.vo.PushPlanVO;
 import com.diagbot.vo.PushVO;
 import com.diagbot.vo.StandConvert;
@@ -53,6 +54,7 @@ public class PushFacade {
         Map<String, Map<String, String>> standConvertMap = neoFacade.standConvertCrf(standConvert);
         commonFacade.dataTypeSet(wordCrfDTO, standConvertMap);
         CoreUtil.getDebugStr(standStart, "标准词转换耗时", debug);
+        ParamUtil.dealLis(wordCrfDTO.getLis());
 
         // 推送
         long pushStart = System.currentTimeMillis();

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

@@ -1,6 +1,7 @@
 package com.diagbot.repository;
 
 
+import com.diagbot.entity.DiseaseProperty;
 import com.diagbot.entity.node.*;
 import com.diagbot.entity.node.base.BaseNode;
 import org.springframework.data.neo4j.annotation.Query;
@@ -46,7 +47,7 @@ public interface BaseNodeRepository extends Neo4jRepository<BaseNode, Long> {
     List<String> getDisByLis(@Param("lisBig") String lisBig,@Param("subres") String subres);
 
     //化验查疾病（有特异性）
-    @Query("match(d:医保疾病名称)-[r1]->(l:化验套餐名称{name:{lisBig}})-[r:化验套餐名称相关化验细项及结果]->(lr:化验细项及结果{name:{subres}}),(d)-[r2]->(lr) where lr.特异性=1 return d.name")
+    @Query("match(d:医保疾病名称)-[r1]->(l:化验套餐名称{name:{lisBig}})-[r:化验套餐名称相关化验细项及结果]->(lr:化验细项及结果{name:{subres}}),(d)-[r2]->(lr) where lr.special='是' return d.name")
     List<String> getDisByLis_Special(@Param("lisBig") String lisBig,@Param("subres") String subres);
 
     @Query("match(d:医保疾病名称)-[r:医保疾病名称相关性别]->(h) return DISTINCT d.name+'&'+h.name")
@@ -82,4 +83,20 @@ public interface BaseNodeRepository extends Neo4jRepository<BaseNode, Long> {
     @Query("MATCH (n) WHERE labels(n)[0]={lab} and n.name={nm} set n.静态知识标识={sign}")
     void updateStaticKnowledgeSign(@Param("lab") String lab,@Param("nm") String nm,@Param("sign") Integer sign);
 
+    @Query("match(d:医保疾病名称)\n" +
+            "return d.name as name, case \n" +
+            "when d.sex is not null then d.sex\n" +
+            "else '3'\n" +
+            "end as sex,\n" +
+            "case\n" +
+            "when d.age is not null then d.age\n" +
+            "else '0-200'\n" +
+            "end as age,\n" +
+            "case\n" +
+            "when d.fbl is not null then d.fbl\n" +
+            "else '0'\n" +
+            "end as fbl")
+    List<DiseaseProperty> getDiseaseProperty();
+
+
 }

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

@@ -11,6 +11,7 @@ import com.diagbot.repository.datautil;
 
 import java.math.BigDecimal;
 import java.util.List;
+import java.util.Map;
 
 public class NeoUtil {
 
@@ -144,6 +145,25 @@ public class NeoUtil {
         return match;
     }
 
+    public static boolean matchBasic(Map<String,String> disease, int gender_code, double age){
+        boolean match = true;
+        if(disease != null){
+            String gender_neo4j = disease.get("sex");
+            String age_neo4j = disease.get("age");
+            if((gender_neo4j != null && gender_neo4j.equals("1") && gender_code != 1) ||
+                    (gender_neo4j != null && gender_neo4j.equals("2") && gender_code != 2)){
+                match = false;
+            }else if(age_neo4j != null ){
+                String[] betweenAge = age_neo4j.split("-");
+                if(betweenAge.length == 2 && (age < Double.parseDouble(betweenAge[0])
+                        || age > Double.parseDouble(betweenAge[1]))){
+                    match = false;
+                }
+            }
+        }
+        return match;
+    }
+
 
     public static NodeNeoDTO fillNodeNeoDTO(Vital vital) {
         NodeNeoDTO nodeNeoDTO = new NodeNeoDTO();

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

@@ -1,9 +1,13 @@
 package com.diagbot.util;
 
+import com.diagbot.enums.RedisEnum;
 import org.apache.commons.collections4.CollectionUtils;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.dao.DataAccessException;
+import org.springframework.data.redis.core.RedisOperations;
 import org.springframework.data.redis.core.RedisTemplate;
+import org.springframework.data.redis.core.SessionCallback;
 import org.springframework.stereotype.Component;
 
 import java.util.Collection;
@@ -89,6 +93,18 @@ public class RedisUtil {
         return redisTemplate.opsForValue().get(key);
     }
 
+    public List<Map<String,String>> get(List<String> keys) {
+        return redisTemplate.executePipelined(new SessionCallback<Object>() {
+            @Override
+            public Map<String,String> execute(RedisOperations redisOperations) throws DataAccessException {
+                for (String dis:keys) {
+                    redisOperations.opsForValue().get(RedisEnum.diseaseType.getName()+dis);
+                }
+                return null;
+            }
+        });
+    }
+
     /**
      * 根据指定key获取value
      *