Merge remote-tracking branch 'origin/master'

pom.xml

@@ -121,6 +121,18 @@
             <version>3.4.0</version>
         </dependency>
 
+        <dependency>
+            <groupId>org.neo4j</groupId>
+            <artifactId>neo4j-ogm-core</artifactId>
+            <version>3.2.9</version>
+        </dependency>
+
+        <dependency>
+            <groupId>org.springframework.data</groupId>
+            <artifactId>spring-data-neo4j</artifactId>
+            <version>5.2.3.RELEASE</version>
+        </dependency>
+
         <dependency>
             <groupId>org.projectlombok</groupId>
             <artifactId>lombok</artifactId>

src/main/java/com/diagbot/dto/BillDTO.java

@@ -1,6 +1,10 @@
 package com.diagbot.dto;
 
 import lombok.Data;
+import lombok.Getter;
+import lombok.Setter;
+
+import java.util.List;
 
 /**
  * @description: 开单合理性出参
@@ -9,7 +13,8 @@ import lombok.Data;
  */
 @Data
 public class BillDTO {
-    // 化验
+    // 化验开单合理性图谱出参
+    private List<LisBillDTO> lisbills;
 
     // 辅检
 

src/main/java/com/diagbot/dto/LisBillDTO.java

@@ -0,0 +1,51 @@
+package com.diagbot.dto;
+
+import lombok.Data;
+import lombok.Getter;
+import lombok.Setter;
+
+import java.util.List;
+
+/**
+ * @description: 化验开单合理性项目
+ * @author: Mark
+ * @time: 2020/7/29 9:57
+ */
+@Data
+@Setter
+@Getter
+public class LisBillDTO {
+    // 禁忌性别
+    private String gender;
+
+    // 年龄最小值
+    private int minage;
+
+    // 年龄最大值
+    private int maxage;
+
+    // 临床表现
+    private List<String> clinicfindings;
+
+    // 服用药品
+    private List<String> meds;
+
+    // 禁忌过敏药品
+    private List<String> allergmeds;
+
+    // 禁忌手术
+    private List<String> operations;
+
+    // 禁忌操作
+    private List<String> procedures;
+
+    // 禁忌辅助检查
+    private List<String> PACS;
+
+    // 禁忌疾病
+    private List<String> disease;
+
+    // 禁用人群
+    private List<String> group;
+
+}

src/main/java/com/diagbot/entity/node/AgeMin.java

@@ -0,0 +1,20 @@
+package com.diagbot.entity.node;
+
+import lombok.Getter;
+import lombok.Setter;
+import com.diagbot.entity.node.base.BaseNode;
+import org.neo4j.ogm.annotation.Labels;
+import org.neo4j.ogm.annotation.NodeEntity;
+
+import java.io.Serializable;
+import java.util.Set;
+
+@Getter
+@Setter
+@NodeEntity(label = "年龄最小值")
+public class AgeMin extends BaseNode implements Serializable {
+
+    @Labels
+    private Set<String> labels;
+
+}

src/main/java/com/diagbot/entity/node/Gender.java

@@ -0,0 +1,20 @@
+package com.diagbot.entity.node;
+
+import lombok.Getter;
+import lombok.Setter;
+import com.diagbot.entity.node.base.BaseNode;
+import org.neo4j.ogm.annotation.Labels;
+import org.neo4j.ogm.annotation.NodeEntity;
+
+import java.io.Serializable;
+import java.util.Set;
+
+@Getter
+@Setter
+@NodeEntity(label = "性别")
+public class Gender extends BaseNode implements Serializable {
+
+    @Labels
+    private Set<String> labels;
+
+}

src/main/java/com/diagbot/entity/node/Medicine.java

@@ -0,0 +1,20 @@
+package com.diagbot.entity.node;
+
+import lombok.Getter;
+import lombok.Setter;
+import com.diagbot.entity.node.base.BaseNode;
+import org.neo4j.ogm.annotation.Labels;
+import org.neo4j.ogm.annotation.NodeEntity;
+
+import java.io.Serializable;
+import java.util.Set;
+
+@Getter
+@Setter
+@NodeEntity(label = "药品通用名")
+public class Medicine extends BaseNode implements Serializable {
+
+    @Labels
+    private Set<String> labels;
+
+}

src/main/java/com/diagbot/entity/node/base/BaseNode.java

@@ -0,0 +1,30 @@
+package com.diagbot.entity.node.base;
+
+import jdk.nashorn.internal.objects.annotations.Property;
+import lombok.Getter;
+import lombok.Setter;
+import org.neo4j.ogm.annotation.*;
+
+import java.io.Serializable;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+/**
+ * @Description: 节点基础类
+ * @author: MarkHuang
+ * @time: 2020/3/23 15:30
+ */
+@Getter
+@Setter
+public class BaseNode implements Serializable {
+    @Id
+    @GeneratedValue
+    private Long nodeId;
+
+    @Property(name = "name")
+    private String name;
+
+//    @Labels
+//    private Set<String> labels;
+}

src/main/java/com/diagbot/entity/relationship/Medicine_AgeMin.java

@@ -0,0 +1,27 @@
+package com.diagbot.entity.relationship;
+
+import com.diagbot.entity.node.Medicine;
+import com.diagbot.entity.node.AgeMin;
+import lombok.Getter;
+import lombok.Setter;
+import org.neo4j.ogm.annotation.EndNode;
+import org.neo4j.ogm.annotation.RelationshipEntity;
+import org.neo4j.ogm.annotation.StartNode;
+
+/**
+ * 关系-鉴别诊断
+ *
+ * @author Mark Huang
+ */
+@Getter
+@Setter
+@RelationshipEntity(type="药品通用名禁忌年龄最小值")
+public class Medicine_AgeMin {
+
+    @StartNode
+    private Medicine medicine;
+
+    @EndNode
+    private AgeMin agemin;
+
+}

src/main/java/com/diagbot/entity/relationship/Medicine_Gender.java

@@ -0,0 +1,27 @@
+package com.diagbot.entity.relationship;
+
+import com.diagbot.entity.node.Medicine;
+import com.diagbot.entity.node.Gender;
+import lombok.Getter;
+import lombok.Setter;
+import org.neo4j.ogm.annotation.EndNode;
+import org.neo4j.ogm.annotation.RelationshipEntity;
+import org.neo4j.ogm.annotation.StartNode;
+
+/**
+ * 关系-鉴别诊断
+ *
+ * @author Mark Huang
+ */
+@Getter
+@Setter
+@RelationshipEntity(type="药品通用名禁忌性别")
+public class Medicine_Gender {
+
+    @StartNode
+    private Medicine medicine;
+
+    @EndNode
+    private Gender gender;
+
+}

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

@@ -0,0 +1,43 @@
+package com.diagbot.repository;
+
+import com.diagbot.entity.node.base.BaseNode;
+import org.springframework.data.neo4j.annotation.Query;
+import org.springframework.data.neo4j.repository.Neo4jRepository;
+import org.springframework.data.repository.query.Param;
+
+import java.util.List;
+
+public interface BaseNodeRepository extends Neo4jRepository<BaseNode, Long> {
+
+    @Query("MATCH (m) DELETE m")
+    void removeNodes();
+
+    @Query("MATCH (m:PreMDC) DETACH DELETE m")
+    void removePreMDC();
+
+    @Query("MATCH (m:MDC) DETACH DELETE m")
+    void removeMDC();
+
+    @Query("MATCH (m:ADRG) DETACH DELETE m")
+    void removeADRG();
+
+    @Query("MATCH (i:ICD) DETACH DELETE i")
+    void removeICD();
+
+    @Query("MATCH (n{name:{name}})-[r]->(m) WHERE type(r)={rel} RETURN m")
+    List<BaseNode> getNodesbyName_Relation(@Param("name") String name, @Param("rel") String relation);
+
+    @Query("MATCH (n) WHERE n.name={name} RETURN n")
+    List<BaseNode> getNodesbyNameIs(@Param("name") String name);
+
+    @Query("MATCH (n) WHERE n.name=~{name} RETURN n")
+    List<BaseNode> getNodesbyNameLike(@Param("name") String name);
+
+    @Query("MATCH(n) RETURN DISTINCT(LABELS(n))")
+    List<List<String>> getLabels();
+
+    @Query("MATCH (d:疾病{name:{disease}}) " +
+           "MATCH (i:ICD10编码{name:{icd}}) " +
+           "MERGE (d)-[r:{rel}]->(i) RETURN d, i")
+    List<BaseNode> connectDiseasetoICD10(@Param("disease") String disease, @Param("icd") String icd10, @Param("rel") String relation);
+}

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

@@ -0,0 +1,117 @@
+package com.diagbot.repository;
+
+import com.diagbot.entity.node.base.BaseNode;
+import com.diagbot.entity.relationship.*;
+import org.springframework.data.neo4j.annotation.Query;
+import org.springframework.data.neo4j.repository.Neo4jRepository;
+import org.springframework.data.repository.query.Param;
+
+import java.util.List;
+import java.util.Map;
+
+public interface BaseRelationRepository extends Neo4jRepository<BaseNode, Long> {
+
+    /*
+    @Query("MATCH (d:疾病{name:{disease}}), (i:编码{name:{icd}}) " +
+           "MERGE (d)-[r:疾病相关编码]->(i) RETURN r")
+    Disease_ICD DiseasetoICD(@Param("disease") String disease, @Param("icd") String icd, @Param("rel") String relation);
+
+    @Query("MATCH (d:疾病{name:{disease}}), (i:ICD10编码{name:{icd}}) " +
+           "MERGE (d)-[r:疾病相关ICD10编码]->(i) RETURN r")
+    Disease_ICD10 DiseasetoICD10(@Param("disease") String disease, @Param("icd") String icd10, @Param("rel") String relation);
+
+    @Query("MATCH (d:疾病{name:{disease}}), (s:症状{name:{symp}}) " +
+            "MERGE (d)-[r:疾病相关症状]->(s) RETURN r")
+    Disease_Symptom DiseasetoSymptom(@Param("disease") String disease, @Param("symp") String symptom, @Param("rel") String relation);
+
+    @Query("MATCH (d:疾病{name:{disease}}), (v:体征{name:{vital}}) " +
+            "MERGE (d)-[r:疾病相关体征]->(v) RETURN r")
+    Disease_Vital DiseasetoVital(@Param("disease") String disease, @Param("vital") String vital, @Param("rel") String relation);
+
+    @Query("MATCH (d:疾病{name:{disease}}), (v:科室{name:{ward}}) " +
+            "MERGE (d)-[r:疾病相关科室]->(v) SET r.rank = {rank} RETURN r")
+    Disease_Ward DiseasetoWard(@Param("disease") String disease, @Param("ward") String ward, @Param("rank") String rank);
+
+    @Query("MATCH (d:疾病{name:{disease}}), (v:科室{name:{ward}}) " +
+            "MERGE (d)-[r:疾病相关标准科室]->(v) RETURN r")
+    Disease_StdWard DiseasetoStdWard(@Param("disease") String disease, @Param("ward") String ward, @Param("rank") String relation);
+
+    @Query("MATCH (d:疾病{name:{disease}}), (dif:疾病{name:{diff}}) " +
+            "MERGE (d)-[r:鉴别诊断]->(dif) RETURN r")
+    Disease_Disease DiseasetoDisease(@Param("disease") String disease, @Param("diff") String diff, @Param("rel") String relation);
+
+    @Query("MATCH (d:疾病{name:{disease}}), (g:性别{name:{gender}}) " +
+            "MERGE (d)-[r:疾病相关性别]->(g) RETURN r")
+    Disease_Gender DiseasetoGender(@Param("disease") String disease, @Param("gender") String gender, @Param("rel") String relation);
+
+    @Query("MATCH (d:疾病{name:{disease}}), (a:疾病别名{name:{alias}}) " +
+            "MERGE (d)-[r:疾病相关别名]->(a) RETURN r")
+    Disease_DiseaseAlias DiseasetoDiseaseAlias(@Param("disease") String disease, @Param("alias") String alias, @Param("rel") String relation);
+
+    @Query("MATCH (d:疾病{name:{disease}}) " +
+            "MATCH (inc:发病率{name:{inc}}) " +
+            "MERGE (d)-[r:发病情况]->(inc) RETURN r")
+    Disease_Incidence DiseasetoIncidence(@Param("disease") String disease, @Param("inc") String incidence, @Param("rel") String relation);
+
+    @Query("MATCH (d:疾病{name:{disease}}), (a:多发人群{name:{group}}) " +
+            "MERGE (d)-[r:疾病相关多发人群]->(a) RETURN r")
+    Disease_InfectiousGroup DiseasetoInfectiousGroup(@Param("disease") String disease, @Param("group") String group, @Param("rel") String relation);
+
+    @Query("MATCH (d:疾病{name:{disease}}), (rt:传染途径{name:{route}}) " +
+            "MERGE (d)-[r:疾病相关传染途径]->(rt) RETURN r")
+    Disease_InfectionRoute DiseasetoInfectionRoute(@Param("disease") String disease, @Param("route") String route, @Param("rel") String relation);
+
+    @Query("MATCH (d:疾病{name:{disease}}), (c:治疗周期{name:{cycle}}) " +
+            "MERGE (d)-[r:疾病相关治疗周期]->(c) RETURN r")
+    Disease_TreatmentCycle DiseasetoTreatmentCycle(@Param("disease") String disease, @Param("cycle") String cycle, @Param("rel") String relation);
+
+    @Query("MATCH (d:疾病{name:{disease}}), (s:治愈率{name:{rate}}) " +
+            "MERGE (d)-[r:疾病相关治愈率]->(s) RETURN r")
+    Disease_CureRate DiseasetoCureRate(@Param("disease") String disease, @Param("rate") String rate, @Param("rel") String relation);
+
+    @Query("MATCH (d:疾病{name:{disease}}), (a:年龄{name:{age}}) " +
+            "MERGE (d)-[r:疾病相关年龄]->(a) RETURN r")
+    Disease_Age DiseasetoAge(@Param("disease") String disease, @Param("age") String age, @Param("rel") String relation);
+
+    @Query("MATCH (s:症状{name:{symptom}}), (a:症状别名{name:{alias}}) " +
+            "MERGE (s)-[r:症状相关别名]->(a) RETURN r")
+    Symptom_SymptomAlias SymptomtoSymptomAlias(@Param("symptom") String symptom, @Param("alias") String alias, @Param("rel") String relation);
+
+    @Query("match (n:症状)<-[r]-(d:疾病)-[q]->(w:科室) where n.name in [{symp}] " +
+            "RETURN distinct(w.name) as name, count(*) as cnt order by cnt desc")
+    List<Map<String, Object>> getS_D_WRelation(@Param("symp") String symp);
+
+
+    @Query("match (:症状{name:{symp1}})<-[r]-(dis:疾病) " +
+           " match (dis:疾病)-[r1]->(:症状{name:{symp2}}) " +
+            "match (dis)-[q:疾病相关标准科室]->(ward:科室) " +
+            "match (dis)-[p:发病情况]-(sit:发病率) " +
+            "return dis,q,ward,sit.name as sit ORDER BY sit.name DESC")
+    List<Map<String, Object>> getS2_D_WRelation(@Param("symp1") String symp1, @Param("symp2") String symp2);
+
+
+    @Query("match (:症状{name:{symp1}})<-[r]-(dis1:疾病) " +
+            " match (dis1:疾病)-[r1]->(:症状{name:{symp2}}) " +
+            " with dis1.name as names " +
+            " match (dis:疾病)-[r2]->(:症状{name:{symp3}}) " +
+            " match (dis)-[q:疾病相关科室]->(ward:科室) " +
+            " match (dis)-[p:发病情况]-(sit:发病率) " +
+            " where dis.name in names " +
+            " return dis,q,ward ORDER BY sit.name DESC")
+    List<Map<String, Object>> getS3_D_WRelation(@Param("symp1") String symp1, @Param("symp2") String symp2, @Param("symp3") String symp3);
+
+
+    @Query("match (n:科室{name:{ward}})<-[r:疾病相关标准科室]-(d:疾病)-[r1:疾病相关症状]-(s:症状) " +
+           "return s.name as name, count(s) as cnt order by cnt desc")
+    List<Map<String, Object>> getRelatedSympbyward(@Param("ward") String ward);
+
+
+
+    @Query("match (rate:发病率)<-[r:发病情况]-(dis:疾病)-[q:疾病相关科室]->(w:科室) " +
+           " where w.name in {wards} return w.name as name, dis.name as dis, rate.name, q.rank " +
+           " ORDER BY rate.name DESC, q.rank ASC")
+    List<Map<String, Object>> getRelatedDiseasebyward(@Param("wards") List<String> wards);
+    */
+
+}
+

src/main/java/com/diagbot/service/GraphService.java

@@ -0,0 +1,110 @@
+package com.diagbot.service;
+
+/*
+import com.lantone.entity.node.*;
+import com.lantone.entity.node.base.BaseNode;
+import com.lantone.entity.relationship.*;
+import org.springframework.data.repository.query.Param;
+
+import java.util.List;
+import java.util.Map;
+
+public interface GraphService {
+
+
+//    Disease addDisease(Disease disease);
+//    List<Disease> find(Disease disease);
+    Disease findDiseasebyName(String name);
+//    Disease findOneDisease(long id);
+//    void deleteOneDisease(long id);
+
+
+
+    Symptom addSymptom(Symptom symptom);
+    List<Symptom> find(Symptom symptom);
+    Symptom findSymptombyName(String name);
+//    List<Symptom> getAllSymptom();
+
+
+    /*
+    Vital addVital(Vital vital);
+    List<Vital> find(Vital vital);
+
+    Age addAge(Age age);
+    Age find(Age age);
+
+    Gender addGender(Gender gender);
+    List<Gender> find(Gender gender);
+
+    PACS addPACS(PACS pacs);
+
+    PACSResult addPACSResult(PACSResult pacsResult);
+
+    /*
+    Surgery addSurgery(Surgery surgery);
+
+    PreMDC addPreMDC(PreMDC preMDC);
+
+    MDC addMDC(MDC mdc);
+
+    MDC findMDC(String code);
+    MDC findMDC(String code, String name);
+
+    ADRG addADRG(ADRG adrg);
+
+    ADRG findADRG(String code, String name);
+    */
+
+    /*
+    ICD addICD(ICD icd);
+    ICD10 addICD10(ICD10 icd10);
+//    ICD11 addICD11(ICD11 icd11);
+
+    Ward addWard(Ward ward);
+    Incidence addIncidence(Incidence incidence);
+    Disease_Alias addDiseaseAlias(Disease_Alias disease_alias);
+    *
+    Symptom_Alias addSymptomAlias(Symptom_Alias symptom_alias);
+    /*
+    InfectiousGroup addInfectiousGroup(InfectiousGroup infectiousGroup);
+    InfectionRoute addInfectionRoute(InfectionRoute infectionRoute);
+    TreatmentCycle addTreatmentCycle(TreatmentCycle treatmentCycle);
+    CureRate addCureRate(CureRate cureRate);
+
+//    void connectDiseasetoICD10(Disease disease, ICD10 icd10, String relation);
+
+    Disease_ICD DiseasetoICD(Disease disease, ICD icd, String relation);
+    Disease_ICD10 DiseasetoICD10(Disease disease, ICD10 icd10, String relation);
+    Disease_Symptom DiseasetoSymptom(Disease disease, Symptom symptom, String relation);
+    Disease_Vital DiseasetoVital(Disease disease, Vital vital, String relation);
+    Disease_Ward DiseasetoWard(Disease disease, Ward ward, String relation);
+    Disease_StdWard DiseasetoStdWard(Disease disease, Ward ward, String relation);
+    Disease_Disease DiseasetoDisease(Disease disease, Disease diff_disease, String relation);
+    Disease_Incidence DiseasetoIncidence(Disease disease, Incidence incidence, String relation);
+    Disease_Gender DiseasetoGender(Disease disease, Gender gender, String relation);
+    Disease_DiseaseAlias DiseasetoDiseaseAlias(Disease disease, Disease_Alias disease_alias, String relation);
+    Disease_InfectiousGroup DiseasetoInfectiousGroup(Disease disease, InfectiousGroup infectiousGroup, String relation);
+    Disease_InfectionRoute DiseasetoInfectionRoute(Disease disease, InfectionRoute infectionRoute, String relation);
+    Disease_TreatmentCycle DiseasetoTreatmentCycle(Disease disease, TreatmentCycle treatmentCycle, String relation);
+    Disease_CureRate DiseasetoCureRate(Disease disease, CureRate cureRate, String relation);
+    Disease_Age DiseasetoAge(Disease disease, Age age, String relation);
+    *
+    Symptom_SymptomAlias SymptomtoSymptomAlias(Symptom symptom, Symptom_Alias symptom_alias, String relation);
+
+
+    List<BaseNode> getNodesbyName(String name);
+    List<BaseNode> getNodesbyName_Relation(String name, String relation);
+    List<List<String>> getLabels();
+
+    /*
+    List<Map<String, Object>> getS_D_W_Relations(String symp);
+    List<Map<String, Object>> getS2_D_W_Relations(String symp1, String symp2);
+    List<Map<String, Object>> getS3_D_W_Relations(String symp1, String symp2, String symp3);
+
+    List<Map<String, Object>> getRelatedSympsbyWard(String ward);
+    List<Map<String, Object>> getRelatedDiseasebyWard(List<String> wards);
+
+
+
+}
+*/

src/main/java/com/diagbot/service/impl/GraphServiceImpl.java

@@ -0,0 +1,808 @@
+package com.diagbot.service.impl;
+
+/*
+import com.lantone.entity.node.*;
+import com.lantone.entity.node.base.BaseNode;
+import com.lantone.entity.relationship.*;
+import com.lantone.repository.*;
+import com.lantone.service.GraphService;
+
+//import org.apache.commons.collections4.IteratorUtils;
+import org.apache.commons.lang3.StringUtils;
+import org.neo4j.driver.types.Node;
+import org.neo4j.driver.types.Path;
+
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.domain.Pageable;
+import org.springframework.stereotype.Service;
+
+import java.util.*;
+
+
+@Service
+public class GraphServiceImpl implements GraphService {
+    Logger logger = LoggerFactory.getLogger(GraphServiceImpl.class);
+
+
+    @Autowired
+    private DiseaseRepository diseaseRepository;
+    @Autowired
+    private SymptomRepository symptomRepository;
+    /*
+    @Autowired
+    private VitalRepository vitalRepository;
+    @Autowired
+    private PACSRepository pacsRepository;
+    @Autowired
+    private PACSResultRepository pacsResultRepository;
+    @Autowired
+    private SurgeryRepository surgeryRepository;
+    @Autowired
+    private GenderRepository genderRepository;
+    @Autowired
+    private DiseaseAliasRepository diseaseAliasRepository;
+    *
+    @Autowired
+    private SymptomAliasRepository symptomAliasRepository;
+    /*
+    @Autowired
+    private InfectiousGroupRepository infectiousGroupRepository;
+    @Autowired
+    private InfectionRouteRepository infectionRouteRepository;
+    @Autowired
+    private TreatmentCycleRepository treatmentCycleRepository;
+    @Autowired
+    private CureRateRepository cureRateRepository;
+    @Autowired
+    private AgeRepository ageRepository;
+    *
+    @Autowired
+    private BaseNodeRepository baseNodeRepository;
+
+    /*
+    @Autowired
+    private ADRGRepository adrgRepository;
+    @Autowired
+    private PreMDCRepository preMDCRepository;
+    @Autowired
+    private MDCRepository mdcRepository;
+    *
+    @Autowired
+    private ICDRepository icdRepository;
+    @Autowired
+    private ICD10Repository icd10Repository;
+    /*
+    @Autowired
+    private ICD11Repository icd11Repository;
+    */
+    /*
+    @Autowired
+    private IncidenceRepository incidenceRepository;
+    @Autowired
+    private WardRepository wardRepository;
+    *
+    @Autowired
+    private BaseRelationRepository baseRelationRepository;
+
+    private List<BaseNode> baseNodes;
+
+    private Pageable pageable;
+
+
+    /**
+     * 删除所有节点
+     *
+    @Override
+    public void removeNodes() {
+        baseNodeRepository.removeNodes();
+    }
+
+
+
+    /**
+     * 删除所有preMDC节点
+     *
+    @Override
+    public void removePreMDC() {
+        baseNodeRepository.removePreMDC();
+    }
+
+
+    /**
+     * 删除所有MDC节点
+     *
+    @Override
+    public void removeMDC() {
+        baseNodeRepository.removeMDC();
+    }
+
+    /**
+     * 删除所有DRG节点
+     *
+    @Override
+    public void removeADRG() {
+        baseNodeRepository.removeADRG();
+    }
+
+    /**
+     * 删除所有ICD节点
+     *
+    @Override
+    public void removeICD() {
+        baseNodeRepository.removeICD();
+    }
+
+    /**
+     * 处理症状节点相关的申请
+     *
+    @Override
+    public Symptom addSymptom(Symptom symptom) {
+        return symptomRepository.add(symptom.getName());
+    }
+
+
+    @Override
+    public Symptom findSymptombyName(String name) {
+        return symptomRepository.findbyNameIs(name);
+    }
+
+    @Override
+    public List<Symptom> find(Symptom symptom) {
+        return symptomRepository.findbyNameLike(symptom.getName());
+    }
+
+    /*
+    @Override
+    public void deleteOneSymptom(long id) {
+        symptomRepository.deleteById(id);
+    }
+    *
+
+
+    @Override
+    public List<Symptom> getAllSymptom() {
+//        pageable = getPageable(pageVo);
+        return IteratorUtils.toList(symptomRepository.findAll().iterator());
+    }
+    */
+
+
+    /**
+     * 处理体征节点相关的申请
+     *
+    @Override
+    public Vital addVital(Vital vital) {
+        return vitalRepository.add(vital.getName());
+    }
+
+    @Override
+    public List<Vital> find(Vital vital) {
+        return vitalRepository.find(vital.getName());
+    }
+
+
+    /**
+     * 处理年龄节点相关的申请
+     *
+    @Override
+    public Age addAge(Age age) {
+        return ageRepository.add(age.getName());
+    }
+
+    @Override
+    public Age find(Age age) {
+        return ageRepository.find(age.getName());
+    }
+
+
+    /**
+     * 处理性别节点相关的申请
+     *
+    @Override
+    public Gender addGender(Gender gender) { return genderRepository.add(gender.getName()); }
+
+    @Override
+    public List<Gender> find(Gender gender) { return genderRepository.find(gender.getName()); }
+
+    /**
+     * 处理疾病节点相关的申请
+     *
+    @Override
+    public Disease addDisease(Disease disease) {
+        return diseaseRepository.add(disease.getName());
+    }
+
+    /*
+    @Override
+    public Disease findOneDisease(long id) {
+        return diseaseRepository.findById(id).get();
+    }
+    *
+
+
+    @Override
+    public Disease findDiseasebyName(String name) {
+        return diseaseRepository.findByNameIs(name);
+    }
+
+
+    /*
+    @Override
+    public List<Disease> find(Disease disease) {
+        return diseaseRepository.findByNameLike(disease.getName());
+    }
+
+
+    @Override
+    public void deleteOneDisease(long id) {
+        diseaseRepository.deleteById(id);
+    }
+
+
+    /**
+     * 处理辅检节点相关的申请
+     *
+    @Override
+    public PACS addPACS(PACS pacs) {
+        return pacsRepository.add(pacs.getName());
+    }
+
+    /**
+     * 处理辅检结果节点相关的申请
+     *
+    @Override
+    public PACSResult addPACSResult(PACSResult pacsResult) {
+        return pacsResultRepository.add(pacsResult.getName());
+    }
+
+
+
+    /**
+     * 处理手术节点相关的申请
+     *
+    @Override
+    public Surgery addSurgery(Surgery surgery) {
+        return surgeryRepository.save(surgery);
+    }
+
+    /**
+     * 添加先期处理节点
+     *
+    @Override
+    public PreMDC addPreMDC(PreMDC preMDC) { return preMDCRepository.save(preMDC); }
+
+    /**
+     * 添加主要诊断大类节点
+     *
+    @Override
+    public MDC addMDC(MDC mdc) { return mdcRepository.save(mdc); }
+
+    /**
+     * 查找主要诊断大类节点
+     *
+    @Override
+    public MDC findMDC(String code) { return mdcRepository.find(code); }
+
+    @Override
+    public MDC findMDC(String code, String name) { return mdcRepository.find(code, name); }
+
+    /**
+     * 添加诊断相关组节点
+     *
+    @Override
+    public ADRG addADRG(ADRG adrg) { return adrgRepository.save(adrg); }
+
+    /**
+     * 查找诊断相关组节点
+     *
+    @Override
+    public ADRG findADRG(String code, String name) { return adrgRepository.find(code, name); }
+
+
+    /**
+     * 添加ICD节点
+     *
+    @Override
+    public ICD addICD(ICD icd) { return icdRepository.add(icd.getName()); }
+
+
+    /**
+     * 添加ICD-10节点
+     *
+    @Override
+    public ICD10 addICD10(ICD10 icd10) { return icd10Repository.add(icd10.getName()); }
+
+
+    /**
+     * 添加ICD-11节点
+     *
+    @Override
+    public ICD11 addICD11(ICD11 icd11) { return icd11Repository.add(icd11.getName()); }
+
+
+    /**
+     * 添加科室节点
+     *
+    @Override
+    public Ward addWard(Ward ward) {
+        String name = ward.getName();
+        if (StringUtils.isNumeric(ward.getName().substring(0,1))) {
+            name = ward.getName().substring(1);
+        }
+        return wardRepository.add(name);
+    }
+
+
+    /**
+     * 添加疾病别名节点
+     *
+    @Override
+    public Disease_Alias addDiseaseAlias(Disease_Alias disease_alias) {
+        return diseaseAliasRepository.add(disease_alias.getName());
+    }
+
+
+    /**
+     * 添加症状别名节点
+     *
+    @Override
+    public Symptom_Alias addSymptomAlias(Symptom_Alias symptom_alias) {
+        return symptomAliasRepository.add(symptom_alias.getName());
+    }
+
+    /**
+     * 添加疾病易发人群节点
+     *
+    @Override
+    public InfectiousGroup addInfectiousGroup(InfectiousGroup infectiousGroup) {
+        return infectiousGroupRepository.add(infectiousGroup.getName());
+    }
+
+
+    /**
+     * 处理传染途径节点相关的申请
+     *
+    @Override
+    public InfectionRoute addInfectionRoute(InfectionRoute infectionRoute) {
+        return infectionRouteRepository.add(infectionRoute.getName());
+    }
+
+
+    /**
+     * 处理治疗周期节点相关的申请
+     *
+    @Override
+    public TreatmentCycle addTreatmentCycle(TreatmentCycle treatmentCycle) {
+        return treatmentCycleRepository.add(treatmentCycle.getName());
+    }
+
+
+    /**
+     * 处理治愈率节点相关的申请
+     *
+    @Override
+    public CureRate addCureRate(CureRate cureRate) {
+        return cureRateRepository.add(cureRate.getName());
+    }
+
+
+    /**
+     * 处理疾病节点到ICD10节点间关系
+     * @param
+     * @return
+     *
+    @Override
+    public void connectDiseasetoICD10(Disease disease, ICD10 icd10, String relation) {
+        baseNodeRepository.connectDiseasetoICD10(disease.getName(), icd10.getName(), relation);
+    }
+    */
+
+
+    /**
+     * 处理疾病节点到ICD节点间关系
+     * @param
+     * @return
+     *
+    @Override
+    public Disease_ICD DiseasetoICD(Disease disease, ICD icd, String relation) {
+        Disease_ICD disease_icd = baseRelationRepository.DiseasetoICD(disease.getName(), icd.getName(), relation);
+
+        if (null != disease_icd) {
+            disease = disease_icd.getDisease();
+            icd = disease_icd.getIcd();
+
+            if (null != disease && null != icd) {
+                disease.setIcd(icd);
+                icd.setDisease(disease);
+            }
+        }
+
+        return disease_icd;
+    }
+
+    /**
+     * 处理疾病节点到ICD10节点间关系
+     * @param
+     * @return
+     *
+    @Override
+    public Disease_ICD10 DiseasetoICD10(Disease disease, ICD10 icd10, String relation) {
+        Disease_ICD10 disease_icd10 = baseRelationRepository.DiseasetoICD10(disease.getName(), icd10.getName(), relation);
+
+        if (null != disease_icd10) {
+            disease = disease_icd10.getDisease();
+            icd10 = disease_icd10.getIcd10();
+
+            if (null != disease && null != icd10) {
+                disease.setIcd10(icd10);
+                icd10.setDisease(disease);
+            }
+        }
+
+        return disease_icd10;
+    }
+
+    /**
+     * 添加发病率节点
+     *
+    @Override
+    public Incidence addIncidence(Incidence incidence) { return incidenceRepository.add(incidence.getName()); }
+
+
+    /**
+     * 处理疾病节点到发病率节点间的关系
+     *
+    @Override
+    public Disease_Incidence DiseasetoIncidence(Disease disease, Incidence incidence, String relation) {
+        Disease_Incidence disease_incidence =
+                baseRelationRepository.DiseasetoIncidence(disease.getName(), incidence.getName(), relation);
+
+        if (null != disease_incidence) {
+            disease = disease_incidence.getDisease();
+            incidence = disease_incidence.getIncidence();
+
+            if (null != disease && incidence != null) {
+                disease.setIncidence(incidence);
+                incidence.setDisease(disease);
+            }
+        }
+
+        return disease_incidence;
+    }
+
+
+    /**
+     * 处理疾病节点到症状的节点间关系
+     *
+    @Override
+    public Disease_Symptom DiseasetoSymptom(Disease disease, Symptom symptom, String relation) {
+        Disease_Symptom disease_symptom =
+                baseRelationRepository.DiseasetoSymptom(disease.getName(), symptom.getName(), relation);
+
+        if (null != disease_symptom) {
+            disease = disease_symptom.getDisease();
+            symptom = disease_symptom.getSymptom();
+
+            if (null != disease && null != symptom) {
+                disease.setSymptom(symptom);
+                symptom.setDisease(disease);
+            }
+        }
+
+        return disease_symptom;
+    }
+
+
+    /**
+     * 处理疾病节点到体征的节点间关系
+     *
+    @Override
+    public Disease_Vital DiseasetoVital(Disease disease, Vital vital, String relation) {
+        Disease_Vital disease_vital =
+                baseRelationRepository.DiseasetoVital(disease.getName(), vital.getName(), relation);
+
+        if (null != disease_vital) {
+            disease = disease_vital.getDisease();
+            vital = disease_vital.getVital();
+
+            if (null != disease && null != vital) {
+                disease.setVital(vital);
+                vital.setDisease(disease);
+            }
+        }
+
+        return disease_vital;
+    }
+
+
+    /**
+     * 处理疾病节点到性别的节点间关系
+     *
+    @Override
+    public Disease_Gender DiseasetoGender(Disease disease, Gender gender, String relation) {
+        Disease_Gender disease_gender =
+                baseRelationRepository.DiseasetoGender(disease.getName(), gender.getName(), relation);
+
+        if (null != disease_gender) {
+            disease = disease_gender.getDisease();
+            gender = disease_gender.getGender();
+
+        }
+
+        return disease_gender;
+    }
+
+    /**
+     * 处理疾病节点到疾病别名的节点之间关系
+     *
+    @Override
+    public Disease_DiseaseAlias DiseasetoDiseaseAlias(Disease disease, Disease_Alias disease_alias, String relation) {
+        Disease_DiseaseAlias disease_diseaseAlias  =
+                baseRelationRepository.DiseasetoDiseaseAlias(disease.getName(), disease_alias.getName(), relation);
+
+        if (null != disease_diseaseAlias) {
+            disease = disease_diseaseAlias.getDisease();
+            disease_alias = disease_diseaseAlias.getDisease_alias();
+        }
+
+        return  disease_diseaseAlias;
+    }
+
+
+    /**
+     * 处理症状节点到症状别名的节点之间关系
+     *
+    @Override
+    public Symptom_SymptomAlias SymptomtoSymptomAlias(Symptom symptom, Symptom_Alias symptom_alias, String relation) {
+        Symptom_SymptomAlias symptom_symptomAlias =
+                baseRelationRepository.SymptomtoSymptomAlias(symptom.getName(), symptom_alias.getName(), relation);
+
+        if (null != symptom_symptomAlias) {
+            symptom = symptom_symptomAlias.getSymptom();
+            symptom_alias = symptom_symptomAlias.getSymptom_alias();
+        }
+
+        return  symptom_symptomAlias;
+    }
+
+
+    /**
+     * 处理疾病节点到多发人群的节点之间关系
+     *
+    @Override
+    public Disease_InfectiousGroup DiseasetoInfectiousGroup(Disease disease, InfectiousGroup infectiousGroup, String relation) {
+        Disease_InfectiousGroup disease_infectiousGroup  =
+                baseRelationRepository.DiseasetoInfectiousGroup(disease.getName(), infectiousGroup.getName(), relation);
+
+        if (null != disease_infectiousGroup) {
+            disease = disease_infectiousGroup.getDisease();
+            infectiousGroup = disease_infectiousGroup.getInfectiousGroup();
+        }
+
+        return  disease_infectiousGroup;
+    }
+
+
+    /**
+     * 处理疾病节点到传染途径的节点间关系
+     *
+    @Override
+    public Disease_InfectionRoute DiseasetoInfectionRoute(Disease disease, InfectionRoute route, String relation) {
+        Disease_InfectionRoute disease_infectionRoute =
+                baseRelationRepository.DiseasetoInfectionRoute(disease.getName(), route.getName(), relation);
+
+        if (null != disease_infectionRoute) {
+            disease = disease_infectionRoute.getDisease();
+            route = disease_infectionRoute.getInfectionRoute();
+
+        }
+
+        return disease_infectionRoute;
+    }
+
+
+
+    /**
+     * 处理疾病节点到治疗周期的节点间关系
+     *
+    @Override
+    public Disease_TreatmentCycle DiseasetoTreatmentCycle(Disease disease, TreatmentCycle treatmentCycle, String relation) {
+        Disease_TreatmentCycle disease_treatmentCycle =
+                baseRelationRepository.DiseasetoTreatmentCycle(disease.getName(), treatmentCycle.getName(), relation);
+
+        if (null != disease_treatmentCycle) {
+            disease = disease_treatmentCycle.getDisease();
+            treatmentCycle = disease_treatmentCycle.getTreatmentCycle();
+
+        }
+
+        return disease_treatmentCycle;
+    }
+
+
+
+    /**
+     * 处理疾病节点到治愈率的节点间关系
+     *
+    @Override
+    public Disease_CureRate DiseasetoCureRate(Disease disease, CureRate cureRate, String relation) {
+        Disease_CureRate disease_cureRate =
+                baseRelationRepository.DiseasetoCureRate(disease.getName(), cureRate.getName(), relation);
+
+        if (null != disease_cureRate) {
+            disease = disease_cureRate.getDisease();
+            cureRate = disease_cureRate.getCureRate();
+
+        }
+
+        return disease_cureRate;
+    }
+
+
+
+
+
+    /**
+     * 处理疾病节点到科室的节点间关系
+     *
+    @Override
+    public Disease_Ward DiseasetoWard(Disease disease, Ward ward, String relation) {
+        String rank = ward.getName().substring(0,1);
+        String ward_name = ward.getName().substring(1);
+//        wardRepository.rename(ward.getName(), ward_name);
+        Disease_Ward disease_ward =
+                baseRelationRepository.DiseasetoWard(disease.getName(), ward_name, rank);
+
+        return disease_ward;
+    }
+
+
+    /**
+     * 处理疾病节点到标准科室的节点间关系
+     *
+    @Override
+    public Disease_StdWard DiseasetoStdWard(Disease disease, Ward ward, String relation) {
+
+        Disease_StdWard disease_stdward =
+                baseRelationRepository.DiseasetoStdWard(disease.getName(), ward.getName(), relation);
+
+        return disease_stdward;
+    }
+
+
+    /**
+     * 处理疾病节点到鉴别诊断的节点间关系
+     *
+    @Override
+    public Disease_Disease DiseasetoDisease(Disease disease, Disease diff, String relation) {
+        Disease_Disease disease_diff =
+                baseRelationRepository.DiseasetoDisease(disease.getName(), diff.getName(), relation);
+
+        if (null != disease_diff) {
+            disease = disease_diff.getDisease();
+            diff = disease_diff.getDiff_disease();
+
+            if (null != disease && null != diff) {
+                disease.setDisease(diff);
+            }
+        }
+
+        return disease_diff;
+    }
+
+
+
+    /**
+     * 处理疾病节点到年龄节点间关系
+     *
+    @Override
+    public Disease_Age DiseasetoAge(Disease disease, Age age, String relation) {
+        Disease_Age disease_age =
+                baseRelationRepository.DiseasetoAge(disease.getName(), age.getName(), relation);
+
+        if (null != disease_age) {
+            disease = disease_age.getDisease();
+            age = disease_age.getAge();
+
+            if (null != disease && null != age) {
+                disease.setAge(age);
+            }
+        }
+
+        return disease_age;
+    }
+
+    /*
+    @Override
+    public List<BaseRelation> getRelation(Long start_id, String name) {
+        return relationRepository.getRelation(start_id, name);
+    }
+    */
+
+    /**
+     * 根据节点的名称查询
+     * @param name
+     *
+    @Override
+    public List<BaseNode> getNodesbyName(String name) {
+        if (name.contains("*")) {
+            name = name.replaceAll("\\*",".\\*");
+            return baseNodeRepository.getNodesbyNameLike(name);
+        }
+        else {
+            return baseNodeRepository.getNodesbyNameIs(name);
+        }
+    }
+
+    /**
+     * 根据起始节点的名称和关系查询终止节点
+//     * @param name
+//     * @param relation
+     * @return List<BaseNode>
+     *
+    @Override
+    public List<BaseNode> getNodesbyName_Relation(String name, String relation) {
+        return baseNodeRepository.getNodesbyName_Relation(name, relation);
+    }
+
+
+
+    /**
+     * 获取所有标签
+     *
+    @Override
+    public List<List<String>> getLabels() {
+        return baseNodeRepository.getLabels();
+    }
+
+
+
+    /**
+     * 获取单个症状，疾病和科室的关系
+     *
+    @Override
+    public List<Map<String, Object>> getS_D_W_Relations(String symp) {
+        return baseRelationRepository.getS_D_WRelation(symp);
+    }
+
+    /**
+     * 获取两个症状，疾病和科室的关系
+     *
+    @Override
+    public List<Map<String, Object>> getS2_D_W_Relations(String symp1, String symp2) {
+        return baseRelationRepository.getS2_D_WRelation(symp1, symp2);
+    }
+
+
+    /**
+     * 获取三个症状，疾病和科室的关系
+     *
+    @Override
+    public List<Map<String, Object>> getS3_D_W_Relations(String symp1, String symp2, String symp3) {
+        return baseRelationRepository.getS3_D_WRelation(symp1, symp2, symp3);
+    }
+
+
+    /**
+     * 根据科室获取相关症状
+     *
+    @Override
+    public List<Map<String, Object>> getRelatedSympsbyWard(String ward) {
+        return  baseRelationRepository.getRelatedSympbyward(ward);
+    }
+
+
+    /**
+     * 根据科室及发病率获取相关诊断
+     *
+    @Override
+    public List<Map<String, Object>> getRelatedDiseasebyWard(List<String> wards) {
+        return baseRelationRepository.getRelatedDiseasebyward(wards);
+    }
+    *
+
+}
+     */

src/main/resources/application-local.yml

@@ -43,7 +43,7 @@ spring:
       datasource:
         neo4j:
           driver-class-name: org.neo4j.jdbc.Driver
-          url: jdbc:neo4j:http://192.168.2.234:7472
+          url: jdbc:neo4j:http://192.168.3.150:7478
           username: neo4j
           password: root
           #定义初始连接数