推送诊断迁移代码

graph-web/src/main/java/org/diagbot/graphWeb/work/DiseaseCalculate.java

@@ -0,0 +1,36 @@
+package org.diagbot.graphWeb.work;
+
+import org.diagbot.common.work.FeatureRate;
+import org.diagbot.common.work.ResponseData;
+import org.diagbot.common.work.SearchData;
+import org.diagbot.pub.api.Response;
+import org.diagbot.pub.utils.PropertiesUtil;
+import org.diagbot.pub.utils.http.HttpApi;
+
+import javax.servlet.http.HttpServletRequest;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+public class DiseaseCalculate {
+    public ResponseData getDisease(HttpServletRequest request, SearchData searchData) throws Exception {
+        ResponseData responseData = new ResponseData();
+        PropertiesUtil propertiesUtil = new PropertiesUtil("url.properties");
+        //调用图谱API
+        HttpApi<ResponseData> api = new HttpApi<>();
+        ResponseData diseaseResponse = api.doPost(propertiesUtil.getProperty("disease.http.url"), searchData,
+                ResponseData.class);
+        List<FeatureRate> dis = (List<FeatureRate>)diseaseResponse.getDis();
+        List<FeatureRate> diseaseName = new ArrayList<>();
+        for (FeatureRate d:dis) {
+            FeatureRate featureRate = new FeatureRate();
+            featureRate.setFeatureName(d.getFeatureName());
+            featureRate.setExtraProperty(d.getExtraProperty());
+            featureRate.setDesc(d.getDesc());
+            featureRate.setRate(d.getRate());
+            diseaseName.add(featureRate);
+        }
+        responseData.setDis(diseaseName);
+        return responseData;
+    }
+}

graph-web/src/main/resources/url.properties

@@ -1,4 +1,5 @@
 highrisk.http.url=http://192.168.3.112:5004/knowledge/getHighRisk
 lisPacs.http.url=http://192.168.2.234:5004/knowledge/getLisPacs
+disease.http.url=http://192.168.3.112:5004/knowledge/getDisease
 #lisPacs.http.url=http://192.168.3.9:5004/knowledge/getLisPacs
 #highrisk.http.url=http://192.168.3.9:5004/knowledge/getHighRisk

graphdb/src/main/java/org/diagbot/repository/BaseNodeRepository.java

@@ -25,4 +25,30 @@ public interface BaseNodeRepository extends Neo4jRepository<BaseNode, Long> {
     @Query("match (d:Disease)-[r1:推荐]->(m) where d.name in {0} return  labels(m)[0] as label,m.name as name")
     List<Map<String,Object>> getLisPacsList(List diagList);
 
+    // get disease
+    @Query("with {0} as data unwind data as row \n" +
+            "match (n)-[r:属于]->(m)-[r1:组合]->(k) \n" +
+            "where n.name= row \n" +
+            "return m.name as condition, count(distinct r)>=m.path as jundgement, labels(m)[0] as label,k.name as standName")
+    List<Map<String,Object>> getCollectionWord(List inputFilds);
+    @Query("match (n)-[r:诊断依据|:近义词]->(e) where n.name in {0} return n.name as fild,collect(distinct type(r)) as typeCollect")
+    List<Map<String,Object>> getCollectJYWord(List inputFilds);
+    @Query("match(l)-[r:近义词]->(h) where l.name={0} return h.name as js")
+    List<Map<String,Object>> getJYWord(String filds);
+    @Query("with {0} as data unwind data as row \n" +
+            "match (l)-[r:诊断依据]->(m) \n" +
+            "where l.name= row \n" +
+            "with m,{1} as data unwind data as row \n" +
+            "match (n)-[r:诊断依据]->(m) \n" +
+            "where n.name= row \n" +
+            "return m.name as condition, count(distinct r)>=m.path as jundgement, labels(m)[0] as label")
+    List<Map<String,Object>> getCondition(List newList,List inputList);
+    @Query("with {0} as data unwind data as row \n" +
+            "match (n)-[r:确诊|:拟诊]->(m)\n" +
+            "where n.name=row \n" +
+            "with distinct m,r \n" +
+            "return m.name as name, labels(m)[0] as label,type(r) as relationType")
+    List<Map<String,Object>> getDisease(List fildList);
+
+
 }

graphdb/src/main/java/org/diagbot/service/KnowledgeService.java

@@ -6,6 +6,7 @@ import org.diagbot.vo.*;
 import org.diagbot.entity.node.Disease;
 import org.diagbot.entity.node.base.BaseNode;
 import org.diagbot.vo.domain.FeatureRate;
+import org.diagbot.vo.domain.ResponseData;
 import org.diagbot.vo.domain.SearchData;
 
 import java.util.List;
