1.增加查询量表所有数据的接口

  GraphController-->scale
  Neo4jApi-->getScale

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

@@ -2,6 +2,9 @@ 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.graph.util.HttpServletRequestUtil;
 import org.diagbot.graphWeb.dao.BackResponse;
 import org.diagbot.graphWeb.work.GraphCalculate;
 import org.diagbot.graphWeb.work.HighRiskCalculate;
@@ -15,6 +18,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")
@@ -44,5 +48,15 @@ public class GraphController {
         response.setData(responseData);
         return response;
     }
+
+    @RequestMapping(value = "/scale", method = RequestMethod.POST)
+    @ResponseBody
+    public Map<String, Object> scale(HttpServletRequest request) throws Exception {
+        Neo4jAPI neo4jAPI = new Neo4jAPI(DriverManager.newDrive());
+        String scaleName = HttpServletRequestUtil.getString(request, "scaleName");
+        Map<String, Object> scale = neo4jAPI.getScale(scaleName);
+        return scale;
+    }
+
 }
 

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);
@@ -894,7 +894,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()) {
@@ -1002,7 +1002,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()) {
@@ -1062,7 +1062,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"));
@@ -1203,9 +1203,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 = "";
@@ -1414,7 +1414,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" +
@@ -1430,7 +1430,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" +
@@ -1438,13 +1438,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()) {
@@ -1584,4 +1584,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)-[r]->(n) 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 n2.type,toInt(r2.p)";
+
+            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 n2.type,toInt(r2.p)";
+            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/HttpServletRequestUtil.java

@@ -0,0 +1,58 @@
+package org.diagbot.graph.util;
+
+import javax.servlet.http.HttpServletRequest;
+
+/**
+ * @Description: 将请求转换成基本数据类型
+ * @Author: HUJING
+ * @Date: 2019/3/26 16:51
+ * @Version 1.0
+ */
+public class HttpServletRequestUtil {
+    public static int getInt(HttpServletRequest request,String key){
+        try {
+            return Integer.decode(request.getParameter(key));
+        } catch (Exception e){
+            return -1;
+        }
+    }
+
+    public static long getLong(HttpServletRequest request,String key){
+        try {
+            return Long.valueOf(request.getParameter(key));
+        } catch (Exception e){
+            return -1;
+        }
+    }
+
+    public static Double getDouble(HttpServletRequest request,String key){
+        try {
+            return Double.valueOf(request.getParameter(key));
+        } catch (Exception e){
+            return -1d;
+        }
+    }
+
+    public static boolean getBoolean(HttpServletRequest request,String key){
+        try {
+            return Boolean.valueOf(request.getParameter(key));
+        } catch (Exception e){
+            return false;
+        }
+    }
+
+    public static String getString(HttpServletRequest request,String key){
+        try {
+            String result = request.getParameter(key);
+            if (result != null){
+                result = result.trim();
+            }
+            if ("".equals(result)){
+                result = null;
+            }
+            return result;
+        } catch (Exception e){
+            return null;
+        }
+    }
+}