解决冲突

common-push/src/main/java/org/diagbot/common/push/cache/CacheFileManager.java

@@ -30,7 +30,7 @@ public class CacheFileManager {
     public static void main(String[] args) {
         CacheFileManager cacheFileManager = new CacheFileManager();
         String p = cacheFileManager.getClass().getClassLoader().getResource("").getPath();
-        p = "d:/cache_file/";
+        p = "e:/cache_file/";
         File file = new File(p);
         if (!file.exists()) {
             file.mkdirs();
@@ -261,6 +261,30 @@ public class CacheFileManager {
                 fw.write("\n");
             }
             fw.close();
+
+            //规则过滤信息
+            sql = "SELECT set_name, idx_name, min_operator, min_value, min_unit, max_operator, " +
+                    " max_value, max_unit, remind FROM kl_rule ";
+            st = conn.createStatement();
+            rs = st.executeQuery(sql);
+            fw = new FileWriter(path + "rule_filter.dict");
+            String r6, r7, r8, r9;
+            while (rs.next()) {
+                r1 = rs.getString(1);
+                r2 = rs.getString(2);
+                r3 = rs.getString(3);
+                r4 = rs.getString(4);
+                r5 = rs.getString(5);
+                r6 = rs.getString(6);
+                r7 = rs.getString(7);
+                r8 = rs.getString(8);
+                r9 = rs.getString(9);
+                fw.write(encrypDES.encrytor(r1+ "|" + r2 + "|" + r3 + "|" + r4 + "|" + r5
+                        + "|" + r6 + "|" + r7 + "|" + r8 + "|" + r9));
+                fw.write("\n");
+            }
+            fw.close();
+
         } catch (Exception e) {
             e.printStackTrace();
         } finally {
@@ -318,7 +342,7 @@ public class CacheFileManager {
             }
             fw.close();
 
-            sql = "SELECT lib_name FROM kl_concept WHERE is_deleted = 'N' AND lib_type = 70 AND lib_name regexp '[0-9]'";
+            sql = "SELECT lib_name FROM kl_concept WHERE is_deleted = 'N' AND lib_name regexp '[0-9]'";
             st = conn.createStatement();
             rs = st.executeQuery(sql);
 

common-service/src/main/java/org/diagbot/common/javabean/MedicalIndication.java

@@ -7,6 +7,7 @@ import java.util.List;
  */
 public class MedicalIndication {
     private String name;
+    // 触发推送的规则
     private String rule;
     private List<MedicalIndicationDetail> details;
 
@@ -22,7 +23,9 @@ public class MedicalIndication {
         return rule;
     }
 
-    public void setRule(String rule) { this.rule = rule; }
+    public void setRule(String rule) {
+        this.rule = rule;
+    }
 
     public List<MedicalIndicationDetail> getDetails() {
         return details;

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

@@ -32,6 +32,12 @@ public class SearchData {
     protected String diag = "";
     protected String past = "";
     protected String other = "";
+    //当前开单lis项目
+    protected String lisOrder = "";
+    //当前开单pacs项目
+    protected String pacOrder = "";
+    //当前开单其他 预留
+    protected String otherOrder = "";
     //大数据推送诊断结果信息
     protected List<FeatureRate> pushDiags = new ArrayList<>();
 
@@ -262,4 +268,28 @@ public class SearchData {
     public void setGraphInputs(Map<String, Map<String, String>> graphInputs) {
         this.graphInputs = graphInputs;
     }
+
+    public String getLisOrder() {
+        return lisOrder;
+    }
+
+    public void setLisOrder(String lisOrder) {
+        this.lisOrder = lisOrder;
+    }
+
+    public String getPacOrder() {
+        return pacOrder;
+    }
+
+    public void setPacOrder(String pacOrder) {
+        this.pacOrder = pacOrder;
+    }
+
+    public String getOtherOrder() {
+        return otherOrder;
+    }
+
+    public void setOtherOrder(String otherOrder) {
+        this.otherOrder = otherOrder;
+    }
 }

graphdb/pom.xml

@@ -84,6 +84,16 @@
             <scope>compile</scope>
         </dependency>
 
+        <dependency>
+            <groupId>org.diagbot</groupId>
+            <artifactId>public</artifactId>
+            <version>1.0.0</version>
+        </dependency>
+        <!--<dependency>-->
+            <!--<groupId>org.diagbot</groupId>-->
+            <!--<artifactId>nlp</artifactId>-->
+            <!--<version>1.0.0</version>-->
+        <!--</dependency>-->
     </dependencies>
 
     <build>

graphdb/src/main/java/org/diagbot/pub/Ciku.java

@@ -0,0 +1,41 @@
+package org.diagbot.pub;
+
+public enum Ciku {
+    SYMPTOM("1","1,70"),VITAL_RESULT("2","35,70"),BIGlIS("3","12"),SUBLIS("subLis","13")
+    ,RESULTLIS("resultLis","14,70"),PACS("4","16"),RESULTPACS("resultPacs","17,70"),DISEASE("5","18")
+    ,HISTORY("6","18,70"),CAUSE("7","5,70"),PROGNOSIS("8","70"),OTHER("9","70");
+    private String name;
+    private String label;
+
+    Ciku(String name, String label) {
+        this.name = name;
+        this.label = label;
+    }
+    public static Ciku getEnum(String name) {
+        for (Ciku item : Ciku.values()) {
+            if (item.name.equals(name) ) {
+                return item;
+            }
+        }
+        return null;
+    }
+    public static String getLabel(String name) {
+        Ciku item = getEnum(name);
+        return item != null ? item.label : null;
+    }
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public String getLabel() {
+        return label;
+    }
+
+    public void setLabel(String label) {
+        this.label = label;
+    }
+}

graphdb/src/main/java/org/diagbot/pub/Label.java

@@ -0,0 +1,44 @@
+package org.diagbot.pub;
+
+public enum Label {
+    SYMPTOM("1","Symptom"),VITAL_RESULT("2","Vital"),LIS("3","LIS"),PACS("4","PACS"),
+    DISEASE("5","Disease"),HISTORY("6","History"),CAUSE("7","Cause"),PROGNOSIS("8","Other"),
+    OTHER("9","Other"),CONDITION("诊断依据","Condition"),NI("92","Condition"),QUE("91","Condition"),
+    HIGH("93","Condition"),DELETE("94","Condition"),
+    LISRESULT("化验结果","LISResult"),PACSRESULT("辅检结果","PACSResult");
+    private String name;
+    private String label;
+
+    Label(String name, String label) {
+        this.name = name;
+        this.label = label;
+    }
+    public static Label getEnum(String name) {
+        for (Label item : Label.values()) {
+            if (item.name.equals(name) ) {
+                return item;
+            }
+        }
+        return null;
+    }
+    public static String getLabel(String name) {
+        Label item = getEnum(name);
+        return item != null ? item.label : null;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public String getLabel() {
+        return label;
+    }
+
+    public void setLabel(String label) {
+        this.label = label;
+    }
+}

graphdb/src/main/java/org/diagbot/pub/Type.java

@@ -0,0 +1,46 @@
+package org.diagbot.pub;
+
+/**
+ * excel
+ * 类型(1：症状，2：体征，3：化验，4：辅检，5：鉴别诊断，6：病史，7：诱因，8：病程，9：其他，91：确诊，92：拟诊，93：警惕)
+ */
+public enum Type {
+    SYMPTOM(1,"症状"),VITAL_RESULT(2,"体征结果"),LIS(3,"化验"),PACS(4,"辅检"),
+    DISEASE(5,"鉴别诊断"),HISTORY(6,"病史"),CAUSE(7,"诱因"),PROGNOSIS(8,"病程"),
+    OTHER(9,"其他"),QUE(91,"确诊"),NI(92,"拟诊"),HIGH(93,"警惕"),DELETE(94,"删除条件");
+    private Integer key;
+    private String name;
+
+    Type(Integer key, String name) {
+        this.key = key;
+        this.name = name;
+    }
+    public static Type getEnum(Integer key) {
+        for (Type item : Type.values()) {
+            if (item.key == key) {
+                return item;
+            }
+        }
+        return null;
+    }
+    public static String getName(Integer key) {
+        Type item = getEnum(key);
+        return item != null ? item.name : null;
+    }
+
+    public Integer getKey() {
+        return key;
+    }
+
+    public void setKey(Integer key) {
+        this.key = key;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+}

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

@@ -18,4 +18,154 @@ public interface DiseaseRepository extends Neo4jRepository<Disease, Long> {
     @Query("match(d:Disease) where d.name in {0} return d.name as name, d.high_risk as risk")
     List<Map<String, Object>> getHighRisk(List diagList);
 
+
+    //删除诊断依据
+    //删除关系1
+    @Query("match(d:Disease)<-[r:拟诊|:确诊|:警惕]-(c:Condition)<-[r1]-(k:Condition)<-[r2]-(h:Condition) where d.disId={0} detach delete c,k,h")
+    void deleteRelation1(Long disId);
+    //删除关系2
+    @Query("match(d:Disease)<-[r:拟诊|:确诊|:警惕]-(c:Condition)<-[r1]-(k:Condition) where d.disId={0} detach delete c,k")
+    void deleteRelation2(Long disId);
+    //删除关系3
+    @Query("match(d:Disease)<-[r:拟诊|:确诊|:警惕]-(c:Condition) where d.disId={0} detach delete r")
+    void deleteRelation3(Long disId);
+    //删除排除关系4
+    @Query("match(d:Disease)<-[r:排除]-(l) where d.disId={0} detach delete l")
+    void deleteRelation4(Long disId);
+    //删除排除关系5
+    @Query("match(d:Disease)-[r:表现]->(j)-[r1:属于]->(k) where d.disId={0} detach delete r")
+    void deleteRelation5(Long disId);
+    //删除排除关系6
+    @Query("match(d:Disease)-[r:表现]->(j) where d.disId={0} detach delete r")
+    void deleteRelation6(Long disId);
+    //删除排除关系7
+    @Query("match(d:Disease)-[r:推荐]->(j:LIS) where d.disId={0} detach delete r")
+    void deleteRelation7(Long disId);
+    //删除排除关系8
+    @Query("match(d:Disease)-[r:推荐]->(j:PACS) where d.disId={0} detach delete r")
+    void deleteRelation8(Long disId);
+    //删除排除关系9
+    @Query("match(d:Disease)-[r:鉴别诊断]->(b) where d.disId={0} detach delete r")
+    void deleteRelation9(Long disId);
+    //删除排除关系10
+    @Query("match(c:Condition) where c.name={0} detach delete c")
+    void deleteRelation10(String conditionName);
+    //更新图谱
+    //存储疾病
+    @Query("merge(d:Disease{name:{0},disId:{1},emergency:{2}})")
+    void mergeDis(String name,Long disId,Integer emergency);
+    //存储确诊，拟诊，警惕
+    @Query( "merge(c:Condition{name:{0},path:{1}})")
+    void mergeCondition(String disName,Integer path);
+    @Query("match(c:Condition{name:{0}}),(d:Disease{disId:{1}})" +
+            " merge(c)-[:确诊]->(d)")
+    void mergeQueNiHigh(String conditionName,Long disId);
+    @Query("match(c:Condition{name:{0}}),(d:Disease{disId:{1}})" +
+            " merge(c)-[:拟诊]->(d)")
+    void mergeNiHigh(String conditionName,Long disId);
+    @Query("match(c:Condition{name:{0}}),(d:Disease{disId:{1}})" +
+            " merge(c)-[:警惕]->(d)")
+    void mergeHigh(String conditionName,Long disId);
+    //任几的condition
+    @Query("merge(c:Condition{name:{0},path:{1},relation:{2}})")
+    void mergeRenCondition(String conditionName,Integer path,String relation);
+    @Query("match(c:Condition{name:{0}}),(s:Condition{name:{1}}) merge(c)-[r:诊断依据]->(s)")
+    void mergeRenCondition(String c1,String c2);
+    //具体code Condition
+    @Query("merge(c:Condition{name:{0},path:1,relation:'任一'})")
+    void mergeNUMCondition(String disName);
+    @Query("match(c:Condition{name:{0}}),(s:Condition{name:{1}}) merge(c)-[r:诊断依据]->(s)")
+    void mergeNUMCondition(String c1,String c2);
+    //开始添加所有的词语
+    //添加症状标准词
+    @Query("merge(d:Symptom{name:{0}})")
+    void mergeStandardSymptom(String name);
+    //疾病表现症状标准词
+    @Query("match(d:Disease{disId:{0}}),(s:Symptom{name:{1}}) merge(d)-[r:表现]->(s)")
+    void mergeRelationStandard(Long disId,String name);
+    //属于症状标准词
+    @Query("match(d:Condition{name:{0}}),(s:Symptom{name:{1}}) merge(d)<-[r:属于]-(s)")
+    void mergeRelationStandardshuyu(String conditionName,String name);
+    //添加体征标准词
+    @Query("merge(d:Vital{name:{0}})")
+    void mergeStandardVital(String name);
+    //疾病表现体征标准词
+    @Query("match(d:Disease{disId:{0}}),(s:Vital{name:{1}}) merge(d)-[r:表现]->(s)")
+    void mergeRelationStandardVital(Long disId,String name);
+    //属于体征标准词
+    @Query("match(d:Condition{name:{0}}),(s:Vital{name:{1}}) merge(d)<-[r:属于]-(s)")
+    void mergeRelationStandardVitalshuyu(String conditionName,String name);
+    //添加病史标准词
+    @Query("merge(d:History{name:{0}})")
+    void mergeStandardHistory(String name);
+    //疾病表现病史标准词
+    @Query("match(d:Disease{disId:{0}}),(s:History{name:{1}}) merge(d)-[r:表现]->(s)")
+    void mergeRelationStandardHistory(Long disId,String name);
+    //属于病史标准词
+    @Query("match(d:Condition{name:{0}}),(s:History{name:{1}}) merge(d)<-[r:属于]-(s)")
+    void mergeRelationStandardHistoryshuyu(String conditionName,String name);
+    //添加诱因标准词
+    @Query("merge(d:Cause{name:{0}})")
+    void mergeStandardCause(String name);
+    //疾病表现诱因标准词
+    @Query("match(d:Disease{disId:{0}}),(s:Cause{name:{1}}) merge(d)-[r:表现]->(s)")
+    void mergeRelationStandardCause(Long disId,String name);
+    //属于诱因标准词
+    @Query("match(d:Condition{name:{0}}),(s:Cause{name:{1}}) merge(d)<-[r:属于]-(s)")
+    void mergeRelationStandardCauseshuyu(String conditionName,String name);
+    //添加病程标准词
+    @Query("merge(d:Prognosis{name:{0}})")
+    void mergeStandardPrognosis(String name);
+    //疾病表现病程标准词
+    @Query("match(d:Disease{disId:{0}}),(s:Prognosis{name:{1}}) merge(d)-[r:表现]->(s)")
+    void mergeRelationStandardPrognosis(Long disId,String name);
+    //属于病程标准词
+    @Query("match(d:Condition{name:{0}}),(s:Prognosis{name:{1}}) merge(d)<-[r:属于]-(s)")
+    void mergeRelationStandardPrognosisshuyu(String conditionName,String name);
+    //添加其他标准词
+    @Query("merge(d:Other{name:{0}})")
+    void mergeStandardOther(String name);
+    //疾病表现其他标准词
+    @Query("match(d:Disease{disId:{0}}),(s:Other{name:{1}}) merge(d)-[r:表现]->(s)")
+    void mergeRelationStandardOther(Long disId,String name);
+    //属于其他标准词
+    @Query("match(d:Condition{name:{0}}),(s:Other{name:{1}}) merge(d)<-[r:属于]-(s)")
+    void mergeRelationStandardOthershuyu(String conditionName,String name);
+    //添加鉴别诊断
+    @Query("merge(d:DifferentDis{name:{0}})")
+    void mergeDifferentDis(String disName);
+    //疾病和鉴别诊断创建关系
+    @Query("match(d:Disease{disId:{0}}),(s:DifferentDis{name:{1}}) merge(d)-[r:鉴别诊断]->(s)")
+    void mergeRelationDifferentDis(Long disId,String name);
+    //创建公表名
+    @Query("merge(l:LIS{name:{0}})")
+    void mergePublicLIS(String lisName);
+    //疾病和鉴别诊断创建关系
+    @Query("match(d:Disease{disId:{0}}),(s:LIS{name:{1}}) merge(d)-[r:推荐]->(s)")
+    void mergeRelationLIS(Long disId,String name);
+    //创建化验结果节点
+    @Query("merge(l:LISResult{name:{0}})")
+    void mergeLISRESULT(String name);
+    //公表名和化验结果创建关系
+    @Query("match(d:LIS{name:{0}}),(s:LISResult{name:{1}}) merge(d)-[r:结果]->(s)")
+    void mergeRelationPublicLIS(String publicLis,String lisResult);
+    //化验结果和对应的codeCondition创建关系
+    @Query("match(d:Condition{name:{0}}),(s:LISResult{name:{1}}) merge(d)<-[r:诊断依据]-(s)")
+    void mergeRelationCondiLisRes(String codeCondition,String lisRes);
+    //创建辅检项目
+    @Query("merge(p:PACS{name:{0}})")
+    void mergePacs(String pacsName);
+    //疾病推荐辅检
+    @Query("match(d:Disease{disId:{0}}),(s:PACS{name:{1}}) merge(d)-[r:推荐]->(s)")
+    void mergeRelationDis2Pacs(Long disId,String name);
+    //创建辅检结果节点
+    @Query("merge(p:PACSResult{name:{0}})")
+    void mergePacsResult(String name);
+    //创建辅检和辅检结果的关系
+    @Query("match(d:PACS{name:{0}}),(s:PACSResult{name:{1}}) merge(d)-[r:结果]->(s)")
+    void mergeRelationPacsResult(String pacs,String pacsResult);
+    //辅检结果和对应的codeCondition创建关系
+    @Query("match(d:Condition{name:{0}}),(s:PACSResult{name:{1}}) merge(d)<-[r:诊断依据]-(s)")
+    void mergeRelationCondiPacsRes(String codeCondition,String pacsRes);
 }
+

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

@@ -5,9 +5,7 @@ import org.diagbot.entity.node.Symptom;
 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 org.diagbot.vo.domain.*;
 
 import java.util.List;
 import java.util.Map;
@@ -54,4 +52,9 @@ public interface KnowledgeService {
     List<Symptom> selectAllSymptom(PageVo pageVo);
     List<LIS> selectAllLIS(PageVo pageVo);
 
+    //更新图谱
+    RespDTO updateNeoDisease(NeoParamVO singleDisease);
+    //删除图谱
+    RespDTO deleteNeoDisease(NeoParamVO singleDisease);
+
 }

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

@@ -6,6 +6,10 @@ import org.apache.commons.lang3.StringUtils;
 import org.diagbot.entity.node.LIS;
 import org.diagbot.entity.node.Symptom;
 import org.diagbot.mapper.KnowledgeMapper;
+import org.diagbot.pub.Ciku;
+import org.diagbot.pub.Label;
+import org.diagbot.pub.Type;
+import org.diagbot.pub.jdbc.MysqlJdbc;
 import org.diagbot.service.KnowledgeService;
 import org.diagbot.vo.*;
 import org.diagbot.entity.node.Disease;
@@ -24,12 +28,16 @@ import org.springframework.data.domain.Sort;
 import org.springframework.stereotype.Service;
 
 import java.math.RoundingMode;
+import java.sql.Connection;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.sql.Statement;
 import java.text.NumberFormat;
 import java.util.*;
 
 
 @Service
-public class KnowledgeServiceImpl implements KnowledgeService {
+public class    KnowledgeServiceImpl implements KnowledgeService {
     Logger logger = LoggerFactory.getLogger(KnowledgeServiceImpl.class);
     @Autowired
     private SymptomRepository symptomRepository;
@@ -49,7 +57,14 @@ public class KnowledgeServiceImpl implements KnowledgeService {
     private List<BaseNode> baseNodes;
 
     private Pageable pageable;
-
+    private Connection conn = null;
+    private MysqlJdbc nlpJdbc = new MysqlJdbc("root", "lantone", "jdbc:mysql://192.168.2.236:3306/med?useSSL=false&useUnicode=true&characterEncoding=UTF-8");
+    public Connection getConn(){
+        if(conn == null){
+            conn = nlpJdbc.connect();
+        }
+        return conn;
+    }
     /**
      * 处理症状节点相关的申请
      */
@@ -1398,6 +1413,710 @@ public class KnowledgeServiceImpl implements KnowledgeService {
         return indicators1;
     }
 
+    /**
+     * 更新图谱
+     * @param singleDisease
+     * @return
+     * 类型(1：症状，2：体征，3：化验，4：辅检，5：鉴别诊断，6：病史，7：诱因，8：病程，9：其他，91：确诊，92：拟诊，93：警惕)
+     */
+    @Override
+    public RespDTO updateNeoDisease(NeoParamVO singleDisease) {
+        RespDTO respDTO = RespDTO.onSuc(true);;
+        Long disId = singleDisease.getId();
+        //先删除
+        this.neo4jDelete(disId);
+        String disName = this.getDisName(disId);
+        if(StringUtils.isNotEmpty(disName)){
+            diseaseRepository.mergeDis(disName,disId,0);
+        }else {
+            respDTO = RespDTO.onError("在数据库中没有找到"+disId+"对应的疾病！！");
+        }
+        //把数据库中的所有词读进map缓存
+        Map<String, Map<String, String>> ciKu = this.allStandWord2Map();
+        //获取每个诊断依据的全部数据
+        List<Map<String, String>> allData = this.getAllData(disId);
+        //获取拟诊，确诊，警惕组合
+        Map<String, List<String>> allNiQueZhenCollection = this.getAllNiQueZhenCollection(disId);
+        this.saveNiQue2Neo(allData,allNiQueZhenCollection,disName,disId);
+        this.saveData2Neo4j(allData,disId,disName,ciKu);
+        return respDTO;
+    }
+
+    /**
+     * 把一个完整的诊断依据封装到list中，list中存的是map,一行一个map
+     * @param disId
+     * @return
+     */
+    public List<Map<String,String>> getAllData(Long disId){
+        List<Map<String,String>> contentList = new ArrayList<>();
+        conn = this.getConn();
+        Statement st = null;
+        ResultSet rs = null;
+        try {
+            String type, code ,standard,relation,result,formula,name;
+            String sql = "SELECT diagnose_id,dis_name,`type`,`code`,standard,relation,result,formula FROM `kl_diagnose_detail` where diagnose_id = "+disId+"";
+            st = conn.createStatement();
+            rs = st.executeQuery(sql);
+            while (rs.next()){
+                Map<String,String> content = new HashMap<>();
+                type = rs.getString(3);
+                code = rs.getString("code");
+                standard = rs.getString("standard");
+                relation = rs.getString("relation");
+                result = rs.getString("result");
+                formula = rs.getString("formula");
+                name = Type.getName(Integer.parseInt(type));
+                content.put("type",type);
+                content.put("typeName",name);
+                content.put("code",code);
+                content.put("standard",standard);
+                content.put("relation",relation);
+                content.put("result",result);
+                content.put("formula",formula);
+                contentList.add(content);
+            }
+
+        } catch (Exception e) {
+            e.printStackTrace();
+        } finally {
+            try {
+                rs.close();
+                st.close();
+            } catch (SQLException e) {
+                e.printStackTrace();
+            }
+        }
+        return contentList;
+    }
+
+    /**
+     * 获取一个诊断依据的确诊，拟诊，警惕集合
+     * @param disId
+     * @return
+     */
+    public Map<String,List<String>> getAllNiQueZhenCollection(Long disId)  {
+        Map<String,List<String>> queNiMap = new HashMap<>();
+        conn = this.getConn();
+        Statement st = null;
+        ResultSet rs = null;
+        List<String> queList = new ArrayList<>();
+        List<String> niList = new ArrayList<>();
+        List<String> highList = new ArrayList<>();
+        try {
+            String type, formula,  label,name;
+            String sql = "SELECT type,formula FROM `kl_diagnose_detail` where diagnose_id = "+disId+" and type in (91,92,93)";
+            st = conn.createStatement();
+            rs = st.executeQuery(sql);
+            while (rs.next()) {
+                type = rs.getString(1);
+                formula = rs.getString(2);
+                name = Type.getName(Integer.parseInt(type));
+                if("拟诊".equals(name)){
+                    niList.add(formula);
+                }else if("确诊".equals(name)){
+                    queList.add(formula);
+                }else if("警惕".equals(name)){
+                    highList.add(formula);
+                }
+                if(queList != null){
+                    for (String que:queList) {
+                        if(que.contains("拟诊")){
+                            for (String ni:niList
+                                    ) {
+                                String newNi = que.replaceAll("拟诊", ni);
+                                queList.add(newNi);
+                            }
+                            queList.remove(que);
+                        }
+                    }
+                }
+                queNiMap.put("拟诊",niList);
+                queNiMap.put("确诊",queList);
+                queNiMap.put("警惕",highList);
+
+            }
+        }catch (Exception e) {
+            e.printStackTrace();
+        } finally {
+            try {
+                rs.close();
+                st.close();
+            } catch (SQLException e) {
+                e.printStackTrace();
+            }
+        }
+        return queNiMap;
+    }
+
+    /**
+     * 加载所有词库
+     * @return
+     */
+    public  Map<String,Map<String,String>> allStandWord2Map(){
+        Map<String,Map<String,String>> ciKu = new HashMap<>();
+        conn = this.getConn();
+        Statement st = null;
+        ResultSet rs = null;
+        try {
+            String tongName, type,  isConcept,stand;
+            String sql = "SELECT name, type_id,is_concept,IF(is_concept=1,a.name,(select lib_name from kl_concept b where b.id = a.concept_id) ) lib_name \n" +
+                    "from kl_library_info a where  a.is_deleted = 'N'\n" +
+                    "and type_id in (1,5,12,13,14,16,17,18,35,70)";
+            st = conn.createStatement();
+            rs = st.executeQuery(sql);
+            Map<String,String> detail =null;
+            while (rs.next()) {
+                tongName = rs.getString(1);
+                type = rs.getString(2);
+                isConcept = rs.getString(3);
+                stand = rs.getString(4);
+                detail = new HashMap<>();
+                detail.put("isConcept",isConcept);
+                detail.put("stand",stand);
+                ciKu.put(tongName+","+type,detail);
+            }
+        }catch (Exception e) {
+            e.printStackTrace();
+        } finally {
+            try {
+                rs.close();
+                st.close();
+            } catch (SQLException e) {
+                e.printStackTrace();
+            }
+            return ciKu;
+        }
+    }
+
+    /**
+     * 获取疾病名
+     * @param disId
+     * @return
+     */
+    public String getDisName(Long disId){
+        Statement st = null;
+        ResultSet rs = null;
+        conn = this.getConn();
+        String name="";
+        try {
+            String sql = "SELECT dis_name FROM `kl_diagnose_detail` where diagnose_id = "+disId+"";
+            st = conn.createStatement();
+            rs = st.executeQuery(sql);
+            while (rs.next()) {
+                name = rs.getString(1);
+            }
+        }catch (Exception e) {
+            e.printStackTrace();
+        } finally {
+            try {
+                rs.close();
+                st.close();
+            } catch (SQLException e) {
+                e.printStackTrace();
+            }
+            return name;
+        }
+    }
+    /**
+     * 把确诊，拟诊，警惕存入图谱
+     */
+    public void saveNiQue2Neo(List<Map<String, String>> allData,Map<String, List<String>> allNiQueZhenCollection,String disName,Long disId){
+        List<String> stringList =null;
+        String[] types = {"确诊","拟诊","警惕"};
+        Integer path = 1;
+        String[] nisplits;
+        for (String type:types) {
+            if("确诊".equals(type)){
+                stringList = allNiQueZhenCollection.get(type);
+                if(stringList != null){
+                    for(int i =0;i<stringList.size();i++){
+                        nisplits = stringList.get(i).split("\\+");
+                        path = nisplits.length;
+                        diseaseRepository.mergeCondition(disName+"-"+type+"组块"+(i+1),path);
+                        diseaseRepository.mergeQueNiHigh(disName+"-"+type+"组块"+(i+1),disId);
+                    }
+                }
+            }else if("拟诊".equals(type)){
+                stringList = allNiQueZhenCollection.get(type);
+                if(stringList != null){
+                    for(int i =0;i<stringList.size();i++){
+                        nisplits = stringList.get(i).split("\\+");
+                        path = nisplits.length;
+                        diseaseRepository.mergeCondition(disName+"-"+type+"组块"+(i+1),path);
+                        diseaseRepository.mergeNiHigh(disName+"-"+type+"组块"+(i+1),disId);
+                        this.splitConditionContent(nisplits,disName,disName+"-"+type+"组块"+(i+1),allData);
+                    }
+                }
+            }else if("警惕".equals(type)){
+                stringList = allNiQueZhenCollection.get(type);
+                if(stringList != null){
+                    for(int i =0;i<stringList.size();i++){
+                        nisplits = stringList.get(i).split("\\+");
+                        path = nisplits.length;
+                        diseaseRepository.mergeCondition(disName+"-"+type+"组块"+(i+1),path);
+                        diseaseRepository.mergeHigh(disName+"-"+type+"组块"+(i+1),disId);
+                        this.splitConditionContent(nisplits,disName,disName+"-"+type+"组块"+(i+1),allData);
+                    }
+                }
+            }
+        }
+    }
+
+    /**
+     * 处理任几
+     * @param nisplits
+     * @param disName
+     * @param startNode
+     * @param allData
+     */
+    public void splitConditionContent(String[] nisplits,String disName,String startNode,List<Map<String, String>> allData){
+        Integer path = 1;
+        String rel = "";
+        for (String ni:nisplits) {
+            if(ni.contains("/")){
+                if(ni.contains("任一")){
+                    path = 1;
+                    rel = "任一";
+                }else if(ni.contains("任二")){
+                    path = 2;
+                    rel = "任二";
+                }else if(ni.contains("任三")){
+                    path = 3;
+                    rel = "任三";
+                }else if(ni.contains("任四")){
+                    path = 4;
+                    rel = "任四";
+                }else if(ni.contains("任五")){
+                    path = 5;
+                    rel = "任五";
+                }else if(ni.contains("任六")){
+                    path = 6;
+                    rel = "任六";
+                }else if(ni.contains("任七")){
+                    path = 7;
+                    rel = "任七";
+                }else {
+                    path = 1;
+                    rel = "任一";
+                }
+                diseaseRepository.mergeRenCondition(disName+ni,path,rel);
+                diseaseRepository.mergeRenCondition(disName+ni,startNode);
+                //获取这个任几集合的数字集合
+                List<String> numList = this.getNumList(ni);
+                if(numList != null && numList.size()>0){
+                    for (String num:numList
+                            ) {
+                        this.processDetailNum(disName,num,disName+ni,allData);
+                    }
+                }
+            }else {
+                this.processDetailNum(disName,ni,disName+ni,allData);
+            }
+        }
+    }
+
+    /**
+     * 获取任几集合的code列表
+     * @return
+     */
+    public List<String> getNumList(String renCondition){
+        List<String> numList = new ArrayList<>();
+        String[] numSplits = renCondition.split("/");
+        if(numSplits.length>0){
+            for (int i=0;i<numSplits.length;i++){
+                if(i == 0){
+                    numList.add(numSplits[i].replaceAll("\\(",""));
+                }else if(i == numSplits.length-1){
+                    String numSplit = numSplits[i];
+                    int i1 = numSplit.indexOf(")");
+                    System.out.println(numSplit+"\t"+i1);
+                    numList.add(numSplits[i].substring(0,numSplits[i].indexOf(")")));
+                }else {
+                    numList.add(numSplits[i]);
+                }
+            }
+        }
+        return numList;
+    }
+    public void processDetailNum(String disName,String num,String renCondition,List<Map<String, String>> allData){
+        String[] types = {"化验","辅检","排除条件"};
+        for (Map<String, String> row:allData) {
+            String code = row.get("code");//编码
+            String type = row.get("type");//类型
+            String typeName = row.get("typeName");//类型对应的中文名
+            String relation = row.get("relation");//关联词
+            String result = row.get("result");//结果
+            if(num.equals(code)){
+                if(Arrays.asList(types).indexOf(typeName) <0){
+                    diseaseRepository.mergeNUMCondition(disName+code);
+                    diseaseRepository.mergeNUMCondition(disName+code,renCondition);
+                }else if("化验".equals(typeName) && !"".equals(result)){
+                    diseaseRepository.mergeNUMCondition(disName+code);
+                    diseaseRepository.mergeNUMCondition(disName+code,renCondition);
+                }else if("辅检".equals(typeName) && !"".equals(relation)){
+                    diseaseRepository.mergeNUMCondition(disName+code);
+                    diseaseRepository.mergeNUMCondition(disName+code,renCondition);
+                }
+            }
+        }
+    }
+
+    /**
+     * 保存完整的诊断依据入知识图谱
+     * @param allData
+     * @param disId
+     * @param disName
+     */
+    public void saveData2Neo4j(List<Map<String, String>> allData,Long disId,String disName,Map<String, Map<String, String>> ciKu){
+        for (Map<String,String> row:allData) {
+            String code = row.get("code");//编码
+            String type = row.get("type");//类型
+            String typeName = row.get("typeName");//类型对应的中文名
+            String standard = row.get("standard");//标准词
+            String relation = row.get("relation");//关联词
+            String result = row.get("result");//结果
+            if(StringUtils.isNotEmpty(type)){
+                String[] split =null;
+                String[] lisResultSplit =null;
+                String[] pacsResultSplit =null;
+                String standWord = null;String lisResult = null,pacsResult=null;
+                if(!"3".equals(type) && !"4".equals(type) && !"5".equals(type)){
+                    //添加词语之前，要找标准词
+                    //添加standard
+                    switch (type){
+                        case "1": //症状
+                            standWord = searchStandWord(standard, type, ciKu);
+                            if(StringUtils.isNotEmpty(standWord)){
+                                diseaseRepository.mergeStandardSymptom(standWord);
+                                diseaseRepository.mergeRelationStandard(disId,standWord);
+                                diseaseRepository.mergeRelationStandardshuyu(disName+code,standWord);
+                            }
+                            if(StringUtils.isNotEmpty(relation)){
+                                split = relation.split("、");
+                                if(split!=null && split.length>0){
+                                    for (String ci:split) {
+                                        if(StringUtils.isNotEmpty(ci)){
+                                            //找标准词
+                                            standWord = searchStandWord(ci,type,ciKu);
+                                            if(StringUtils.isNotEmpty(standWord)){
+                                                diseaseRepository.mergeStandardSymptom(standWord);
+                                                diseaseRepository.mergeRelationStandardshuyu(disName+code,standWord);
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                            break;
+                        case "2"://体征结果
+                            standWord = searchStandWord(standard,type,ciKu);
+                            if(StringUtils.isNotEmpty(standWord)){
+                                diseaseRepository.mergeStandardVital(standWord);
+                                diseaseRepository.mergeRelationStandardVital(disId,standWord);
+                                diseaseRepository.mergeRelationStandardVitalshuyu(disName+code,standWord);
+                            }
+                            if(StringUtils.isNotEmpty(relation)){
+                                split = relation.split("、");
+                                if(split!=null && split.length>0){
+                                    for (String ci:split) {
+                                        if(StringUtils.isNotEmpty(ci)){
+                                            //找标准词
+                                            standWord = searchStandWord(ci,type,ciKu);
+                                            if(StringUtils.isNotEmpty(standWord)){
+                                                diseaseRepository.mergeStandardVital(standWord);
+                                                diseaseRepository.mergeRelationStandardVitalshuyu(disName+code,standWord);
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                            break;
+                        case "6"://病史
+                            standWord = searchStandWord(standard,type,ciKu);
+                            if(StringUtils.isNotEmpty(standWord)){
+                                diseaseRepository.mergeStandardHistory(standWord);
+                                diseaseRepository.mergeRelationStandardHistory(disId,standWord);
+                                diseaseRepository.mergeRelationStandardHistoryshuyu(disName+code,standWord);
+                            }
+                            if(StringUtils.isNotEmpty(relation)){
+                                split = relation.split("、");
+                                if(split!=null && split.length>0){
+                                    for (String ci:split) {
+                                        if(StringUtils.isNotEmpty(ci)){
+                                            //找标准词
+                                            standWord = searchStandWord(ci,type,ciKu);
+                                            if(StringUtils.isNotEmpty(standWord)){
+                                                diseaseRepository.mergeStandardHistory(standWord);
+                                                diseaseRepository.mergeRelationStandardHistoryshuyu(disName+code,standWord);
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                            break;
+                        case "7"://诱因
+                            standWord = searchStandWord(standard,type,ciKu);
+                            if(StringUtils.isNotEmpty(standWord)){
+                                diseaseRepository.mergeStandardCause(standWord);
+                                diseaseRepository.mergeRelationStandardCause(disId,standWord);
+                                diseaseRepository.mergeRelationStandardCauseshuyu(disName+code,standWord);
+                            }
+                            if(StringUtils.isNotEmpty(relation)){
+                                split = relation.split("、");
+                                if(split!=null && split.length>0){
+                                    for (String ci:split) {
+                                        if(StringUtils.isNotEmpty(ci)){
+                                            //找标准词
+                                            standWord = searchStandWord(ci,type,ciKu);
+                                            if(StringUtils.isNotEmpty(standWord)){
+                                                diseaseRepository.mergeStandardCause(standWord);
+                                                diseaseRepository.mergeRelationStandardCauseshuyu(disName+code,standWord);
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                            break;
+                        case "8"://病程
+                            standWord = searchStandWord(standard,type,ciKu);
+                            if(StringUtils.isNotEmpty(standWord)){
+                                diseaseRepository.mergeStandardPrognosis(standWord);
+                                diseaseRepository.mergeRelationStandardPrognosis(disId,standWord);
+                                diseaseRepository.mergeRelationStandardPrognosisshuyu(disName+code,standWord);
+                            }
+                            if(StringUtils.isNotEmpty(relation)){
+                                split = relation.split("、");
+                                if(split!=null && split.length>0){
+                                    for (String ci:split) {
+                                        if(StringUtils.isNotEmpty(ci)){
+                                            //找标准词
+                                            standWord = searchStandWord(ci,type,ciKu);
+                                            if(StringUtils.isNotEmpty(standWord)){
+                                                diseaseRepository.mergeStandardPrognosis(standWord);
+                                                diseaseRepository.mergeRelationStandardPrognosisshuyu(disName+code,standWord);
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                            break;
+                        case "9"://其他
+                            standWord = searchStandWord(standard,type,ciKu);
+                            if(StringUtils.isNotEmpty(standWord)){
+                                diseaseRepository.mergeStandardOther(standard);
+                                diseaseRepository.mergeRelationStandardOther(disId,standard);
+                                diseaseRepository.mergeRelationStandardOthershuyu(disName+code,standard);
+                            }
+                            if(StringUtils.isNotEmpty(relation)){
+                                split = relation.split("、");
+                                if(split!=null && split.length>0){
+                                    for (String ci:split) {
+                                        if(StringUtils.isNotEmpty(ci)){
+                                            //找标准词
+                                            standWord = searchStandWord(ci,type,ciKu);
+                                            if(StringUtils.isNotEmpty(standWord)){
+                                                diseaseRepository.mergeStandardOther(standWord);
+                                                diseaseRepository.mergeRelationStandardOthershuyu(disName+code,standWord);
+                                            }
+
+                                        }
+                                    }
+                                }
+                            }
+                            break;
+                    }
+                }else if("5".equals(type)){   //鉴别诊断
+                    //找标准词
+                    diseaseRepository.mergeDifferentDis(standard);
+                    diseaseRepository.mergeRelationDifferentDis(disId,standard);
+                    if(StringUtils.isNotEmpty(relation)){
+                        split = relation.split("、");
+                        if(split !=null && split.length>0){
+                            for (String dis:split) {
+                                if(StringUtils.isNotEmpty(dis)){
+                                    //找标准词
+                                    diseaseRepository.mergeDifferentDis(dis);
+                                    diseaseRepository.mergeRelationDifferentDis(disId,dis);
+                                }
+                            }
+                        }
+                    }
+                } else if("3".equals(type)){ //处理化验
+                    String lis = "";
+                    //查找化验大项的标准词
+                    standWord = searchStandWord(standard,type,ciKu);
+                    if(StringUtils.isNotEmpty(standWord)){
+                        if(StringUtils.isNotEmpty(relation) && standard.equals(relation)){
+                            lis = standWord;
+                        }else if(StringUtils.isNotEmpty(standard) && StringUtils.isEmpty(relation)){
+                            lis = standWord;
+                        }else if(StringUtils.isNotEmpty(standard)&& StringUtils.isNotEmpty(relation)&&!standard.equals(relation)){
+                            type = "subLis";
+                            if(StringUtils.isNotEmpty(searchStandWord(relation,type,ciKu))){
+                                //查找化验小项的标准词
+                                lis = standWord+"--"+searchStandWord(relation,type,ciKu);
+                            }
+
+                        }
+                    }
+
+                    //创建公表名
+                    diseaseRepository.mergePublicLIS(lis);
+                    //疾病推荐化验公表名
+                    diseaseRepository.mergeRelationLIS(disId,lis);
+                    //处理化验结果
+                    if(StringUtils.isNotEmpty(result)){
+                        lisResultSplit = result.split("、");
+                        if(lisResultSplit != null && lisResultSplit.length>0){
+                            //化验结果找标准词
+                            for (String lisRs:lisResultSplit) {
+                                if(StringUtils.isNotEmpty(lisRs)){
+                                    lisResult = searchStandWord(lisRs,"resultLis",ciKu);
+                                    if(StringUtils.isNotEmpty(lisResult)){
+                                        //创建化验结果节点
+                                        diseaseRepository.mergeLISRESULT(lisResult);
+                                        //公表名和化验结果创建关系
+                                        diseaseRepository.mergeRelationPublicLIS(lis,lisResult);
+                                        //化验结果和对应的codeCondition创建关系
+                                        diseaseRepository.mergeRelationCondiLisRes(disName+code,lisResult);
+                                    }
+
+                                }
+                            }
+                        }
+                    }
+                }else if("4".equals(type)){ //辅检
+                    //查找辅检的标准词
+                    standWord = searchStandWord(standard,type,ciKu);
+                    if(StringUtils.isNotEmpty(standWord)){
+                        //创建辅检标准词的节点
+                        diseaseRepository.mergePacs(standWord);
+                        //疾病推荐辅检
+                        diseaseRepository.mergeRelationDis2Pacs(disId,standWord);
+                    }
+                    if(StringUtils.isNotEmpty(relation)){
+                        pacsResultSplit = relation.split("、");
+                        if(pacsResultSplit != null && pacsResultSplit.length>0){
+                            for (String pacs:pacsResultSplit) {
+                                //查找辅检结果的标准词
+                                if(StringUtils.isNotEmpty(pacs)){
+                                   pacsResult = searchStandWord(pacs,"resultPacs",ciKu);
+                                   if(StringUtils.isNotEmpty(pacsResult)){
+                                       diseaseRepository.mergePacsResult(pacsResult);
+                                       //创建辅检和辅检结果关系
+                                       diseaseRepository.mergeRelationPacsResult(standWord,pacsResult);
+                                       //创建辅检结果和对应的pacsCondition的关系
+                                       diseaseRepository.mergeRelationCondiPacsRes(disName+code,pacsResult);
+                                   }
+
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+    }
+
+    /**
+     * 查找标准词
+     * @param type
+     * @return
+     */
+    public String searchStandWord(String word,String type,Map<String, Map<String, String>> ciKu){
+        String stand = null;
+        Map<String, String> detaiMap =null;
+        String label = Ciku.getLabel(type);
+        String[] labelSplits = label.split(",");
+        if(labelSplits.length == 1){
+            detaiMap = ciKu.get(word + "," + label);
+            if(detaiMap != null){
+                stand = detaiMap.get("stand");
+            }
+        }else if(labelSplits.length == 2){
+            detaiMap = ciKu.get(word + "," + labelSplits[0]);
+            if(detaiMap == null){
+                detaiMap = ciKu.get(word + "," + labelSplits[1]);
+            }
+            if(detaiMap != null){
+                stand = detaiMap.get("stand");
+            }
+        }
+        return stand;
+    }
+    /**
+     * 在图谱中删除诊断依据
+     * @param singleDisease
+     * @return
+     */
+    @Override
+    public RespDTO deleteNeoDisease(NeoParamVO singleDisease) {
+        Long disId = singleDisease.getId();
+        RespDTO respDTO = null;
+        if(disId != null){
+            this.neo4jDelete(disId);
+            respDTO = RespDTO.onSuc(true);
+        }else {
+            respDTO = RespDTO.onError(disId +" 删除失败！！！");
+        }
+        return respDTO;
+    }
+    //删除
+    public void neo4jDelete(Long disId) {
+        if (disId != null) {
+            diseaseRepository.deleteRelation1(disId);
+            diseaseRepository.deleteRelation2(disId);
+            diseaseRepository.deleteRelation3(disId);
+            diseaseRepository.deleteRelation4(disId);
+//            diseaseRepository.deleteRelation5(disId);
+            diseaseRepository.deleteRelation6(disId);
+            diseaseRepository.deleteRelation7(disId);
+            diseaseRepository.deleteRelation8(disId);
+            diseaseRepository.deleteRelation9(disId);
+            List<String> allCode = this.getAllCode(disId);
+            if(allCode.size()>0){
+                for (String conName:allCode) {
+                    diseaseRepository.deleteRelation10(conName);
+                }
+            }
+
+        }
+    }
+
+    /**
+     * 获取一个诊断依据的全部code
+     * @param disId
+     * @return
+     */
+    public List<String> getAllCode(Long disId){
+        List<String> codeList = new ArrayList<>();
+        conn = this.getConn();
+        Statement st = null;
+        ResultSet rs = null;
+        try {
+            String code ,name;
+            String sql = "SELECT dis_name,code FROM `kl_diagnose_detail` where diagnose_id="+disId+" and code != \"\"";
+            st = conn.createStatement();
+            rs = st.executeQuery(sql);
+            while (rs.next()){
+                name = rs.getString("dis_name");
+                code = rs.getString("code");
+                codeList.add(name+code);
+            }
+
+        } catch (Exception e) {
+            e.printStackTrace();
+        } finally {
+            try {
+                rs.close();
+                st.close();
+            } catch (SQLException e) {
+                e.printStackTrace();
+            }
+        }
+        return codeList;
+    }
+
     @Override
     public List<Map<String, Object>> getRecommendItem(QueryVo queryVo) {
         List<Map<String, Object>> list = relationRepository.getRecommendItem(queryVo.getDiseaselist());

graphdb/src/main/java/org/diagbot/vo/domain/NeoParamVO.java

@@ -0,0 +1,22 @@
+package org.diagbot.vo.domain;
+
+import java.io.Serializable;
+
+public class NeoParamVO implements Serializable {
+    private  Long id; //诊断依据id,是唯一的
+
+    public Long getId() {
+        return id;
+    }
+
+    public void setId(Long id) {
+        this.id = id;
+    }
+
+    @Override
+    public String toString() {
+        return "NeoParamVO{" +
+                "id=" + id +
+                '}';
+    }
+}

graphdb/src/main/java/org/diagbot/vo/domain/RespDTO.java

@@ -0,0 +1,38 @@
+package org.diagbot.vo.domain;
+
+import java.io.Serializable;
+
+/**
+ * @Description: 通用返回格式
+ * @author: gaodm
+ * @time: 2018/8/1 14:55
+ */
+public class RespDTO<T> implements Serializable {
+
+
+    public String code = "0";
+    public String msg = "";
+    public T data;
+
+    public static RespDTO onSuc(Object data) {
+        RespDTO resp = new RespDTO();
+        resp.data = data;
+        return resp;
+    }
+
+    public static RespDTO onError(String errMsg) {
+        RespDTO resp = new RespDTO();
+        resp.code = "-1";
+        resp.msg = errMsg;
+        return resp;
+    }
+
+    @Override
+    public String toString() {
+        return "RespDTO{" +
+                "code=" + code +
+                ", error='" + msg + '\'' +
+                ", data=" + data +
+                '}';
+    }
+}

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

@@ -185,17 +185,25 @@ public class KnowledgeController {
         return knowledgeService.getScale(queryVo);
     }
 
-    /*
-    @RequestMapping("/actedIn/{personId}/{movieId}")
-    public TJ actedIn(@PathVariable("personId")String personId, @PathVariable("movieId")String movieId){
-        Person person=diseaseServer.findOnePerson(Long.parseLong(personId));
-        Disease disease =diseaseServer.findOneMovie(Long.parseLong(movieId));
-        TJ TJ =new TJ();
-        TJ.setRoles("龙套");
-        TJ.setStartNode(person);
-        TJ.setEndNode(disease);
-        return diseaseServer.actedIn(TJ);
-    }
-    */
+    /**
+     * 给定诊断依据的id,删除图谱中对应的诊断依据
+     * @param disease
+     * @return
+     */
+    @RequestMapping("/deleteDisease")
+    public RespDTO deleteDiseaseData(@Valid @RequestBody NeoParamVO disease){
+        RespDTO respDTO = knowledgeService.deleteNeoDisease(disease);
+        return respDTO;
+    }
 
+    /**
+     * 给定诊断依据的id,更新图谱中对应的诊断依据
+     * @param disease
+     * @return
+     */
+    @RequestMapping("/updateDisease")
+    public RespDTO updateDiseaseData(@Valid @RequestBody NeoParamVO disease){
+        RespDTO respDTO = knowledgeService.updateNeoDisease(disease);
+        return respDTO;
+    }
 }

nlp/pom.xml

@@ -38,6 +38,13 @@
             <artifactId>poi-ooxml</artifactId>
             <version>3.17</version>
         </dependency>
+        <!-- https://mvnrepository.com/artifact/org.mongodb/bson -->
+        <dependency>
+            <groupId>org.mongodb</groupId>
+            <artifactId>bson</artifactId>
+            <version>3.10.2</version>
+        </dependency>
+
     </dependencies>
 
     <build>

nlp/src/main/resources/nlp.properties

@@ -1,3 +1,3 @@
 #Êý¾ÝÎļþ´æ·Å·¾¶
-cache.file.dir=/opt/diagbot-push/cache_file/
-#cache.file.dir=d:\\cache_file\\
+#cache.file.dir=/opt/diagbot-push/cache_file/
+cache.file.dir=d:\\cache_file\\

push-web/src/main/java/org/diagbot/push/transform/PreProcess.java

@@ -0,0 +1,295 @@
+package org.diagbot.push.transform;
+
+import org.diagbot.bigdata.common.ApplicationCacheUtil;
+import org.diagbot.common.javabean.Rule;
+import org.diagbot.common.javabean.MedicalIndication;
+import org.diagbot.common.work.LisDetail;
+import org.diagbot.common.work.ResponseData;
+import org.diagbot.common.work.SearchData;
+import org.diagbot.nlp.participle.ParticipleUtil;
+import org.diagbot.nlp.participle.word.Lexeme;
+import org.diagbot.nlp.participle.word.LexemePath;
+import org.diagbot.nlp.util.Constants;
+import org.diagbot.push.controller.ParticipleController;
+
+import java.util.*;
+import java.util.stream.Collectors;
+
+public class PreProcess {
+
+    private static String up = "升高";
+    private static String down = "降低";
+    private static String normal = "正常";
+
+    private static String pos = "阳性";
+    private static String neg = "阴性";
+
+    private List<Map<String, Object>> vitlist = new ArrayList<>();
+    private String[] vitkeyset = {"index", "value", "unit"};
+    private String[] bptype = {"血压","收缩压","舒张压","/"};
+
+    /**
+     * 处理临床数据
+     *
+     * @param searchdata
+     * @return ResponseData
+     */
+    public SearchData processClinicalData(SearchData searchdata) {
+        SearchData sData = searchdata;
+
+        sData = calculateLis(sData);
+
+        return sData;
+    }
+
+    public ResponseData applyrules(SearchData sData) {
+
+        ResponseData ruleResponse = new ResponseData();
+
+        List<MedicalIndication> reminder;
+        try {
+            Map<String, List<Rule>> rule = ApplicationCacheUtil.get_rule_filter_map();
+
+            reminder = applytolis(sData, rule);
+
+            String ClinicFind = sData.getSymptom() + " " + sData.getVital();
+            reminder.addAll(applytovital(ClinicFind, rule));
+
+            ruleResponse.setMedicalIndications(reminder);
+
+        } catch (Exception ex) {
+            ex.printStackTrace();
+        } finally {
+            return ruleResponse;
+        }
+    }
+
+    private List<MedicalIndication> applytolis(SearchData sData, Map<String, List<Rule>> rule) {
+
+        List<MedicalIndication> reminder = new ArrayList<>();
+        try {
+            List<LisDetail> lisarr = sData.getLisArr();
+            String name;
+            String detail;
+
+            for (LisDetail lis : lisarr) {
+                detail = lis.getDetailName();
+//                name = lis.getName();
+                String key = detail;
+                if (rule.get(key) != null) {
+                    reminder.addAll(comparelis(rule.get(key), lis));
+                }
+            }
+
+        } catch (Exception ex) {
+            ex.printStackTrace();
+        } finally {
+            return reminder;
+        }
+    }
+
+
+    private List<MedicalIndication> applytovital(String vital, Map<String, List<Rule>> rule) {
+
+        List<MedicalIndication> reminder = new ArrayList<>();
+
+        try {
+            Map<String, Object> vitobj = new HashMap<>();
+            Lexeme lexeme;
+            LexemePath<Lexeme> lexemes = ParticipleUtil.participle(vital);
+            for (int i=0; i<lexemes.size(); i++) {
+                lexeme = lexemes.get(i);
+                if (lexeme.getText().trim().length() > 0) {
+                    if (lexeme.getProperty().equals(Constants.word_property_vital_idx)) {
+                        vitobj = new HashMap<>();
+                        vitobj.put(vitkeyset[0], lexeme.getText());
+                    } else if (lexeme.getProperty().equals(Constants.word_property_number) &&
+                            vitobj.get(vitkeyset[0]) != null) {
+                        vitobj.put(vitkeyset[1], lexeme.getText());
+                    } else if (lexeme.getProperty().equals(Constants.word_property_unit) &&
+                            vitobj.get(vitkeyset[1]) != null) {
+                        vitobj.put(vitkeyset[2], lexeme.getText());
+
+                        if (vitobj.get(vitkeyset[0]).toString().equals(bptype[0]) &&
+                                vitobj.get(vitkeyset[1]).toString().contains(bptype[3])) {
+                            String[] idx = Arrays.asList(bptype).subList(1,3).toArray(new String[2]);
+                            String[] vals = vitobj.get(vitkeyset[1]).toString().split(bptype[3]);
+                            String unit = vitobj.get(vitkeyset[2]).toString();
+
+                            if (idx.length == vals.length) {
+                                for (int j=0; j<idx.length; j++) {
+                                    vitobj = new HashMap<>();
+                                    vitobj.put(vitkeyset[0], idx[j]);
+                                    vitobj.put(vitkeyset[1], vals[j]);
+                                    vitobj.put(vitkeyset[2], unit);
+                                    vitlist.add(vitobj);
+                                }
+                            }
+                        } else {
+                            vitlist.add(vitobj);
+                        }
+                    }
+                }
+//                System.out.println(lexeme.getText() + ": " + lexeme.getProperty());
+            }
+
+            for (Map<String, Object> obj : vitlist) {
+                String idx = obj.get(vitkeyset[0]).toString();
+                if (rule.get(idx) != null) {
+                    reminder.addAll(comparevit(rule.get(idx), obj));
+                } else { System.out.println(idx + ":\t 不存在");}
+            }
+            System.out.println("\n");
+        } catch (Exception ex) {
+            ex.printStackTrace();
+        } finally {
+            return reminder;
+        }
+    }
+    private List<MedicalIndication> comparelis(List<Rule> rules, LisDetail lis) {
+        List<MedicalIndication> reminder = new ArrayList<>();
+
+        try {
+            String detailname = lis.getDetailName();
+            Double numval = lis.getValue();
+            String unit = lis.getUnits();
+            String otherval = lis.getOtherValue();
+
+            reminder = compare(rules, reminder, detailname, numval, unit, otherval);
+        } catch (Exception ex) {
+            ex.printStackTrace();
+        } finally {
+            return reminder;
+        }
+    }
+
+
+
+    private List<MedicalIndication> comparevit(List<Rule> rules, Map<String, Object> vit) {
+        List<MedicalIndication> reminder = new ArrayList<>();
+
+        try {
+            String detailname = vit.get(vitkeyset[0]).toString();
+            Double numval = Double.valueOf(vit.get(vitkeyset[1]).toString());
+            String unit = vit.get(vitkeyset[2]).toString();
+            String otherval = "";
+
+            reminder = compare(rules, reminder, detailname, numval, unit, otherval);
+        } catch (Exception ex) {
+            ex.printStackTrace();
+        } finally {
+            return reminder;
+        }
+    }
+
+    private List<MedicalIndication> compare(List<Rule> rules, List<MedicalIndication> reminder,
+                                            String detailname, Double numval, String unit, String otherval) {
+        boolean minmatch, maxmatch;
+        Double minval, maxval;
+        String minop, maxop, minunit, maxunit;
+
+        try {
+            if (null == numval && otherval.trim().length() > 0) {
+                for (Rule rule : rules) {
+                    if (rule.getMin_operator().equals("=") && otherval.contains(rule.getMin_value())) {
+                        MedicalIndication medind = new MedicalIndication();
+                        medind.setName(rule.getRemind());
+                        medind.setRule(detailname + ": " + otherval);
+                        reminder.add(medind);
+
+                        System.out.println(medind.getRule() + " -> " + medind.getName());
+                    }
+                }
+            } else if (String.valueOf(numval).trim().length() > 0 && unit.length() > 0){
+                for (Rule rule : rules) {
+                    minmatch = maxmatch = false;
+                    minval = (rule.getMin_value().length()==0)?0:Double.valueOf(rule.getMin_value());
+                    maxval = (rule.getMax_value().length()==0)?0:Double.valueOf(rule.getMax_value());
+                    minunit = rule.getMin_unit();
+                    maxunit = rule.getMax_unit();
+                    minop = rule.getMin_operator();
+                    maxop = rule.getMax_operator();
+
+                    if ( String.valueOf(minval).trim().length() > 0 && minunit.equals(unit) ) {
+                        switch (minop) {
+                            case ">":
+                                if (numval > minval) { minmatch = true; }
+                                break;
+                            case ">=":
+                                if (numval >= minval) { minmatch = true; }
+                                break;
+                        }
+                    } else { minmatch = true; }
+
+                    if (String.valueOf(maxval).trim().length() > 0 && maxunit.equals(unit) ) {
+                        switch (maxop) {
+                            case "<":
+                                if (numval < maxval) { maxmatch = true; }
+                                break;
+                            case "<=":
+                                if (numval <= maxval) { maxmatch = true; }
+                                break;
+                        }
+                    } else { maxmatch = true; }
+
+                    if (minmatch && maxmatch) {
+                        MedicalIndication medind = new MedicalIndication();
+                        medind.setName(rule.getRemind());
+                        medind.setRule(detailname + ": " + numval + " " + unit);
+                        reminder.add(medind);
+
+                        System.out.println(medind.getRule() + " -> " + medind.getName());
+                    }
+                }
+            }
+
+        } catch (Exception ex) {
+            ex.printStackTrace();
+        } finally {
+            return reminder;
+        }
+    }
+
+    private SearchData calculateLis(SearchData sData) {
+        sData.setLisArr(processLis(sData.getLisArr()));
+
+        if (sData.getLisArr().size() > 0) {
+            List<String> otherVal = sData.getLisArr().stream().map(lisArr -> lisArr.getOtherValue()).collect(Collectors.toList());
+            sData.setLis(String.join(",", otherVal));
+        }
+
+        return sData;
+    }
+
+    private List<LisDetail> processLis(List<LisDetail> lisArr) {
+        if (lisArr.size() == 0) {
+            return lisArr;
+        }
+
+        String Otherval = "";
+
+        for (int i = 0; i < lisArr.size(); i++) {
+            LisDetail lisres = lisArr.get(i);
+
+//            Otherval = (lisres.getOtherValue().trim().length() > 0) ? lisres.getOtherValue().trim() + "\n" : "";
+            Otherval = lisres.getOtherValue();
+
+            if (Otherval.indexOf(pos) >= 0 || Otherval.indexOf(neg) >= 0) {
+                lisres.setOtherValue(lisres.getDetailName() + Otherval);
+            } else {
+                Otherval = (Otherval.trim().length() > 0) ? Otherval.trim() + "\n" : "";
+                if (lisres.getValue() == null) {
+                    continue;
+                } else if (lisres.getMaxValue() != null && lisres.getValue() > lisres.getMaxValue()) {
+                    lisres.setOtherValue(Otherval + lisres.getDetailName() + up);
+                } else if (lisres.getMinValue() != null && lisres.getValue() < lisres.getMinValue()) {
+                    lisres.setOtherValue(Otherval + lisres.getDetailName() + down);
+                } else {
+                    lisres.setOtherValue(Otherval + lisres.getDetailName() + normal);
+                }
+            }
+        }
+
+        return lisArr;
+    }
+}

push-web/src/main/resources/static/pages/algorithm/list.html

@@ -402,12 +402,12 @@
 
         } else {
             startDiag('/algorithm/page_neural', '#symptom_list', '1', resourceType, '11', '1');
-            startDiag('/algorithm/page_neural', '#vital_list', '3,2,7', resourceType, '31', '3');
-            startDiag('/algorithm/page_neural', '#lis_list', '4,2,7', resourceType, '41', '4');
-            startDiag('/algorithm/page_neural', '#pacs_list', '5,2,7', resourceType, '51', '5');
-
-            startDiagMapping('/algorithm/page_neural', '#diag_list', '2', resourceType, '21', '2');
-            startDiagMapping('/algorithm/page_neural', '#before_combine_diag_list', '2', resourceType, '21', '6');
+//            startDiag('/algorithm/page_neural', '#vital_list', '3,2,7', resourceType, '31', '3');
+//            startDiag('/algorithm/page_neural', '#lis_list', '4,2,7', resourceType, '41', '4');
+//            startDiag('/algorithm/page_neural', '#pacs_list', '5,2,7', resourceType, '51', '5');
+//
+//            startDiagMapping('/algorithm/page_neural', '#diag_list', '2', resourceType, '21', '2');
+//            startDiagMapping('/algorithm/page_neural', '#before_combine_diag_list', '2', resourceType, '21', '6');
         }
     }