@@ -39,8 +40,10 @@ public interface KnowledgeService {
 
     // 获取高危疾病列表
     Map<String, Object> getHighRiskDisease(SearchData searchData);
-
+    // 获取LIS,PACS
     Map<String,List<FeatureRate>> getLisPacs(SearchData searchData);
+    //获取诊断
+    ResponseData getDis(SearchData searchData);
 
     Map<String, List<Map<String, Object>>> getScale(QueryVo queryVo);
 

graphdb/src/main/java/org/diagbot/service/impl/KnowledgeServiceImpl.java

@@ -10,6 +10,7 @@ import org.diagbot.entity.node.base.BaseNode;
 import org.apache.commons.collections4.IteratorUtils;
 import org.diagbot.repository.*;
 import org.diagbot.vo.domain.FeatureRate;
+import org.diagbot.vo.domain.ResponseData;
 import org.diagbot.vo.domain.SearchData;
 import org.neo4j.driver.v1.types.Node;
 import org.neo4j.driver.v1.types.Path;
@@ -192,6 +193,83 @@ public class KnowledgeServiceImpl implements KnowledgeService {
         return map;
     }
 
+    @Override
+    public ResponseData getDis(SearchData searchData) {
+        ResponseData responseData = new ResponseData();
+        List<String> newList = new ArrayList<>();
+        List<String> inputList = new ArrayList<>();
+        Map<String, Map<String, String>> inputs = searchData.getInputs();
+        Set<String> ss = inputs.keySet();
+        inputList.addAll(ss);
+        //图谱计算是否有组合词
+        List<Map<String, Object>> collectionWord = baseNodeRepository.getCollectionWord(inputList);
+        if(collectionWord !=null && collectionWord.size()>0){
+            for (Map<String, Object> word:collectionWord) {
+                String jundgement = word.get("jundgement").toString();
+                String standName = word.get("standName").toString();
+                if("TRUE".equals(jundgement)){
+                    inputList.add(standName);
+                }
+            }
+        }
+        List<Map<String, Object>> collectJYWord = baseNodeRepository.getCollectJYWord(inputList);
+        if(collectJYWord !=null && collectJYWord.size()>0){
+            for (Map<String, Object> word:collectJYWord) {
+                String fild = word.get("fild").toString();
+                String[] typeCollect = (String[])word.get("typeCollect");
+                if(typeCollect.length == 1 && "近义词".equals(typeCollect[0].toString())){
+                    List<Map<String, Object>> jyWord = baseNodeRepository.getJYWord(fild);
+                    if(jyWord !=null && jyWord.size()>0){
+                        for (Map<String, Object> ji:jyWord) {
+                            String js = ji.get("js").toString();
+                            inputList.remove(fild);
+                            inputList.add(js);
+                        }
+                    }
+                }
+            }
+        }
+        newList.addAll(inputList);
+        while (newList.size()>0){
+            List<Map<String, Object>> condition = baseNodeRepository.getCondition(newList, inputList);
+            newList.clear();
+            if(condition !=null && condition.size()>0){
+                for (Map<String, Object> cd:condition) {
+                    String conditionName = cd.get("condition").toString();
+                    String jundgement = cd.get("jundgement").toString();
+                    if ("true".equals(jundgement)) {
+                        newList.add(conditionName);
+                        inputList.add(conditionName);
+                    }
+                }
+            }
+        }
+        List<String> que = new ArrayList<>();
+        List<Map<String, Object>> disease = baseNodeRepository.getDisease(inputList);
+        if(disease !=null && disease.size()>0){
+            for (Map<String, Object> d: disease) {
+                String diseaseName = d.get("name").toString();
+                String relationType = d.get("relationType").toString();
+                if("确诊".equals(relationType) || "拟诊".equals(relationType)){
+                    que.add(diseaseName);
+                }
+            }
+        }
+        List<FeatureRate> featureRates = new ArrayList<>();
+        if(que !=null && que.size()>0){
+            for (String quezhen:que) {
+                FeatureRate featureRate = new FeatureRate();
+                featureRate.setFeatureName(quezhen);
+                featureRate.setExtraProperty("");
+                featureRate.setDesc("");
+                featureRate.setRate("neo4j");
+                featureRates.add(featureRate);
+            }
+        }
+        responseData.setDis(featureRates);
+        return responseData;
+    }
+
     @Override
     public Map<String, List<FeatureRate>> getLisPacs(SearchData searchData) {
         Map<String, List<FeatureRate>> lisPacsFeature = new HashMap<>();

graphdb/src/main/java/org/diagbot/web/KnowledgeController.java

@@ -160,6 +160,13 @@ public class KnowledgeController {
         kk.setData(responseData);
         return kk;
     }
+    /**
+     * 推送诊断(疑诊)
+     */
+    @RequestMapping("/getDisease")
+    public ResponseData getDis(@Valid @RequestBody SearchData searchData){
+        return knowledgeService.getDis(searchData);
+    }
     /**
      * 给定疾病，获取推荐的化验或辅检项目
      */