Merge remote-tracking branch 'origin/master'

common-service/src/main/java/org/diagbot/common/work/SearchData.java

@@ -34,6 +34,9 @@ public class SearchData {
     //大数据推送诊断结果信息
     protected List<FeatureRate> pushDiags = new ArrayList<>();
 
+    //量表
+    protected String scaleName = "";
+
     //模型
     protected String algorithmClassifyValue;
     //推送条件
@@ -199,6 +202,14 @@ public class SearchData {
         this.other = other;
     }
 
+    public String getScaleName() {
+        return scaleName;
+    }
+
+    public void setScaleName(String scaleName) {
+        this.scaleName = scaleName;
+    }
+
     public String getAlgorithmClassifyValue() {
         return algorithmClassifyValue;
     }

graph-web/src/main/java/org/diagbot/graphWeb/controller/GraphController.java

@@ -2,6 +2,8 @@ package org.diagbot.graphWeb.controller;
 
 import com.alibaba.fastjson.JSONObject;
 import org.diagbot.graph.javabean.GdbResponse;
+import org.diagbot.graph.jdbc.DriverManager;
+import org.diagbot.graph.jdbc.Neo4jAPI;
 import org.diagbot.graphWeb.dao.BackResponse;
 import org.diagbot.graphWeb.work.GraphCalculate;
 import org.diagbot.graphWeb.work.HighRiskCalculate;
@@ -15,10 +17,41 @@ import org.springframework.web.bind.annotation.RequestMethod;
 import org.springframework.web.bind.annotation.ResponseBody;
 
 import javax.servlet.http.HttpServletRequest;
+import java.util.Map;
+
+import static org.diagbot.graph.jdbc.DriverManager.propertiesUtil;
 
 @Controller
 @RequestMapping("/graph")
 public class GraphController {
+    @RequestMapping(value = "/push", method = RequestMethod.POST)
+    @ResponseBody
+    public Response<ResponseData> bayesPageData(HttpServletRequest request, @RequestBody SearchData searchData) throws Exception {
+        Response<ResponseData> response = new Response();
+        GraphCalculate graphCalculate = new GraphCalculate();
+        ResponseData responseData = graphCalculate.calculate(request, searchData);
+        response.setData(responseData);
+        return response;
+    }
+
+    @RequestMapping(value = "/highRisk", method = RequestMethod.POST)
+    @ResponseBody
+    public Response<GdbResponse> getHighRisk(HttpServletRequest request, @RequestBody SearchData searchData) throws Exception {
+        HighRiskCalculate highRiskCalculate = new HighRiskCalculate();
+        Response<GdbResponse> gdbResponseResponse = highRiskCalculate.calculateHighRisk(request, searchData);
+        return gdbResponseResponse;
+    }
+
+    @RequestMapping(value = "/lisPacs", method = RequestMethod.POST)
+    @ResponseBody
+    public Response<ResponseData> lisPacsData(HttpServletRequest request, @RequestBody SearchData searchData) throws Exception {
+        Response<ResponseData> response = new Response();
+        GraphCalculate graphCalculate = new GraphCalculate();
+        ResponseData responseData = graphCalculate.getLisPacs(request, searchData);
+        response.setData(responseData);
+        return response;
+    }
+
 
 }
 

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

@@ -90,11 +90,13 @@ public class GraphCalculate {
         String webDiag = searchData.getDiag();
         List<String> webDiagList = Arrays.asList(webDiag.split(",|，|、"));
         List<FeatureRate> bigdataDiagFeature = searchData.getPushDiags();
-        List<String> bigdataDiagList =new ArrayList<>();
+        List<String> bigdataDiagList =new LinkedList<>();
         if(bigdataDiagFeature.size()>0){
             for (FeatureRate fe:bigdataDiagFeature) {
                 if("neo4j".equals(fe.getRate())){
                     bigdataDiagList.add(fe.getFeatureName());
+                }else {
+                    bigdataDiagList.add(fe.getFeatureName());
                 }
             }
         }

graph/src/main/java/org/diagbot/graph/Diagnose/DiagnoseMain.java

@@ -16,8 +16,12 @@ public class DiagnoseMain {
 //                "侵袭性骨破坏","右上腹痛","向右背部放射","墨菲斯征阳性","白细胞增多","不洁饮食","胆囊内有强回声团");
 //        Map<String, String> diagnose = new DiagnoseProcess().getDiagnose(
 //                "上腹痛","墨菲斯征阳性","白细胞增多","不洁饮食","胆囊内有强回声团");
+//        Map<String, String> diagnose = new DiagnoseProcess().getDiagnose(
+//                "咽痛","鼻塞","乏力","淋巴结肿大","扁桃体肿大","上腹痛","墨菲斯征阳性","白细胞增多","不洁饮食","胆囊内有强回声团","近端指间关节炎","足关节炎","对称性关节肿胀",
+//                "晨僵≥30分钟","类风湿因子阳性","抗CCP抗体阳性","胸腔积液","呼吸音减弱","发热","胸痛","呼吸困难","咳嗽");
         Map<String, String> diagnose = new DiagnoseProcess().getDiagnose(
-                "咽痛","鼻塞","乏力","淋巴结肿大","扁桃体肿大","上腹痛","墨菲斯征阳性","白细胞增多","不洁饮食","胆囊内有强回声团","近端指间关节炎","足关节炎","对称性关节肿胀","晨僵≥30分钟","类风湿因子阳性","抗CCP抗体阳性");
+                "咽痛","鼻塞","乏力","淋巴结肿大","扁桃体肿大","上腹痛","墨菲斯征阳性","白细胞增多","不洁饮食","胆囊内有强回声团","近端指间关节炎","足关节炎","对称性关节肿胀",
+                "晨僵≥30分钟","类风湿因子阳性","抗CCP抗体阳性","胸腔积液","呼吸音减弱","发热","咳嗽");
         for (Map.Entry<String,String> disease:diagnose.entrySet()) {
             System.out.println(disease.getKey()+"\t"+disease.getValue());
         }

graph/src/main/java/org/diagbot/graph/Diagnose/DiagnoseProcess.java

@@ -21,18 +21,28 @@ public class DiagnoseProcess {
         //获取driver和session
         Driver driver = DriverManager.newDrive("192.168.2.232","neo4j","root");
         Session session = driver.session(AccessMode.READ);
-        //第一步查找近义词.化验或辅检项目
-        String searchJinyici = propertiesUtil.getProperty("searchJinyici");
-        String fildList = searchJinyici.replace("fildList", startList.toString());
-        query = fildList;
+        //第一步查找近义词
+//        String searchJinyici = propertiesUtil.getProperty("searchJinyici");
+//        String fildList = searchJinyici.replace("fildList", startList.toString());
+        query = propertiesUtil.getProperty("serchCollect").replace("fildList",startList.toString());;
 //        System.out.println("查找近义词语句:"+query+"\n");
         run = session.run(query);
         while (run.hasNext()){
-            Record next = run.next();
-            String c = next.get("zi").toString();
-            String d = next.get("fu").toString();
-            startList.remove(c);
-            startList.add(d);
+            Record record = run.next();
+            String fild = record.get("fild").toString();
+            List<Object> typeCollect = record.get("typeCollect").asList();
+            //如果不包含诊断依据就找它的同义词,否则就要这个词
+            if("近义词".equals(typeCollect.get(0)) && typeCollect.size() ==1){
+                query = "match(l)-[r:近义词]->(h) where l.name="+fild+" return h.name as js";
+                StatementResult jinyiResult = session.run(query);
+                while (jinyiResult.hasNext()){
+                    Record next = jinyiResult.next();
+                    String js = next.get("js").toString();
+                    startList.remove(fild);
+                    startList.add(js);
+                }
+
+            }
         }
         newList.addAll(startList);
         int i =0;

graph/src/main/java/org/diagbot/graph/encryptionNeo4j/ReadNeo4jData2Neo4j.java

@@ -17,6 +17,7 @@ public class ReadNeo4jData2Neo4j{
     public static PropertiesUtil propertiesUtil = new PropertiesUtil("query.properties");
     public static void main(String[] args) {
         String[] diseaseArray ={"慢性胃炎","急性胰腺炎","心脏病","肺部感染"};
+//        String[] diseaseArray ={"肺部感染"};
         NodeRelationUtil nodeRelationUtil = new NodeRelationUtil();
         Driver driver233 = nodeRelationUtil.getDriver();//读
         Driver driver232 = nodeRelationUtil.get232Driver();//写
@@ -45,7 +46,6 @@ public class ReadNeo4jData2Neo4j{
         List<String> diseaseNameList;
         String queryWord;
         StatementResult resultSet;
-
         diseaseNameList = new ArrayList<String>(Arrays.asList(diseaseArray));
         for (String diseaseName:diseaseNameList) {
             nodeRelationUtil.AddNode(driver,0,"Disease",diseaseName.replace("\"",""));//添加疾病
@@ -53,15 +53,42 @@ public class ReadNeo4jData2Neo4j{
             resultSet = session.run(queryWord);
             while (resultSet.hasNext()){
                 Record record = resultSet.next();
-                String drug = record.get("drug").toString();//药类
-                String label = record.get("label").toString();//类型
-                int p = Integer.parseInt(record.get("p").toString());//药类的排序
+                String drug = record.get("drug").toString().replace("\"","");//药类
+                String label = record.get("label").toString().replace("\"","");//类型
                 int p1 = record.get("p").asInt();
                 List<Object> collectName = record.get("collectName").asList();
-                System.out.println(drug+"\t"+label+"\t"+p+"\t"+collectName);
+                String s = collectName.get(0).toString();
+                nodeRelationUtil.AddNode(driver,0,"Drugs",drug);
+                nodeRelationUtil.addRelationWithProperty(driver,"Disease",diseaseName.replace("\"",""),"推荐",p1,"Drugs",drug);
+                for (Object o:collectName) {
+                    String medicationName = o.toString();
+                    nodeRelationUtil.AddNode(driver,0,"Medicine",medicationName);
+                    nodeRelationUtil.addRelation(driver,0,"Drugs",drug,"包含","Medicine",medicationName);
+                }
+            }
+            queryWord = propertiesUtil.getProperty("diseaseMedication").replace("diseaseName",diseaseName);
+            resultSet = session.run(queryWord);
+            while (resultSet.hasNext()){
+                Record record = resultSet.next();
+                double p1 = record.get("p").asDouble();
+                String medication = record.get("collectName").toString().replace("\"","");//类型
+                nodeRelationUtil.AddNode(driver,0,"Medicine",medication);
+                nodeRelationUtil.addRelationWithPropertyDouble(driver,"Disease",diseaseName.replace("\"",""),"推荐",p1,"Medicine",medication);
+            }
+            queryWord = propertiesUtil.getProperty("bigDrugAndSubDrugs").replace("diseaseName",diseaseName);
+            resultSet = session.run(queryWord);
+            while (resultSet.hasNext()){
+                Record record = resultSet.next();
+                String bigDrugs = record.get("big").toString().replace("\"","");//大类型
+                String subDrugs = record.get("sub").toString().replace("\"","");//小类型
+                nodeRelationUtil.AddNode(driver,0,"Drugs",bigDrugs);
+                nodeRelationUtil.AddNode(driver,0,"Drugs",subDrugs);
+                nodeRelationUtil.addRelation(driver,0,"Drugs",bigDrugs,"包含","Drugs",subDrugs);
+                nodeRelationUtil.addRelation(driver,0,"Disease",diseaseName.replace("\"",""),"推荐","Drugs",bigDrugs);
             }
         }
     }
+
     private static void from233to232(String[] diseaseArray,NodeRelationUtil nodeRelationUtil, Driver driver232, Session session) {
         List<String> diseaseList;
         String query;

graph/src/main/java/org/diagbot/graph/jdbc/Neo4jAPI.java

@@ -63,7 +63,7 @@ public class Neo4jAPI {
 
             while (Rset.hasNext()) {
                 rec = Rset.next();
-//                System.out.println(rec);
+                //                System.out.println(rec);
                 String lbl = rec.get(key).toString();
                 jobj.put(lbl.substring(1, lbl.length() - 1), rec.get(val).toString());
             }
@@ -256,7 +256,7 @@ public class Neo4jAPI {
                     coll.put(name, (Object) jobj);
                 }
 
-//                System.out.println(name + "\t" + lbl + "\t" + JSONUtils.toJSONString(Result));
+                //                System.out.println(name + "\t" + lbl + "\t" + JSONUtils.toJSONString(Result));
             }
 
             for (String key : coll.keySet()) {
@@ -406,7 +406,7 @@ public class Neo4jAPI {
 
             resmap.put(name, content);
             res = JSONUtils.toJSONString(resmap);
-//            System.out.println(res);
+            //            System.out.println(res);
         } catch (Exception ex) {
             ex.printStackTrace();
         } finally {
@@ -434,7 +434,7 @@ public class Neo4jAPI {
             switch (option) {
                 case "-1":
                     RemovePath(start, end, oldrel);
-//                    Res = GetPath(name, label, "1");
+                    //                    Res = GetPath(name, label, "1");
                     break;
                 case "0":
                     Res = GetPath(name, label, level);
@@ -653,12 +653,29 @@ public class Neo4jAPI {
         String query = "";
         try {
             session = driver.session(AccessMode.WRITE);
-            //判断是否有近义词
+            query = propertiesUtil.getProperty("serchCollect").replace("fildList",fildList.toString());
+            result = session.run(query);
+            while (result.hasNext()){
+                Record record = result.next();
+                String fild = record.get("fild").toString();
+                List<Object> typeCollect = record.get("typeCollect").asList();
+                //如果不包含诊断依据就找它的同义词,否则就要这个词
+                if("近义词".equals(typeCollect.get(0)) && typeCollect.size() ==1){
+                    query = "match(l)-[r:近义词]->(h) where l.name="+fild+" return h.name as js";
+                    StatementResult jinyiResult = session.run(query);
+                    while (jinyiResult.hasNext()){
+                        Record next = jinyiResult.next();
+                        String js = next.get("js").toString();
+                        fildList.remove(fild);
+                        fildList.add(js);
+                    }
+
+                }
+            }
+/*            //判断是否有近义词
             query = "match (l)-[r:近义词]->(m)\n" +
                     "where l.name in  " + fildList + "\n" +
                     "return l.name as zi,type(r),m.name as fu";
-//            System.out.println("近义词语句:");
-//            System.out.println(query);
             result = session.run(query);
             while (result.hasNext()) {
                 Record record = result.next();
@@ -666,7 +683,7 @@ public class Neo4jAPI {
                 String d = record.get("fu").toString();
                 fildList.remove(c);
                 fildList.add(d);
-            }
+            }*/
 //            System.out.println("参与计算的词:"+fildList);
             newList.addAll(fildList);
             int i = 0;
@@ -700,9 +717,6 @@ public class Neo4jAPI {
                     "where n.name=row\n" +
                     "with distinct m,r\n" +
                     "return m.name as name, labels(m)[0] as label,type(r) as relationType";
-//            System.out.println("查询确诊和拟诊:");
-//            System.out.println(query);
-
             result = session.run(query);
             while (result.hasNext()) {
                 Record record = result.next();
@@ -905,7 +919,7 @@ public class Neo4jAPI {
                         for (Map.Entry<String, LinkedHashMap<String, String>> w : mapSortValueDa.entrySet()) {
                             int i = 0;
                             Drugs drugs1 = new Drugs();
-//                                drugs1.setDrugsName(w.getKey().trim());//药类
+                            //                                drugs1.setDrugsName(w.getKey().trim());//药类
                             LinkedList<Medicition> medicitions = new LinkedList<>();
                             LinkedHashMap<String, String> value2 = w.getValue();
                             for (Map.Entry<String, String> d : value2.entrySet()) {
@@ -960,7 +974,7 @@ public class Neo4jAPI {
         nf.setMinimumFractionDigits(0);//设置该百分比数字，保留2位小数;
         nf.setRoundingMode(RoundingMode.HALF_UP); //设置满5向上进位，即四舍五入;
         Map<String, String> resultMap = new HashMap<>();
-        String[] diseaseArray = disease.split(",|，|、");
+        String[] diseaseArray = disease.split(",|，|、|;|:|；");
         List<String> diseaseList = new ArrayList<>();//诊断数组
         for (int i = 0; i < diseaseArray.length; i++) {
             diseaseList.add(diseaseArray[i]);
@@ -1013,7 +1027,7 @@ public class Neo4jAPI {
                         }
                         //药类型的大小类拼接
                         Map<String, String> shortLargeMap = new HashMap<>();
-//                        query="match (n:Disease{name:'"+diseaseName+"'})-[:推荐]->(d:Drugs)<-[:包含]-(m) return d.name as short,m.name as large";
+                        //                        query="match (n:Disease{name:'"+diseaseName+"'})-[:推荐]->(d:Drugs)<-[:包含]-(m) return d.name as short,m.name as large";
                         query = "match (n:Disease{name:'" + diseaseName + "'})-[r0:推荐]->(m:Drugs)-[:包含]->(k:Drugs) return k.name as short,m.name as large";
                         result = tx.run(query);
                         while (result.hasNext()) {
@@ -1052,11 +1066,11 @@ public class Neo4jAPI {
                          * 查找药类的忌用
                          */
                         Map<String, String> drugsUseMap = new HashMap<>();//key:药名 value:禁忌(慎用)
-                        query = "match (n:Disease{name:'急性胰腺炎'})-[:推荐]->(d:Drugs)<-[r0:慎用]-(m)\n" +
+                        query = "match (n:Disease{name:'"+diseaseName+"'})-[:推荐]->(d:Drugs)<-[r0:慎用]-(m)\n" +
                                 "where m.name in " + value + "" +
                                 "return d.name as ff,type(r0) as hh\n" +
                                 "union\n" +
-                                "match (n:Disease{name:'急性胰腺炎'})-[:推荐]->(d:Drugs)<-[r0:忌用]-(m)\n" +
+                                "match (n:Disease{name:'"+diseaseName+"'})-[:推荐]->(d:Drugs)<-[r0:忌用]-(m)\n" +
                                 "where m.name in " + value + "" +
                                 "return d.name as ff,type(r0) as hh";
                         result = tx.run(query);
@@ -1073,7 +1087,7 @@ public class Neo4jAPI {
                             int i = 0;
                             Drugs drugs = new Drugs();
                             String drugsName = w.getKey();//药类
-//                            Map<String, String> bigSubDrugs = new DrugsPattern().bigSubDrugs(drugsName);
+                            //                            Map<String, String> bigSubDrugs = new DrugsPattern().bigSubDrugs(drugsName);
                             Map<String, String> bigSubDrugs = drugsPattern.bigSubDrugs(drugsName);
                             drugs.setBigdrugsName(bigSubDrugs.get("big"));
                             drugs.setSubdrugsName(bigSubDrugs.get("sub"));
@@ -1214,9 +1228,9 @@ public class Neo4jAPI {
      * @return
      */
     public Map<String, List> getPushBack(String diseaseName, int sign) {
-//        Map<String, String> labelMap = new HashMap<>();
+        //        Map<String, String> labelMap = new HashMap<>();
         HashMap<String, List> backMap = new HashMap<>();
-        String[] label = {"Symptom", "Vital", "LIS", "PACS", "History"};
+        String[] label = { "Symptom", "Vital", "LIS", "PACS", "History" };
         Session session = null;
         StatementResult result = null;
         String query = "";
@@ -1425,7 +1439,7 @@ public class Neo4jAPI {
                         "when m.判断1= \"大于等于\" and m.单位=row.units then row.value >= m.判断系数1\n" +
                         "when m.判断1= \"小于\" and m.单位=row.units then row.value < m.判断系数1\n" +
                         "when m.判断1= \"小于等于\" and m.单位=row.units then row.value <= m.判断系数1\n" +
-//                        "when m.单位<>row.unit and m.单位 is not null then '单位不同'\n" +
+                        //                        "when m.单位<>row.unit and m.单位 is not null then '单位不同'\n" +
                         "else 'Unknown'\n" +
                         "end as judgement1,\n" +
                         "case\n" +
@@ -1441,7 +1455,7 @@ public class Neo4jAPI {
                         "when m.判断2 = \"大于等于\" and m.单位=row.units then row.value >= m.判断系数2\n" +
                         "when m.判断2 = \"小于\" and m.单位=row.units then row.value < m.判断系数2\n" +
                         "when m.判断2 = \"小于等于\" and m.单位=row.units then row.value <= m.判断系数2\n" +
-//                        "when m.单位<>row.unit and m.单位 is not null then '单位不同'\n" +
+                        //                        "when m.单位<>row.unit and m.单位 is not null then '单位不同'\n" +
                         "else 'Unknown'\n" +
                         "end as judgement2\n" +
                         "return m.name as LIS_Result,\n" +
@@ -1449,13 +1463,13 @@ public class Neo4jAPI {
                         "when judgement1 = True and judgement2 = True then True\n" +
                         "when judgement1 = True and judgement2 = '未定义' then True\n" +
                         "when judgement2 = True and judgement1 = '未定义' then True\n" +
-//                        "when judgement2 = '单位不同' or judgement1 = '单位不同' then 'Unknown'\n" +
-//                        "when judgement2 = '未定义' and judgement1 = '未定义' then 'Unknown'\n" +
-//                        "when judgement2 is null or judgement1 is null then 'Unknown'\n" +
-//                        "when judgement2 = false or judgement1 = false then false\n" +
+                        //                        "when judgement2 = '单位不同' or judgement1 = '单位不同' then 'Unknown'\n" +
+                        //                        "when judgement2 = '未定义' and judgement1 = '未定义' then 'Unknown'\n" +
+                        //                        "when judgement2 is null or judgement1 is null then 'Unknown'\n" +
+                        //                        "when judgement2 = false or judgement1 = false then false\n" +
                         "else False end as judgement order by LIS_Result";
 
-//                System.out.println(query);
+                //                System.out.println(query);
 
                 StatementResult run = session.run(query);
                 while (run.hasNext()) {
@@ -1595,4 +1609,188 @@ public class Neo4jAPI {
         }
         return graphWordsList;
     }
+
+    /**
+     * 根据是否需要计算调取相应返回量表的方法
+     *
+     * @param scaleName
+     * @return
+     */
+    public Map<String, Object> getScale(String scaleName) {
+        Session session = driver.session(AccessMode.READ);
+        StatementResult Rset;
+        scaleName = scaleName.toUpperCase();
+        Map<String, Object> scale = new LinkedHashMap<>();
+
+        try {
+            String query = "match (m:Scale) WHERE m.name=~'.*" + scaleName + ".*' return m.type";
+            Rset = session.run(query);
+            String type = Rset.next().get("m.type").toString().replace("\"", "");
+            if ("NoCalc".equals(type)) {
+                scale = this.getScaleNoCalc(scaleName);
+            } else {
+                scale = this.getScaleCalc(scaleName);
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+            System.out.println("调量表方法时出了问题！");
+        } finally {
+            CloseSession(session);
+            return scale;
+        }
+
+    }
+
+    /**
+     * 返回带得分需要计算的量表
+     *
+     * @param scaleName
+     * @return
+     */
+    public Map<String, Object> getScaleCalc(String scaleName) {
+        Session session = driver.session(AccessMode.READ);
+        StatementResult Rset1 = null;
+        StatementResult Rset2 = null;
+        Record rec;
+        scaleName = scaleName.toUpperCase();
+
+        //<年龄,<<=44,0>>   最外层
+        Map<String, Object> twoLevelItems = new LinkedHashMap<>();
+        //第二层
+        Map<String, Object> threeLevelItems = new LinkedHashMap<>();
+        //<<=44,0>
+        Map<Object, Object> itemOrIndex = new LinkedHashMap<>();
+
+        try {
+            String query1 = "match (m:Scale)-[r1]->(n1)-[r2]->(n2) WHERE m.name=~'.*" + scaleName + ".*' return n1.name,r1.score,n2.name," +
+                    "r2.score,n2.type,r2.p order by toInt(r2.p),n2.type";
+
+            String query2 = "match (m:Scale)-[r1]->(n1)-[r2]->(n2)-[r3]->(n3) WHERE m.name=~'.*" + scaleName + ".*' return n1.name,r1.score,n2.name," +
+                    "r2.score,n3.name,r3.score,r3.p,n3.type order by toInt(r2.p),n2.type";
+            writeLog(query1);
+            Rset1 = session.run(query1);
+            Rset2 = session.run(query2);
+            writeLog(query2);
+
+            String item = "";
+            String optionOrIndex = "";
+            String score1 = "";
+            String index = "";
+            String score2 = "";
+
+            while (Rset1.hasNext()) {
+                rec = Rset1.next();
+                item = rec.get("n1.name").toString().replace("\"", "");
+                optionOrIndex = rec.get("n2.name").toString().replace("\"", "");
+                score1 = rec.get("r2.score").toString().replace("\"", "");
+                if (!"NULL".equals(score1)) {
+                    if (!threeLevelItems.containsKey(item)) {
+                        itemOrIndex = new LinkedHashMap<>();
+                    }
+                    itemOrIndex.put(optionOrIndex, score1);
+                    threeLevelItems.put(item, itemOrIndex);
+                }
+            }
+            while (Rset2.hasNext()) {
+                rec = Rset2.next();
+                item = rec.get("n1.name").toString().replace("\"", "");
+                optionOrIndex = rec.get("n2.name").toString().replace("\"", "");
+                index = rec.get("n3.name").toString().replace("\"", "");
+                score2 = rec.get("r3.score").toString().replace("\"", "");
+
+                if (!threeLevelItems.containsKey(item)) {
+                    itemOrIndex = new LinkedHashMap<>();
+                    twoLevelItems = new LinkedHashMap<>();
+                }
+                if (!twoLevelItems.containsKey(optionOrIndex)) {
+                    itemOrIndex = new LinkedHashMap<>();
+                }
+                itemOrIndex.put(index, score2);
+                twoLevelItems.put(optionOrIndex, itemOrIndex);
+                threeLevelItems.put(item, twoLevelItems);
+            }
+        } catch (Exception ex) {
+            ex.printStackTrace();
+            System.out.println("返回带得分需要计算的量表时出了问题！---->getScaleCalc");
+        } finally {
+            CloseSession(session);
+            return threeLevelItems;
+        }
+    }
+
+    /**
+     * 返回不带得分不需要计算的量表
+     *
+     * @param scaleName
+     * @return
+     */
+    public Map<String, Object> getScaleNoCalc(String scaleName) {
+        Session session = driver.session(AccessMode.READ);
+        StatementResult Rset1 = null;
+        StatementResult Rset2 = null;
+        Record rec;
+        scaleName = scaleName.toUpperCase();
+
+        Map<String, Object> fourLevelItems = new LinkedHashMap<>();
+        Map<String, Object> threeLevelItems = new LinkedHashMap<>();
+        Map<String, Object> twoLevelItems = new LinkedHashMap<>();
+        Map<Object, Object> firstLevelItems = new LinkedHashMap<>();
+
+        try {
+            String query1 = "match (m:Scale)-[r1]->(n1) where m.name=~'.*" + scaleName + ".*' " +
+                    "return m.name,r1.grade,n1.name order by r1.grade,toInt(r1.p)";
+
+            String query2 = "match (m:Scale)-[r1]->(n1)-[r2]->(n2) where m.name=~'.*" + scaleName + ".*' " +
+                    "return m.name,r1.grade,n1.name,r2.stage,n2.name order by r1.grade,r2.stage,toInt(r1.p)";
+            writeLog(query1);
+            Rset1 = session.run(query1);
+            Rset2 = session.run(query2);
+            writeLog(query2);
+
+            String scale = "";
+            String grade = "";
+            String gradeName = "";
+            String stage = "";
+            String stageName = "";
+
+            while (Rset1.hasNext()) {
+                rec = Rset1.next();
+                scale = rec.get("m.name").toString().replace("\"", "");
+                grade = rec.get("r1.grade").toString().replace("\"", "");
+                gradeName = rec.get("n1.name").toString().replace("\"", "");
+
+                firstLevelItems.put(gradeName, grade);
+                fourLevelItems.put(scale, firstLevelItems);
+
+            }
+
+            while (Rset2.hasNext()) {
+                rec = Rset2.next();
+                scale = rec.get("m.name").toString().replace("\"", "");
+                grade = rec.get("r1.grade").toString().replace("\"", "");
+                gradeName = rec.get("n1.name").toString().replace("\"", "");
+                stage = rec.get("r2.stage").toString().replace("\"", "");
+                stageName = rec.get("n2.name").toString().replace("\"", "");
+
+                if (!threeLevelItems.containsKey(gradeName)) {
+                    firstLevelItems = new LinkedHashMap<>();
+                    twoLevelItems = new LinkedHashMap<>();
+                }
+                if (!twoLevelItems.containsKey(grade)) {
+                    firstLevelItems = new LinkedHashMap<>();
+                }
+                firstLevelItems.put(stageName, stage);
+                twoLevelItems.put(grade, firstLevelItems);
+                threeLevelItems.put(gradeName, twoLevelItems);
+                fourLevelItems.put(scale, threeLevelItems);
+            }
+        } catch (Exception ex) {
+            ex.printStackTrace();
+            System.out.println("返回不带得分不需要计算的量表出了问题！---->getScaleNoCalc");
+        } finally {
+            CloseSession(session);
+            return fourLevelItems;
+        }
+    }
+
 }

graph/src/main/java/org/diagbot/graph/jdbc/Test.java

@@ -0,0 +1,24 @@
+package org.diagbot.graph.jdbc;
+
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * @Description:
+ * @Author: HUJING
+ * @Date: 2019/3/22 11:37
+ */
+public class Test {
+    public static void main(String[] args) throws Exception {
+        Neo4jAPI neo4jAPI = new Neo4jAPI(DriverManager.newDrive("localhost", "neo4j", "root"));
+        Map<String, Object> scale = neo4jAPI.getScaleNoCalc("te");
+
+                Set<String> keys = scale.keySet();
+        for (String key:keys) {
+            System.out.println(key + "," + scale.get(key));
+        }
+
+
+    }
+}

graph/src/main/java/org/diagbot/graph/util/NodeRelationUtil.java

@@ -122,6 +122,52 @@ public class NodeRelationUtil {
             if (session != null) session.close();
         }
     }
+    /**
+     * 添加带属性的关系
+     */
+    public void addRelationWithProperty(final Driver driver, final String fromlbl, final String fromval, final String relation,final Integer sort, final String tolbl, final String toval){
+        Session session = null;
+        try {
+            session = driver.session(AccessMode.WRITE);
+            session.writeTransaction(new TransactionWork<Integer>() {
+                @Override
+                public Integer execute(Transaction tx) {
+                    int result =0;
+                    String query = "MATCH (e:" + fromlbl + "{name:$src}), (c:" + tolbl + "{name:$dest}) " +
+                            "MERGE (e)-[r:" + relation + "{p:"+sort+"}]->(c) RETURN e.name, type(r), c.name";
+                    result = processRelation(tx, query, "src", fromval, "dest", toval);
+                    return result;
+                }
+            });
+        }catch (Exception ex) {
+            ex.printStackTrace();
+        } finally {
+            if (session != null) session.close();
+        }
+    }
+    /**
+     * 添加带属性的关系
+     */
+    public void addRelationWithPropertyDouble(final Driver driver, final String fromlbl, final String fromval, final String relation,final Double sort, final String tolbl, final String toval){
+        Session session = null;
+        try {
+            session = driver.session(AccessMode.WRITE);
+            session.writeTransaction(new TransactionWork<Integer>() {
+                @Override
+                public Integer execute(Transaction tx) {
+                    int result =0;
+                    String query = "MATCH (e:" + fromlbl + "{name:$src}), (c:" + tolbl + "{name:$dest}) " +
+                            "MERGE (e)-[r:" + relation + "{rate:"+sort+"}]->(c) RETURN e.name, type(r), c.name";
+                    result = processRelation(tx, query, "src", fromval, "dest", toval);
+                    return result;
+                }
+            });
+        }catch (Exception ex) {
+            ex.printStackTrace();
+        } finally {
+            if (session != null) session.close();
+        }
+    }
     /**
      * 为两个节点添加关系
      * @param fromlbl 标签类型
@@ -135,15 +181,6 @@ public class NodeRelationUtil {
         //两个节点之间,有关系,先删除
         try {
             session = driver.session(AccessMode.WRITE);
-//            session.writeTransaction(new TransactionWork<Integer>() {
-//                @Override
-//                public Integer execute(Transaction tx) {
-//                    String query = "MATCH (e:" + fromlbl + "{name:$src})-[r]->(c:" +
-//                            tolbl + "{name:$dest}) DELETE r";
-//                    int result = processRelation(tx, query, "src", fromval, "dest", toval);
-//                    return result;
-//                }
-//            });
             //为两个节点添加关系
             session.writeTransaction(new TransactionWork<Integer>() {
                 @Override
@@ -174,6 +211,7 @@ public class NodeRelationUtil {
         tx.run(query, parameters(srclbl, srcname, destlbl, destname));
         return 1;
     }
+
     private int processNode(Transaction tx, String query, String label, String val) {
         tx.run(query, parameters(label, val));
         return 1;

graph/src/main/resources/bolt.properties

@@ -20,22 +20,13 @@ bolt112.user=neo4j
 bolt112.passwd=123456
 
 #\u63A8\u786E\u8BCA\u5904\u7406sql
-#\u67E5\u627E\u8FD1\u4E49\u8BCD\u548C\u5316\u9A8C\u548C\u8F85\u68C0\u9879\u76EE
-
-#searchJinyici=with fildList as data  unwind data as  fild \n \
-#match(d:Disease)-[R1:\u63A8\u8350]->(h)-[r:\u7ED3\u679C]->(l) \n \
-#where l.name=fild \n \
-#return l.name as zi,labels(l)[0] as jin,h.name as fu,labels(h)[0] as da \n \
-#union \n \
-#with fildList as data  unwind data as  fild  \n \
-#match(l)-[r:\u8FD1\u4E49\u8BCD]->(h) \n \
-#where l.name=fild \n \
-#return l.name as zi,labels(l)[0] as jin,h.name as fu,labels(h)[0] as da
-
+#\u67E5\u627E\u8FD1\u4E49\u8BCD
 searchJinyici=with fildList as data  unwind data as  fild  \n \
 match(l)-[r:\u8FD1\u4E49\u8BCD]->(h) \n \
 where l.name=fild \n \
 return l.name as zi,labels(l)[0] as jin,h.name as fu,labels(h)[0] as da
+#\u67E5\u627E\u8FD1\u4E49\u8BCD\u7CBE\u534E\u7248
+serchCollect=match (n)-[r:\u8BCA\u65AD\u4F9D\u636E|:\u8FD1\u4E49\u8BCD]->(e) where n.name in fildList return n.name as fild,collect(distinct type(r)) as typeCollect
 #\u67E5\u627E\u80FD\u63A8\u51FA\u8BCA\u65AD\u4F9D\u636E\u7684\u8BCD
 searchCondition=with newList as data unwind data as row\n \
 match (l)-[r:\u8BCA\u65AD\u4F9D\u636E]->(m)\n \

graph/src/main/resources/query.properties

@@ -2,4 +2,8 @@
 # \u7B2C\u4E00\u6B65,\u75BE\u75C5\u5230\u7C7B,\u7C7B\u5305\u542B\u836F
 diseaseDrugsMedication=\
   match(d:Disease{name:'diseaseName'})-[r:\u63A8\u8350]->(h)-[r1:\u5305\u542B]->(l:Medicine) \
-  return d.name,h.name as drug,labels(h)[0] as label,r.p as p,collect(l.name) as collectName
+  return d.name,h.name as drug,labels(h)[0] as label,r.p as p,collect(l.name) as collectName
+# \u7B2C\u4E8C\u6B65,\u75BE\u75C5\u548C\u836F\u7684\u5173\u7CFB
+diseaseMedication=match(d:Disease{name:"diseaseName"})-[r:\u63A8\u8350]->(l:Medicine) return d.name,r.rate as p,l.name as collectName
+# \u7B2C\u4E09\u6B65,\u5927\u7C7B\u548C\u5B50\u7C7B\u7684\u5173\u7CFB
+bigDrugAndSubDrugs=match(d:Disease)-[r:\u63A8\u8350]->(s:Drugs)-[r1:\u5305\u542B]->(j:Drugs)where d.name="diseaseName" return s.name as big,j.name as sub

push-web/src/main/java/org/diagbot/push/controller/GraphController.java

@@ -3,6 +3,8 @@ package org.diagbot.push.controller;
 import org.diagbot.common.work.ResponseData;
 import org.diagbot.common.work.SearchData;
 import org.diagbot.graph.javabean.GdbResponse;
+import org.diagbot.graph.jdbc.DriverManager;
+import org.diagbot.graph.jdbc.Neo4jAPI;
 import org.diagbot.graphWeb.work.GraphCalculate;
 import org.diagbot.graphWeb.work.HighRiskCalculate;
 import org.diagbot.pub.api.Response;
@@ -14,6 +16,7 @@ import org.springframework.web.bind.annotation.RequestMethod;
 import org.springframework.web.bind.annotation.ResponseBody;
 
 import javax.servlet.http.HttpServletRequest;
+import java.util.Map;
 
 @Controller
 @RequestMapping("/graph")
@@ -66,4 +69,13 @@ public class GraphController extends BaseController {
         response.setData(responseData);
         return response;
     }
+
+    @RequestMapping(value = "/scale", method = RequestMethod.POST)
+    @ResponseBody
+    public Map<String, Object> scale(HttpServletRequest request, @RequestBody SearchData searchData) throws Exception {
+        Neo4jAPI neo4jAPI = new Neo4jAPI(DriverManager.newDrive("192.168.2.233","neo4j","root"));
+        String scaleName = searchData.getScaleName();
+        Map<String, Object> scale = neo4jAPI.getScale(scaleName);
+        return scale;
+    }
 }