更新针对新图谱的实体及查询的方法

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

@@ -0,0 +1,51 @@
+package com.diagbot.dto;
+
+import lombok.Data;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * @description: 联合项目开单合理性图谱数据
+ * @author: Mark
+ * @time: 2020/7/29 9:57
+ */
+@Data
+public class CombiOpBillNeoDTO {
+    // 禁忌性别
+    private NodeNeoDTO gender;
+
+    // 年龄
+    private NodeNeoDTO ageNeoDTO;
+
+    // 临床表现
+    private List<NodeNeoDTO> clinicfindings = new ArrayList<>();
+
+    // 体征
+    private List<NodeNeoDTO> vitals = new ArrayList<>();
+
+    // 服用药品
+    private List<NodeNeoDTO> oralmeds = new ArrayList<>();
+
+    // 禁忌药品过敏源
+    private List<NodeNeoDTO> medallergens = new ArrayList<>();
+
+    // 禁忌实验室检查
+    private List<NodeNeoDTO> lis = new ArrayList<>();
+
+    // 禁忌操作
+    private List<NodeNeoDTO> procedures = new ArrayList<>();
+
+    // 禁忌辅助检查
+    private List<NodeNeoDTO> pacs = new ArrayList<>();
+
+    // 禁忌疾病
+    private List<NodeNeoDTO> disease = new ArrayList<>();
+
+    // 禁用人群
+    private List<NodeNeoDTO> group = new ArrayList<>();
+
+    // 禁用辅助检查描述
+    private List<NodeNeoDTO> pacsDesc = new ArrayList<>();
+
+}

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

@@ -50,4 +50,11 @@ public class OperationBillNeoDTO {
 
     // 禁用辅助检查描述
     private List<NodeNeoDTO> pacsDesc = new ArrayList<>();
+
+    // 禁忌药物过敏原
+    private List<NodeNeoDTO> medallegen = new ArrayList<>();
+
+    // 禁忌禁忌医疗器械及物品
+    private List<NodeNeoDTO> meddevice = new ArrayList<>();
+
 }

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

@@ -1,40 +0,0 @@
-package com.diagbot.entity.node;
-
-import lombok.Data;
-import com.diagbot.entity.node.base.BaseNode;
-import lombok.EqualsAndHashCode;
-import lombok.Getter;
-import lombok.Setter;
-import org.neo4j.ogm.annotation.Labels;
-import org.neo4j.ogm.annotation.NodeEntity;
-import org.neo4j.ogm.annotation.Property;
-import org.neo4j.ogm.annotation.Relationship;
-
-import java.io.Serializable;
-import java.util.Set;
-
-@Setter
-@Getter
-//@EqualsAndHashCode(callSuper = false)
-@NodeEntity(label = "年龄")
-public class Age extends BaseNode  {
-
-    @Property(name = "最大值")
-    private Integer maxval;
-
-    @Property(name = "最小值")
-    private Integer minval;
-
-    @Relationship(type="疾病相关年龄", direction = Relationship.INCOMING)
-    private Set<Disease> diseases;
-
-    @Relationship(type="药品通用名禁忌年龄", direction = Relationship.INCOMING)
-    private Set<Medicine> medicines;
-
-    @Relationship(type = "辅助检查禁忌年龄", direction = Relationship.INCOMING)
-    private Set<PACS> pacs;
-
-    @Relationship(type="实验室检查禁忌年龄", direction = Relationship.INCOMING)
-    private Set<LIS> lis;
-}
-

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

@@ -1,29 +0,0 @@
-package com.diagbot.entity.node;
-
-import lombok.Data;
-import com.diagbot.entity.node.base.BaseNode;
-import lombok.EqualsAndHashCode;
-import lombok.Getter;
-import lombok.Setter;
-import org.neo4j.ogm.annotation.Labels;
-import org.neo4j.ogm.annotation.NodeEntity;
-import org.neo4j.ogm.annotation.Relationship;
-
-import java.io.Serializable;
-import java.util.Set;
-
-@Setter
-@Getter
-//@EqualsAndHashCode(callSuper = false)
-@NodeEntity(label = "过敏药品")
-public class AllergicMed extends BaseNode  {
-
-    @Relationship(type="药品通用名禁忌过敏药品", direction = Relationship.INCOMING)
-    private Set<Medicine> medicines;
-
-    @Relationship(type="辅助检查禁忌过敏药品", direction = Relationship.INCOMING)
-    private Set<PACS> pacs;
-
-    @Relationship(type="实验室检查禁忌过敏药品", direction = Relationship.INCOMING)
-    private Set<LIS> lis;
-}

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

@@ -1,19 +0,0 @@
-package com.diagbot.entity.node;
-
-import com.diagbot.entity.node.base.BaseNode;
-import lombok.Getter;
-import lombok.Setter;
-import org.neo4j.ogm.annotation.NodeEntity;
-import org.neo4j.ogm.annotation.Relationship;
-
-import java.util.Set;
-
-@Setter
-@Getter
-//@EqualsAndHashCode(callSuper = false)
-@NodeEntity(label = "发病原因")
-public class Cause extends BaseNode  {
-
-    @Relationship(type="疾病相关发病原因", direction = Relationship.INCOMING)
-    private Set<Disease> diseases;
-}

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

@@ -1,40 +0,0 @@
-package com.diagbot.entity.node;
-
-import com.diagbot.entity.node.base.BaseNode;
-import lombok.EqualsAndHashCode;
-import lombok.Getter;
-import lombok.Setter;
-import org.neo4j.ogm.annotation.NodeEntity;
-import org.neo4j.ogm.annotation.Property;
-import org.neo4j.ogm.annotation.Relationship;
-
-import java.util.Set;
-
-@Setter
-@Getter
-//@EqualsAndHashCode(callSuper = true)
-@NodeEntity(label = "临床表现")
-public class ClinicalFinding extends BaseNode  {
-
-    @Property(name = "最大值")
-    private Double maxval;
-
-    @Property(name = "最小值")
-    private Double minval;
-
-    @Property(name = "单位")
-    private String unit;
-
-    @Property(name = "范围")
-    private Integer range;
-
-    @Relationship(type="药品通用名禁忌临床表现", direction = Relationship.INCOMING)
-    private Set<Medicine> medicines;
-
-    @Relationship(type="辅助检查禁忌临床表现", direction = Relationship.INCOMING)
-    private Set<PACS> pacs;
-
-    @Relationship(type="实验室检查禁忌临床表现", direction = Relationship.INCOMING)
-    private Set<ClinicalFinding> clinicalfindings;
-
-}

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

@@ -1,19 +0,0 @@
-package com.diagbot.entity.node;
-
-import com.diagbot.entity.node.base.BaseNode;
-import lombok.Getter;
-import lombok.Setter;
-import org.neo4j.ogm.annotation.NodeEntity;
-import org.neo4j.ogm.annotation.Relationship;
-
-import java.util.Set;
-
-@Setter
-@Getter
-//@EqualsAndHashCode(callSuper = false)
-@NodeEntity(label = "编码")
-public class Code extends BaseNode  {
-
-    @Relationship(type="疾病相关编码", direction = Relationship.INCOMING)
-    private Set<Disease> diseases;
-}

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

@@ -1,19 +0,0 @@
-package com.diagbot.entity.node;
-
-import com.diagbot.entity.node.base.BaseNode;
-import lombok.Getter;
-import lombok.Setter;
-import org.neo4j.ogm.annotation.NodeEntity;
-import org.neo4j.ogm.annotation.Relationship;
-
-import java.util.Set;
-
-@Setter
-@Getter
-//@EqualsAndHashCode(callSuper = false)
-@NodeEntity(label = "并发症")
-public class Complication extends BaseNode  {
-
-    @Relationship(type="疾病相关并发症", direction = Relationship.INCOMING)
-    private Set<Disease> diseases;
-}

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

@@ -1,23 +0,0 @@
-package com.diagbot.entity.node;
-
-import lombok.Data;
-import com.diagbot.entity.node.base.BaseNode;
-import lombok.EqualsAndHashCode;
-import lombok.Getter;
-import lombok.Setter;
-import org.neo4j.ogm.annotation.Labels;
-import org.neo4j.ogm.annotation.NodeEntity;
-import org.neo4j.ogm.annotation.Relationship;
-
-import java.io.Serializable;
-import java.util.Set;
-
-@Setter
-@Getter
-//@EqualsAndHashCode(callSuper = false)
-@NodeEntity(label = "配伍")
-public class ConflictMed extends BaseNode  {
-
-    @Relationship(type="药品通用名禁忌配伍", direction = Relationship.INCOMING)
-    private Set<Medicine> medicines;
-}

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

@@ -1,19 +0,0 @@
-package com.diagbot.entity.node;
-
-import com.diagbot.entity.node.base.BaseNode;
-import lombok.Getter;
-import lombok.Setter;
-import org.neo4j.ogm.annotation.NodeEntity;
-import org.neo4j.ogm.annotation.Relationship;
-
-import java.util.Set;
-
-@Setter
-@Getter
-//@EqualsAndHashCode(callSuper = false)
-@NodeEntity(label = "治愈率")
-public class CureRate extends BaseNode  {
-
-    @Relationship(type="疾病相关治愈率", direction = Relationship.INCOMING)
-    private Set<Disease> diseases;
-}

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

@@ -1,19 +0,0 @@
-package com.diagbot.entity.node;
-
-import com.diagbot.entity.node.base.BaseNode;
-import lombok.Getter;
-import lombok.Setter;
-import org.neo4j.ogm.annotation.NodeEntity;
-import org.neo4j.ogm.annotation.Relationship;
-
-import java.util.Set;
-
-@Setter
-@Getter
-//@EqualsAndHashCode(callSuper = false)
-@NodeEntity(label = "科室")
-public class Dept extends BaseNode  {
-
-    @Relationship(type="疾病相关科室", direction = Relationship.INCOMING)
-    private Set<Disease> diseases;
-}

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

@@ -1,123 +0,0 @@
-package com.diagbot.entity.node;
-
-import lombok.Data;
-import com.diagbot.entity.node.base.BaseNode;
-import lombok.EqualsAndHashCode;
-import lombok.Getter;
-import lombok.Setter;
-import org.neo4j.ogm.annotation.Labels;
-import org.neo4j.ogm.annotation.NodeEntity;
-import org.neo4j.ogm.annotation.Relationship;
-
-import java.io.Serializable;
-import java.util.HashSet;
-import java.util.Set;
-
-@Setter
-@Getter
-//@EqualsAndHashCode(callSuper = false)
-@NodeEntity(label = "疾病")
-public class Disease extends BaseNode  {
-
-    @Relationship(type="疾病相关年龄", direction = Relationship.OUTGOING)
-    private Age age;
-
-    @Relationship(type="疾病相关性别", direction = Relationship.OUTGOING)
-    private Gender gender;
-
-    @Relationship(type="疾病相关治愈率", direction = Relationship.OUTGOING)
-    private CureRate curerate;
-
-    @Relationship(type="疾病相关治疗周期", direction = Relationship.OUTGOING)
-    private TreatCycle treatcycle;
-
-    @Relationship(type="疾病相关传染途径", direction = Relationship.OUTGOING)
-    private Set<Infection> infections = new HashSet<>();
-
-    @Relationship(type="疾病相关多发人群", direction = Relationship.OUTGOING)
-    private Set<Group> groups = new HashSet<>();
-
-    @Relationship(type="疾病相关体征", direction = Relationship.OUTGOING)
-    private Set<Vital> vitals = new HashSet<>();
-
-    @Relationship(type="疾病相关科室", direction = Relationship.OUTGOING)
-    private Set<Dept> depts = new HashSet<>();
-
-    @Relationship(type="疾病相关症状", direction = Relationship.OUTGOING)
-    private Set<Symptom> symptoms = new HashSet<>();
-
-    @Relationship(type="疾病相关发病情况", direction = Relationship.OUTGOING)
-    private Set<Situation> situations = new HashSet<>();
-
-    @Relationship(type="疾病相关编码", direction = Relationship.OUTGOING)
-    private Code code;
-
-    @Relationship(type="疾病相关标准科室", direction = Relationship.OUTGOING)
-    private Set<Dept> stddepts = new HashSet<>();
-
-    @Relationship(type="疾病相关并发症", direction = Relationship.OUTGOING)
-    private Set<Complication> complications = new HashSet<>();
-
-    @Relationship(type="疾病相关检查", direction = Relationship.OUTGOING)
-    private Set<PACS> pacss = new HashSet<>();
-
-    @Relationship(type="疾病相关药品", direction = Relationship.OUTGOING)
-    private Set<Medicine> medicines = new HashSet<>();
-
-    @Relationship(type="疾病相关发病原因", direction = Relationship.OUTGOING)
-    private Set<Cause> causes = new HashSet<>();
-
-    @Relationship(type="疾病相关鉴别诊断", direction = Relationship.OUTGOING)
-    private Set<Disease> diff_diseases = new HashSet<>();
-
-    @Relationship(type="疾病相关手术和操作", direction = Relationship.OUTGOING)
-    private Set<Operation> operations = new HashSet<>();
-
-    @Relationship(type="疾病相关病原体", direction = Relationship.OUTGOING)
-    private Set<Pathogen> pathogens = new HashSet<>();
-
-    @Relationship(type="疾病相关遗传性", direction = Relationship.OUTGOING)
-    private Set<Heredity> hereditys = new HashSet<>();
-
-    @Relationship(type="疾病相关治疗", direction = Relationship.OUTGOING)
-    private Set<Treatment> treatments = new HashSet<>();
-
-    @Relationship(type="疾病相关分型", direction = Relationship.OUTGOING)
-    private Set<DiseaseType> diseasetypes = new HashSet<>();
-
-    @Relationship(type="疾病相关局部并发症", direction = Relationship.OUTGOING)
-    private Set<Complication> localcompls = new HashSet<>();
-
-    @Relationship(type="疾病相关全身并发症", direction = Relationship.OUTGOING)
-    private Set<Complication> generalcompls = new HashSet<>();
-
-    @Relationship(type="疾病相关化验", direction = Relationship.OUTGOING)
-    private Set<LIS> liss = new HashSet<>();
-
-    @Relationship(type="疾病相关实验室检查", direction = Relationship.OUTGOING)
-    private Set<LIS> liss_dis = new HashSet<>();
-
-    @Relationship(type="疾病相关辅助检查", direction = Relationship.OUTGOING)
-    private Set<PACS> pacs = new HashSet<>();
-
-    @Relationship(type="疾病相关药品代码通用名", direction = Relationship.OUTGOING)
-    private Medicine_Code medicine_code;
-
-    @Relationship(type="药品通用名禁忌疾病", direction = Relationship.INCOMING)
-    private Set<Medicine> medicine_conflict_diseases;
-
-    @Relationship(type="辅助检查禁忌疾病", direction = Relationship.INCOMING)
-    private Set<PACS> pacs_conflict_diseases;
-
-    @Relationship(type="实验室检查禁忌疾病", direction = Relationship.INCOMING)
-    private Set<Disease> lis_conflict_diseases;
-
-    @Relationship(type="手术和操作禁忌疾病", direction = Relationship.INCOMING)
-    private Set<Operation> operation_conflict_diseases;
-}
-
-
-
-
-
-

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

@@ -1,19 +0,0 @@
-package com.diagbot.entity.node;
-
-import com.diagbot.entity.node.base.BaseNode;
-import lombok.Getter;
-import lombok.Setter;
-import org.neo4j.ogm.annotation.NodeEntity;
-import org.neo4j.ogm.annotation.Relationship;
-
-import java.util.Set;
-
-@Setter
-@Getter
-//@EqualsAndHashCode(callSuper = false)
-@NodeEntity(label = "分型")
-public class DiseaseType extends BaseNode  {
-
-    @Relationship(type="疾病相关分型", direction = Relationship.INCOMING)
-    private Set<Disease> diseases;
-}

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

@@ -1,32 +0,0 @@
-package com.diagbot.entity.node;
-
-import lombok.Data;
-import com.diagbot.entity.node.base.BaseNode;
-import lombok.EqualsAndHashCode;
-import lombok.Getter;
-import lombok.Setter;
-import org.neo4j.ogm.annotation.Labels;
-import org.neo4j.ogm.annotation.NodeEntity;
-import org.neo4j.ogm.annotation.Relationship;
-
-import java.io.Serializable;
-import java.util.Set;
-
-@Setter
-@Getter
-//@EqualsAndHashCode(callSuper = false)
-@NodeEntity(label = "性别")
-public class Gender extends BaseNode  {
-
-    @Relationship(type="疾病相关性别", direction = Relationship.INCOMING)
-    private Set<Disease> diseases;
-
-    @Relationship(type="药品通用名禁忌性别", direction = Relationship.INCOMING)
-    private Set<Medicine> medicines;
-
-    @Relationship(type = "辅助检查禁忌性别", direction = Relationship.INCOMING)
-    private Set<PACS> pacs;
-
-    @Relationship(type="实验室检查禁忌性别", direction = Relationship.INCOMING)
-    private Set<LIS> lis;
-}

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

@@ -1,32 +0,0 @@
-package com.diagbot.entity.node;
-
-import lombok.Data;
-import com.diagbot.entity.node.base.BaseNode;
-import lombok.EqualsAndHashCode;
-import lombok.Getter;
-import lombok.Setter;
-import org.neo4j.ogm.annotation.Labels;
-import org.neo4j.ogm.annotation.NodeEntity;
-import org.neo4j.ogm.annotation.Relationship;
-
-import java.io.Serializable;
-import java.util.Set;
-
-@Setter
-@Getter
-//@EqualsAndHashCode(callSuper = false)
-@NodeEntity(label = "人群")
-public class Group extends BaseNode  {
-
-    @Relationship(type="疾病相关多发人群", direction = Relationship.INCOMING)
-    private Set<Disease> diseases;
-
-    @Relationship(type="药品通用名禁忌人群", direction = Relationship.INCOMING)
-    private Set<Medicine> medicines;
-
-    @Relationship(type="辅助检查禁忌人群", direction = Relationship.INCOMING)
-    private Set<PACS> pacs;
-
-    @Relationship(type="实验室检查禁忌人群", direction = Relationship.INCOMING)
-    private Set<LIS> lis;
-}

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

@@ -1,19 +0,0 @@
-package com.diagbot.entity.node;
-
-import com.diagbot.entity.node.base.BaseNode;
-import lombok.Getter;
-import lombok.Setter;
-import org.neo4j.ogm.annotation.NodeEntity;
-import org.neo4j.ogm.annotation.Relationship;
-
-import java.util.Set;
-
-@Setter
-@Getter
-//@EqualsAndHashCode(callSuper = false)
-@NodeEntity(label = "遗传性")
-public class Heredity extends BaseNode  {
-
-    @Relationship(type="疾病相关遗传性", direction = Relationship.INCOMING)
-    private Set<Disease> diseases;
-}

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

@@ -1,43 +0,0 @@
-package com.diagbot.entity.node;
-
-import com.diagbot.entity.node.base.BaseNode;
-import lombok.Getter;
-import lombok.Setter;
-import org.neo4j.ogm.annotation.NodeEntity;
-import org.neo4j.ogm.annotation.Property;
-import org.neo4j.ogm.annotation.Relationship;
-
-import java.util.HashSet;
-import java.util.Set;
-
-@Setter
-@Getter
-//@EqualsAndHashCode(callSuper = false)
-@NodeEntity(label = "医保ICD_10疾病")
-public class ICDDisease extends BaseNode  {
-
-    @Property(name="医保ICD-10代码")
-    private String icdcode;
-
-    @Property(name="疾病名称")
-    private String othername;
-
-    @Property(name="静态知识")
-    private String knowledge;
-
-    @Relationship(type="医保ICD-10疾病相关实验室检查", direction = Relationship.OUTGOING)
-    private Set<LIS> liss_dis = new HashSet<>();
-
-    @Relationship(type="医保ICD-10疾病相关辅助检查", direction = Relationship.OUTGOING)
-    private Set<PACS> pacs = new HashSet<>();
-
-    @Relationship(type="医保ICD-10疾病相关实验室检查套餐", direction = Relationship.OUTGOING)
-    private Set<LISPack> lispack_dis = new HashSet<>();
-
-}
-
-
-
-
-
-

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

@@ -1,19 +0,0 @@
-package com.diagbot.entity.node;
-
-import com.diagbot.entity.node.base.BaseNode;
-import lombok.Getter;
-import lombok.Setter;
-import org.neo4j.ogm.annotation.NodeEntity;
-import org.neo4j.ogm.annotation.Relationship;
-
-import java.util.Set;
-
-@Setter
-@Getter
-//@EqualsAndHashCode(callSuper = false)
-@NodeEntity(label = "传染途径")
-public class Infection extends BaseNode  {
-
-    @Relationship(type="疾病相关传染途径", direction = Relationship.INCOMING)
-    private Set<Disease> diseases;
-}

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

@@ -1,94 +1,45 @@
 package com.diagbot.entity.node;
 
-import lombok.Data;
 import com.diagbot.entity.node.base.BaseNode;
-import lombok.EqualsAndHashCode;
 import lombok.Getter;
 import lombok.Setter;
-import org.neo4j.ogm.annotation.Labels;
 import org.neo4j.ogm.annotation.NodeEntity;
 import org.neo4j.ogm.annotation.Property;
 import org.neo4j.ogm.annotation.Relationship;
 
-import java.io.Serializable;
-import java.math.BigDecimal;
-import java.util.HashSet;
 import java.util.Set;
+import java.util.HashSet;
 
 @Setter
 @Getter
-//@EqualsAndHashCode(callSuper = false)
 @NodeEntity(label = "实验室检查")
-public class LIS extends BaseNode  {
-
-    @Property(name = "最大值")
-    private Double maxval;
-
-    @Property(name = "最小值")
-    private Double minval;
-
-    @Property(name = "单位")
-    private String unit;
-
-    @Property(name = "范围")
-    private Integer range;
-
-    @Relationship(type="实验室检查项目相关套餐", direction = Relationship.OUTGOING)
-    private Set<LISPack> lisPacks = new HashSet<>();
-
-    @Relationship(type="实验室检查相关实验室检查危急值", direction = Relationship.OUTGOING)
-    private Set<LISCritical> liscritial = new HashSet<>();
-
-    @Relationship(type="实验室检查禁忌性别", direction = Relationship.OUTGOING)
-    private Gender gender;
-
-    @Relationship(type="实验室检查禁忌年龄", direction = Relationship.OUTGOING)
-    private Age age;
-
-    @Relationship(type="实验室检查禁忌临床表现", direction = Relationship.OUTGOING)
-    private Set<ClinicalFinding> clinicalfindings = new HashSet<>();
-
-    @Relationship(type="实验室检查禁忌体征", direction = Relationship.OUTGOING)
-    private Set<Vital> vitals = new HashSet<>();
-
-    @Relationship(type="实验室检查禁忌服用药品", direction = Relationship.OUTGOING)
-    private Set<Medicine> conflict_medicines = new HashSet<>();
-
-    @Relationship(type="实验室检查禁忌过敏药品", direction = Relationship.OUTGOING)
-    private Set<AllergicMed> allergicmeds = new HashSet<>();
-
-    @Relationship(type="实验室检查禁忌手术和操作", direction = Relationship.OUTGOING)
-    private Set<Operation> operations = new HashSet<>();
-
-    @Relationship(type="实验室检查禁忌操作", direction = Relationship.OUTGOING)
-    private Set<Procedure> procedures = new HashSet<>();
-
-    @Relationship(type="实验室检查禁忌辅助检查", direction = Relationship.OUTGOING)
-    private Set<PACS> pacs = new HashSet<>();
+public class Lis extends BaseNode  {
 
-    @Relationship(type="实验室检查禁忌疾病", direction = Relationship.OUTGOING)
-    private Set<Disease> diseases = new HashSet<>();
+	@Property(name = "单位")
+	private String unit;
 
-    @Relationship(type="实验室检查禁忌人群", direction = Relationship.OUTGOING)
-    private Set<Group> groups = new HashSet<>();
+	@Property(name = "最小值")
+	private Double minval;
 
-    @Relationship(type="疾病相关化验", direction = Relationship.INCOMING)
-    private Set<Disease> disease_related_inspect;
+	@Property(name = "最大值")
+	private Double maxval;
 
-    @Relationship(type="疾病相关实验室检查", direction = Relationship.INCOMING)
-    private Set<Disease> disease_related_lis;
+	@Property(name = "范围")
+	private Integer range;
 
-    @Relationship(type="药品通用名禁忌实验室检查", direction = Relationship.INCOMING)
-    private Set<Medicine> medicine_conflict_lis;
+	@Relationship(type = "医保手术和操作名称禁忌实验室检查", direction = Relationship.INCOMING)
+	private Set<YiBaoOperationName> yibaooperationnames = new HashSet<>();
 
-    @Relationship(type="辅助检查禁忌实验室检查", direction = Relationship.INCOMING)
-    private Set<PACS> pacs_conflict_lis;
+	@Relationship(type = "辅助检查名称禁忌实验室检查", direction = Relationship.INCOMING)
+	private Set<Pacs> pacss = new HashSet<>();
 
-    @Relationship(type="医保ICD-10疾病相关实验室检查", direction = Relationship.INCOMING)
-    private Set<Disease> icddis_related_lis = new HashSet<>();
+	@Relationship(type = "联合项目禁忌实验室检查", direction = Relationship.INCOMING)
+	private Set<CombiOperation> combioperations = new HashSet<>();
 
-    @Relationship(type="实验室检查套餐相关实验室检查", direction = Relationship.INCOMING)
-    private Set<LISPack> lisPacks_related_lis = new HashSet<>();
-}
+//	@Relationship(type = "辅助检查禁忌实验室检查", direction = Relationship.INCOMING)
+//	private Set<Pacs> pacss = new HashSet<>();
 
+	@Relationship(type = "医保手术和操作禁忌实验室检查", direction = Relationship.INCOMING)
+	private Set<YiBaoOperation> yibaooperations = new HashSet<>();
 
+}

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

@@ -1,37 +0,0 @@
-package com.diagbot.entity.node;
-
-import com.diagbot.entity.node.base.BaseNode;
-import lombok.Getter;
-import lombok.Setter;
-import org.neo4j.ogm.annotation.NodeEntity;
-import org.neo4j.ogm.annotation.Property;
-import org.neo4j.ogm.annotation.Relationship;
-
-
-@Setter
-@Getter
-//@EqualsAndHashCode(callSuper = false)
-@NodeEntity(label = "实验室检查危急值")
-public class LISCritical extends BaseNode  {
-
-    @Property(name = "高危急值")
-    private String maxval;
-
-    @Property(name = "低危急值")
-    private String minval;
-
-    @Property(name = "单位")
-    private String unit;
-
-    @Property(name = "年龄")
-    private String age;
-
-    @Property(name = "危急值范围")
-    private String range;
-
-    @Relationship(type="实验室检查相关实验室检查危急值", direction = Relationship.INCOMING)
-    private LIS lis_related_liscritial;
-
-}
-
-

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

@@ -1,81 +0,0 @@
-package com.diagbot.entity.node;
-
-import com.diagbot.entity.node.base.BaseNode;
-import lombok.Getter;
-import lombok.Setter;
-import org.neo4j.ogm.annotation.NodeEntity;
-import org.neo4j.ogm.annotation.Property;
-import org.neo4j.ogm.annotation.Relationship;
-
-import java.util.HashSet;
-import java.util.Set;
-
-@Setter
-@Getter
-//@EqualsAndHashCode(callSuper = false)
-@NodeEntity(label = "实验室检查套餐")
-public class LISPack extends BaseNode  {
-
-    @Property(name = "最大值")
-    private Double maxval;
-
-    @Property(name = "最小值")
-    private Double minval;
-
-    @Property(name = "单位")
-    private String unit;
-
-    @Relationship(type="实验室检查套餐相关实验室检查", direction = Relationship.OUTGOING)
-    private Set<LIS> lisPacks_related_lis = new HashSet<>();
-
-    @Relationship(type="实验室检查套餐禁忌性别", direction = Relationship.OUTGOING)
-    private Gender gender;
-
-    @Relationship(type="实验室检查套餐禁忌年龄", direction = Relationship.OUTGOING)
-    private Age age;
-
-    @Relationship(type="实验室检查套餐禁忌临床表现", direction = Relationship.OUTGOING)
-    private Set<ClinicalFinding> clinicalfindings = new HashSet<>();
-
-    @Relationship(type="实验室检查套餐禁忌服用药品", direction = Relationship.OUTGOING)
-    private Set<Medicine> conflict_medicines = new HashSet<>();
-
-    @Relationship(type="实验室检查套餐禁忌过敏药品", direction = Relationship.OUTGOING)
-    private Set<AllergicMed> allergicmeds = new HashSet<>();
-
-    @Relationship(type="实验室检查套餐禁忌手术和操作", direction = Relationship.OUTGOING)
-    private Set<Operation> operations = new HashSet<>();
-
-    @Relationship(type="实验室检查套餐禁忌操作", direction = Relationship.OUTGOING)
-    private Set<Procedure> procedures = new HashSet<>();
-
-    @Relationship(type="实验室检查套餐禁忌辅助检查", direction = Relationship.OUTGOING)
-    private Set<PACS> pacs = new HashSet<>();
-
-    @Relationship(type="实验室检查套餐禁忌疾病", direction = Relationship.OUTGOING)
-    private Set<Disease> diseases = new HashSet<>();
-
-    @Relationship(type="实验室检查套餐禁忌人群", direction = Relationship.OUTGOING)
-    private Set<Group> groups = new HashSet<>();
-
-    @Relationship(type="疾病相关化验套餐", direction = Relationship.INCOMING)
-    private Set<Disease> disease_related_inspect;
-
-    @Relationship(type="疾病相关实验室检查套餐", direction = Relationship.INCOMING)
-    private Set<Disease> disease_related_lispack;
-
-    @Relationship(type="药品通用名禁忌实验室检查套餐", direction = Relationship.INCOMING)
-    private Set<Medicine> medicine_conflict_lispack;
-
-    @Relationship(type="辅助检查禁忌实验室检查套餐", direction = Relationship.INCOMING)
-    private Set<PACS> pacs_conflict_lispack;
-
-    @Relationship(type="医保ICD-10疾病相关实验室检查套餐", direction = Relationship.INCOMING)
-    private Set<Disease> icddis_related_lispack = new HashSet<>();
-
-    @Relationship(type="实验室检查项目相关套餐", direction = Relationship.INCOMING)
-    private Set<LIS> lis_related_lisPack = new HashSet<>();
-
-}
-
-

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

@@ -1,74 +1,22 @@
 package com.diagbot.entity.node;
 
 import com.diagbot.entity.node.base.BaseNode;
-import lombok.EqualsAndHashCode;
 import lombok.Getter;
 import lombok.Setter;
-import org.neo4j.ogm.annotation.Labels;
 import org.neo4j.ogm.annotation.NodeEntity;
 import org.neo4j.ogm.annotation.Property;
 import org.neo4j.ogm.annotation.Relationship;
 
-import java.io.Serializable;
-import java.util.*;
+import java.util.Set;
+import java.util.HashSet;
 
 @Setter
 @Getter
-@EqualsAndHashCode(callSuper = true)
-@NodeEntity(label = "药品通用名")
-public class Medicine extends BaseNode implements Serializable {
+@NodeEntity(label = "药品通用名称")
+public class Medicine extends BaseNode  {
 
-    @Property(name = "高危级别")
-    private String risklevel;
-
-    @Relationship(type = "药品通用名禁忌性别", direction = Relationship.OUTGOING)
-    private Gender gender;
-
-    @Relationship(type = "药品通用名禁忌年龄", direction = Relationship.OUTGOING)
-    private Age age;
-
-    @Relationship(type = "药品通用名禁忌临床表现", direction = Relationship.OUTGOING)
-    private Set<ClinicalFinding> clinicalfindings = new HashSet<>();
-
-    @Relationship(type = "药品通用名禁忌体征", direction = Relationship.OUTGOING)
-    private Set<Vital> vitals = new HashSet<>();
-
-    @Relationship(type = "药品通用名禁忌实验室检查", direction = Relationship.OUTGOING)
-    private Set<LIS> lisset = new HashSet<>();
-
-    @Relationship(type = "药品通用名禁忌辅助检查", direction = Relationship.OUTGOING)
-    private Set<PACS> pacs = new HashSet<>();
-
-    @Relationship(type = "药品通用名禁忌过敏药品", direction = Relationship.OUTGOING)
-    private Set<AllergicMed> allergicmeds = new HashSet<>();
-
-    @Relationship(type = "药品通用名禁忌手术和操作", direction = Relationship.OUTGOING)
-    private Set<Operation> operations = new HashSet<>();
-
-    @Relationship(type = "药品通用名禁忌操作", direction = Relationship.OUTGOING)
-    private Set<Procedure> procedures = new HashSet<>();
-
-    @Relationship(type = "药品通用名禁忌疾病", direction = Relationship.OUTGOING)
-    private Set<Disease> diseases = new HashSet<>();
-
-    @Relationship(type = "药品通用名禁忌人群", direction = Relationship.OUTGOING)
-    private Set<Group> groups = new HashSet<>();
-
-    @Relationship(type = "药品通用名禁忌配伍", direction = Relationship.OUTGOING)
-    private Set<ConflictMed> conflictmeds = new HashSet<>();
-
-    @Relationship(type="疾病相关药品", direction = Relationship.INCOMING)
-    private Set<Disease> disease_related_meds;
-
-    @Relationship(type="药品代码名相关药品通用名称", direction = Relationship.INCOMING)
-    private Set<Medicine_Code> medicinecode_related_medicine;
-
-    @Relationship(type="辅助检查禁忌服用药品", direction = Relationship.INCOMING)
-    private Set<PACS> pacs_conflict_medicine;
-
-    @Relationship(type="实验室检查禁忌服用药品", direction = Relationship.INCOMING)
-    private Set<Medicine> lis_conflict_medicine;
-
-}
 
+	@Relationship(type = "药品相关药品通用名称", direction = Relationship.INCOMING)
+	private Set<MedCodeName> medcodenames = new HashSet<>();
 
+}

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

@@ -1,21 +0,0 @@
-package com.diagbot.entity.node;
-
-import com.diagbot.entity.node.base.BaseNode;
-import lombok.Getter;
-import lombok.Setter;
-import org.neo4j.ogm.annotation.NodeEntity;
-import org.neo4j.ogm.annotation.Relationship;
-
-import java.util.HashSet;
-import java.util.Set;
-
-@Setter
-@Getter
-//@EqualsAndHashCode(callSuper = false)
-@NodeEntity(label = "药品解刨学类别")
-public class Medicine_Anatomy extends BaseNode  {
-
-    @Relationship(type="药品相关药品解刨学类别", direction = Relationship.INCOMING)
-    private Set<Medicine_Code> medicine_related_Anatomy = new HashSet<>();
-
-}

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

@@ -1,24 +0,0 @@
-package com.diagbot.entity.node;
-
-import com.diagbot.entity.node.base.BaseNode;
-import lombok.Getter;
-import lombok.Setter;
-import org.neo4j.ogm.annotation.NodeEntity;
-import org.neo4j.ogm.annotation.Relationship;
-
-import java.util.HashSet;
-import java.util.Set;
-
-@Setter
-@Getter
-//@EqualsAndHashCode(callSuper = false)
-@NodeEntity(label = "药品代码通用名")
-public class Medicine_Code extends BaseNode  {
-
-    @Relationship(type="药品相关药品通用名称", direction = Relationship.OUTGOING)
-    private Set<Medicine> medicinecode_related_medicine = new HashSet<>();
-
-    @Relationship(type="药品相关药品解刨学类别", direction = Relationship.OUTGOING)
-    private Set<Medicine_Anatomy> medicine_related_Anatomy = new HashSet<>();
-
-}

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

@@ -1,63 +0,0 @@
-package com.diagbot.entity.node;
-
-import lombok.Data;
-import com.diagbot.entity.node.base.BaseNode;
-import lombok.EqualsAndHashCode;
-import lombok.Getter;
-import lombok.Setter;
-import org.neo4j.ogm.annotation.Labels;
-import org.neo4j.ogm.annotation.NodeEntity;
-import org.neo4j.ogm.annotation.Property;
-import org.neo4j.ogm.annotation.Relationship;
-
-import java.io.Serializable;
-import java.util.HashSet;
-import java.util.Set;
-
-@Setter
-@Getter
-//@EqualsAndHashCode(callSuper = false)
-@NodeEntity(label = "手术和操作")
-public class Operation extends BaseNode  {
-
-    @Property(name = "高危级别")
-    private String risklevel;
-
-    @Relationship(type = "手术和操作禁忌性别", direction = Relationship.OUTGOING)
-    private Gender gender;
-
-    @Relationship(type = "手术和操作禁忌体征", direction = Relationship.OUTGOING)
-    private Set<Vital> vitals = new HashSet<>();
-
-    @Relationship(type = "手术和操作禁忌临床表现", direction = Relationship.OUTGOING)
-    private Set<ClinicalFinding> clinicalFindings = new HashSet<>();
-
-    @Relationship(type = "手术和操作禁忌实验室检查", direction = Relationship.OUTGOING)
-    private Set<LIS> conflict_lis = new HashSet<>();
-
-    @Relationship(type = "手术和操作禁忌辅助检查描述", direction = Relationship.OUTGOING)
-    private Set<PACSDescribe> conflict_pacsdesc = new HashSet<>();
-
-    @Relationship(type = "手术和操作禁忌服用药品", direction = Relationship.OUTGOING)
-    private Set<OralMedicine> oralMedicines = new HashSet<>();
-
-    @Relationship(type = "手术和操作禁忌疾病", direction = Relationship.OUTGOING)
-    private Set<Disease> conflict_diseases = new HashSet<>();
-
-    @Relationship(type = "手术和操作禁忌人群", direction = Relationship.OUTGOING)
-    private Set<Group> groups = new HashSet<>();
-
-    @Relationship(type="疾病相关手术和操作", direction = Relationship.INCOMING)
-    private Set<Disease> diseases = new HashSet<>();
-
-    @Relationship(type="药品通用名禁忌手术和操作", direction = Relationship.INCOMING)
-    private Set<Medicine> medicines = new HashSet<>();
-
-    @Relationship(type="辅助检查禁忌手术和操作", direction = Relationship.INCOMING)
-    private Set<PACS> pacs = new HashSet<>();
-
-    @Relationship(type="实验室检查禁忌手术和操作", direction = Relationship.INCOMING)
-    private Set<LIS> lis = new HashSet<>();
-}
-
-

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

@@ -1,34 +1,25 @@
 package com.diagbot.entity.node;
 
 import com.diagbot.entity.node.base.BaseNode;
-import lombok.EqualsAndHashCode;
 import lombok.Getter;
 import lombok.Setter;
 import org.neo4j.ogm.annotation.NodeEntity;
+import org.neo4j.ogm.annotation.Property;
 import org.neo4j.ogm.annotation.Relationship;
 
-import java.io.Serializable;
-import java.util.HashSet;
 import java.util.Set;
+import java.util.HashSet;
 
 @Setter
 @Getter
-@EqualsAndHashCode(callSuper = true)
 @NodeEntity(label = "服用药品")
-public class OralMedicine extends BaseNode implements Serializable {
-
-    @Relationship(type="疾病相关药品", direction = Relationship.INCOMING)
-    private Set<Disease> disease_related_meds;
-
-    @Relationship(type="药品相关化学物质类别", direction = Relationship.INCOMING)
-    private Set<Disease> medicine_related_chem;
-
-    @Relationship(type="辅助检查禁忌服用药品", direction = Relationship.INCOMING)
-    private Set<PACS> pacs_conflict_medicine;
+public class OralMedicine extends BaseNode  {
 
-    @Relationship(type="实验室检查禁忌服用药品", direction = Relationship.INCOMING)
-    private Set<OralMedicine> lis_conflict_medicine;
 
-}
+	@Relationship(type = "医保手术和操作名称禁忌服用药品", direction = Relationship.INCOMING)
+	private Set<YiBaoOperationName> yibaooperationnames = new HashSet<>();
 
+	@Relationship(type = "辅助检查名称禁忌服用药品", direction = Relationship.INCOMING)
+	private Set<Pacs> pacss = new HashSet<>();
 
+}

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

@@ -1,89 +1,22 @@
 package com.diagbot.entity.node;
 
-import lombok.Data;
 import com.diagbot.entity.node.base.BaseNode;
-import lombok.EqualsAndHashCode;
 import lombok.Getter;
 import lombok.Setter;
-import org.neo4j.ogm.annotation.Labels;
 import org.neo4j.ogm.annotation.NodeEntity;
 import org.neo4j.ogm.annotation.Property;
 import org.neo4j.ogm.annotation.Relationship;
 
-import java.io.Serializable;
-import java.math.BigDecimal;
-import java.util.HashSet;
 import java.util.Set;
+import java.util.HashSet;
 
 @Setter
 @Getter
-//@EqualsAndHashCode(callSuper = false)
 @NodeEntity(label = "辅助检查")
-public class PACS extends BaseNode  {
-
-    /*
-    @Property(name = "最大值")
-    private BigDecimal maxval;
-
-    @Property(name = "最小值")
-    private BigDecimal minval;
-
-    @Property(name = "单位")
-    private String unit;
-    */
-
-    @Relationship(type = "辅助检查禁忌性别", direction = Relationship.OUTGOING)
-    private Gender gender;
-
-    @Relationship(type="辅助检查禁忌年龄", direction = Relationship.OUTGOING)
-    private Age age;
-
-    @Relationship(type="辅助检查禁忌临床表现", direction = Relationship.OUTGOING)
-    private Set<ClinicalFinding> clinicalfindings = new HashSet<>();
-
-    @Relationship(type="辅助检查禁忌体征", direction = Relationship.OUTGOING)
-    private Set<Vital> vitals = new HashSet<>();
-
-    @Relationship(type="辅助检查禁忌服用药品", direction = Relationship.OUTGOING)
-    private Set<OralMedicine> oralmeds = new HashSet<>();
-
-    @Relationship(type="辅助检查禁忌过敏药品", direction = Relationship.OUTGOING)
-    private Set<AllergicMed> allergicmeds = new HashSet<>();
-
-    @Relationship(type="辅助检查禁忌手术和操作", direction = Relationship.OUTGOING)
-    private Set<Operation> operations = new HashSet<>();
-
-    @Relationship(type="辅助检查禁忌操作", direction = Relationship.OUTGOING)
-    private Set<Procedure> procedures = new HashSet<>();
-
-    @Relationship(type="辅助检查禁忌实验室检查", direction = Relationship.OUTGOING)
-    private Set<LIS> liss = new HashSet<>();
-
-    @Relationship(type="辅助检查禁忌辅助检查描述", direction = Relationship.OUTGOING)
-    private Set<PACSDescribe> pacs_conflict_pacsdesc = new HashSet<>();
-
-    @Relationship(type="辅助检查禁忌疾病", direction = Relationship.OUTGOING)
-    private Set<Disease> diseases = new HashSet<>();
-
-    @Relationship(type="辅助检查禁忌人群", direction = Relationship.OUTGOING)
-    private Set<Group> groups = new HashSet<>();
-
-
-    @Relationship(type="疾病相关辅助检查", direction = Relationship.INCOMING)
-    private Set<Disease> disease_related_pacs = new HashSet<>();
-
-//    @Relationship(type="药品通用名禁忌辅助检查", direction = Relationship.INCOMING)
-//    private Set<Medicine> medicine_conflict_pacs = new HashSet<>();
-
-    @Relationship(type="实验室检查禁忌辅助检查", direction = Relationship.INCOMING)
-    private Set<LIS> lis_conflict_pacs = new HashSet<>();
-
-    @Relationship(type="医保ICD-10疾病相关辅助检查", direction = Relationship.INCOMING)
-    private Set<Disease> icddis_related_pacs = new HashSet<>();
-
-}
-
-
+public class Pacs extends BaseNode  {
 
 
+	@Relationship(type = "辅助检查禁忌实验室检查", direction = Relationship.OUTGOING)
+	private Set<Lis> liss = new HashSet<>();
 
+}

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

@@ -4,26 +4,25 @@ import com.diagbot.entity.node.base.BaseNode;
 import lombok.Getter;
 import lombok.Setter;
 import org.neo4j.ogm.annotation.NodeEntity;
+import org.neo4j.ogm.annotation.Property;
 import org.neo4j.ogm.annotation.Relationship;
 
-import java.util.HashSet;
 import java.util.Set;
+import java.util.HashSet;
 
 @Setter
 @Getter
-//@EqualsAndHashCode(callSuper = false)
-@NodeEntity(label = "辅助检查描述")
-public class PACSDescribe extends BaseNode  {
-
-    @Relationship(type = "手术和操作禁忌辅助检查描述", direction = Relationship.INCOMING)
-    private Set<Operation> op_conflict_pacsdesc = new HashSet<>();
-
-    @Relationship(type="辅助检查禁忌辅助检查描述", direction = Relationship.INCOMING)
-    private Set<PACS> pacs_conflict_pacsdesc;
-
-}
+@NodeEntity(label = "辅助检查名称描述")
+public class PacsDescribe extends BaseNode  {
 
 
+	@Relationship(type = "医保手术和操作名称禁忌辅助检查名称描述", direction = Relationship.INCOMING)
+	private Set<YiBaoOperationName> yibaooperationnames = new HashSet<>();
 
+	@Relationship(type = "联合项目禁忌辅助检查名称描述", direction = Relationship.INCOMING)
+	private Set<CombiOperation> combioperations = new HashSet<>();
 
+	@Relationship(type = "辅助检查名称禁忌辅助检查名称描述", direction = Relationship.INCOMING)
+	private Set<Pacs> pacss = new HashSet<>();
 
+}

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

@@ -0,0 +1,53 @@
+package com.diagbot.entity.node;
+
+import com.diagbot.entity.node.base.BaseNode;
+import lombok.Getter;
+import lombok.Setter;
+import org.neo4j.ogm.annotation.NodeEntity;
+import org.neo4j.ogm.annotation.Relationship;
+
+import java.util.HashSet;
+import java.util.Set;
+
+@Setter
+@Getter
+@NodeEntity(label = "辅助检查名称")
+public class PacsName extends BaseNode  {
+
+
+	@Relationship(type = "辅助检查名称包含辅助检查子项目名称", direction = Relationship.OUTGOING)
+	private Set<PacsSubName> pacssubnames = new HashSet<>();
+
+	@Relationship(type = "辅助检查名称禁忌性别", direction = Relationship.OUTGOING)
+	private Gender gender;
+
+	@Relationship(type = "辅助检查名称禁忌临床表现", direction = Relationship.OUTGOING)
+	private Set<ClinicalFinding> clinicalfindings = new HashSet<>();
+
+	@Relationship(type = "辅助检查名称禁忌体征", direction = Relationship.OUTGOING)
+	private Set<Vital> vitals = new HashSet<>();
+
+	@Relationship(type = "辅助检查名称禁忌实验室检查", direction = Relationship.OUTGOING)
+	private Set<Lis> lis = new HashSet<>();
+
+	@Relationship(type = "辅助检查名称禁忌辅助检查名称描述", direction = Relationship.OUTGOING)
+	private Set<PacsDescribe> pacsdescribes = new HashSet<>();
+
+	@Relationship(type = "辅助检查名称禁忌禁忌人群", direction = Relationship.OUTGOING)
+	private Set<Group> groups = new HashSet<>();
+
+	@Relationship(type = "辅助检查名称禁忌服用药品", direction = Relationship.OUTGOING)
+	private Set<OralMedicine> oralmedicines = new HashSet<>();
+
+	@Relationship(type = "辅助检查名称禁忌药物过敏原", direction = Relationship.OUTGOING)
+	private Set<MedAllergen> medallergens = new HashSet<>();
+
+	@Relationship(type = "辅助检查名称禁忌疾病", direction = Relationship.OUTGOING)
+	private Set<Disease> diseases = new HashSet<>();
+
+	@Relationship(type = "辅助检查名称禁忌过敏原", direction = Relationship.OUTGOING)
+	private Set<Allergen> allergens = new HashSet<>();
+
+	@Relationship(type = "辅助检查名称禁忌禁忌医疗器械及物品", direction = Relationship.OUTGOING)
+	private Set<ConflictDevice> conflictdevices = new HashSet<>();
+}

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

@@ -1,19 +0,0 @@
-package com.diagbot.entity.node;
-
-import com.diagbot.entity.node.base.BaseNode;
-import lombok.Getter;
-import lombok.Setter;
-import org.neo4j.ogm.annotation.NodeEntity;
-import org.neo4j.ogm.annotation.Relationship;
-
-import java.util.Set;
-
-@Setter
-@Getter
-//@EqualsAndHashCode(callSuper = false)
-@NodeEntity(label = "病原体")
-public class Pathogen extends BaseNode  {
-
-    @Relationship(type="疾病相关病原体", direction = Relationship.INCOMING)
-    private Set<Disease> diseases;
-}

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

@@ -1,30 +0,0 @@
-package com.diagbot.entity.node;
-
-import lombok.Data;
-import com.diagbot.entity.node.base.BaseNode;
-import lombok.EqualsAndHashCode;
-import lombok.Getter;
-import lombok.Setter;
-import org.neo4j.ogm.annotation.Labels;
-import org.neo4j.ogm.annotation.NodeEntity;
-import org.neo4j.ogm.annotation.Relationship;
-
-import java.io.Serializable;
-import java.util.Set;
-
-@Setter
-@Getter
-//@EqualsAndHashCode(callSuper = false)
-@NodeEntity(label = "操作")
-public class Procedure extends BaseNode  {
-
-    @Relationship(type="药品通用名禁忌操作", direction = Relationship.INCOMING)
-    private Set<Medicine> medicines;
-
-    @Relationship(type="辅助检查禁忌操作", direction = Relationship.INCOMING)
-    private Set<PACS> pacs;
-
-    @Relationship(type="实验室检查禁忌操作", direction = Relationship.INCOMING)
-    private Set<LIS> lis;
-
-}

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

@@ -1,19 +0,0 @@
-package com.diagbot.entity.node;
-
-import com.diagbot.entity.node.base.BaseNode;
-import lombok.Getter;
-import lombok.Setter;
-import org.neo4j.ogm.annotation.NodeEntity;
-import org.neo4j.ogm.annotation.Relationship;
-
-import java.util.Set;
-
-@Setter
-@Getter
-//@EqualsAndHashCode(callSuper = false)
-@NodeEntity(label = "发病情况")
-public class Situation extends BaseNode  {
-
-    @Relationship(type="疾病相关发病情况", direction = Relationship.INCOMING)
-    private Set<Disease> diseases;
-}

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

@@ -1,19 +0,0 @@
-package com.diagbot.entity.node;
-
-import com.diagbot.entity.node.base.BaseNode;
-import lombok.Getter;
-import lombok.Setter;
-import org.neo4j.ogm.annotation.NodeEntity;
-import org.neo4j.ogm.annotation.Relationship;
-
-import java.util.Set;
-
-@Setter
-@Getter
-//@EqualsAndHashCode(callSuper = false)
-@NodeEntity(label = "症状")
-public class Symptom extends BaseNode  {
-
-    @Relationship(type="疾病相关症状", direction = Relationship.INCOMING)
-    private Set<Disease> diseases;
-}

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

@@ -1,19 +0,0 @@
-package com.diagbot.entity.node;
-
-import com.diagbot.entity.node.base.BaseNode;
-import lombok.Getter;
-import lombok.Setter;
-import org.neo4j.ogm.annotation.NodeEntity;
-import org.neo4j.ogm.annotation.Relationship;
-
-import java.util.Set;
-
-@Setter
-@Getter
-//@EqualsAndHashCode(callSuper = false)
-@NodeEntity(label = "治疗周期")
-public class TreatCycle extends BaseNode  {
-
-    @Relationship(type="疾病相关治疗周期", direction = Relationship.INCOMING)
-    private Set<Disease> diseases;
-}

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

@@ -1,19 +0,0 @@
-package com.diagbot.entity.node;
-
-import com.diagbot.entity.node.base.BaseNode;
-import lombok.Getter;
-import lombok.Setter;
-import org.neo4j.ogm.annotation.NodeEntity;
-import org.neo4j.ogm.annotation.Relationship;
-
-import java.util.Set;
-
-@Setter
-@Getter
-//@EqualsAndHashCode(callSuper = false)
-@NodeEntity(label = "治疗")
-public class Treatment extends BaseNode  {
-
-    @Relationship(type="疾病相关治疗", direction = Relationship.INCOMING)
-    private Set<Disease> diseases;
-}

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

@@ -1,44 +0,0 @@
-package com.diagbot.entity.node;
-
-import com.diagbot.entity.node.base.BaseNode;
-import lombok.Getter;
-import lombok.Setter;
-import org.neo4j.ogm.annotation.NodeEntity;
-import org.neo4j.ogm.annotation.Property;
-import org.neo4j.ogm.annotation.Relationship;
-
-import java.math.BigDecimal;
-import java.util.HashSet;
-import java.util.Set;
-
-@Setter
-@Getter
-//@EqualsAndHashCode(callSuper = false)
-@NodeEntity(label = "体征")
-public class Vital extends BaseNode  {
-
-    @Property(name = "最大值")
-    private Double maxval;
-
-    @Property(name = "最小值")
-    private Double minval;
-
-    @Property(name = "单位")
-    private String unit;
-
-    @Property(name = "范围")
-    private Integer range;
-
-    @Relationship(type="疾病相关体征", direction = Relationship.INCOMING)
-    private Set<Disease> diseases;
-
-    @Relationship(type="实验室检查禁忌体征", direction = Relationship.INCOMING)
-    private Set<LIS> conflict_lis = new HashSet<>();
-
-    @Relationship(type="辅助检查禁忌体征", direction = Relationship.INCOMING)
-    private Set<PACS> conflict_pacs = new HashSet<>();
-
-//    @Relationship(type = "药品通用名禁忌体征", direction = Relationship.INCOMING)
-//    private Set<Medicine> conflict_mediciness = new HashSet<>();
-
-}

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

@@ -1,15 +1,11 @@
 package com.diagbot.entity.node.base;
 
 
-import lombok.Data;
-import lombok.EqualsAndHashCode;
 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;
 
 /**

src/main/java/com/diagbot/facade/BillFacade.java

@@ -7,7 +7,6 @@ import com.diagbot.dto.BillMsg;
 import com.diagbot.dto.BillNeoDTO;
 import com.diagbot.dto.IndicationDTO;
 import com.diagbot.dto.WordCrfDTO;
-import com.diagbot.entity.node.Operation;
 import com.diagbot.process.BillProcess;
 import com.diagbot.util.ListUtil;
 import com.diagbot.util.StringUtil;

src/main/java/com/diagbot/facade/EntityFacade.java

@@ -26,10 +26,10 @@ public class EntityFacade {
     BaseNodeRepository baseNodeRepository;
 
     @Autowired
-    LisRepository lisRepository;
+    LisNameRepository lisRepository;
 
     @Autowired
-    LisPackRepository lisPackRepository;
+    LisSetRepository lisSetRepository;
 
 
     public List<String> getLabels() {
@@ -60,17 +60,18 @@ public class EntityFacade {
             String clsname = map.get(label);
 
             switch (clsname) {
-                case "LIS":
-                    LisNode lisNode = new LisNode();
+                case "LisName":
+                    LisNameNode lisNode = new LisNameNode();
                     keys = getKeys(lisRepository.getKeys(), "name");
                     neoEntityDTO = lisNode.updateEntity(name, props, keys, lisRepository);
                     break;
-                case "LISPack":
-                    LisPackNode lisPackNode = new LisPackNode();
-                    keys = getKeys(lisPackRepository.getKeys(), "name");
-                    neoEntityDTO = lisPackNode.updateEntity(name, props, keys, lisPackRepository);
+                case "LisSet":
+                    LisSetNode lisPackNode = new LisSetNode();
+                    keys = getKeys(lisSetRepository.getKeys(), "name");
+                    neoEntityDTO = lisPackNode.updateEntity(name, props, keys, lisSetRepository);
                     break;
             }
+
             neoEntityDTO.setLabels(labels);
         }
 

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

@@ -0,0 +1,75 @@
+package com.diagbot.repository;
+
+import com.diagbot.dto.CombiOpBillNeoDTO;
+import com.diagbot.entity.node.*;
+import com.diagbot.util.NeoUtil;
+
+import java.util.*;
+
+public class CombiOperationNode {
+
+	public CombiOpBillNeoDTO CombiOptoCombiOpDTO(CombiOperation combiOp) {
+
+		CombiOpBillNeoDTO combiOpBillNeoDTO = new CombiOpBillNeoDTO();
+		NodeInfo nodeInfo;
+
+
+		Gender gender = combiOp.getGender();
+		if (null!=gender) {
+			nodeInfo = new NodeInfo();
+			nodeInfo.setName(gender.getName());
+			nodeInfo.setTypeval("性别");
+			combiOpBillNeoDTO.setGender(NeoUtil.updateNodeInfo(nodeInfo));
+		}
+
+
+		Set<Group> groups = combiOp.getGroups();
+		for (Group group : groups) {
+			nodeInfo = new NodeInfo();
+			nodeInfo.setName(group.getName());
+
+			combiOpBillNeoDTO.getGroup().add(NeoUtil.updateNodeInfo(nodeInfo));
+		}
+
+
+		Set<Lis> lislist = combiOp.getLiss();
+		for (Lis lis : lislist) {
+			nodeInfo = new NodeInfo();
+			nodeInfo.setName(lis.getName());
+
+			combiOpBillNeoDTO.getGroup().add(NeoUtil.updateNodeInfo(nodeInfo));
+		}
+
+
+		Set<PacsDescribe> pacsDescribes = combiOp.getPacsdescs();
+		for (PacsDescribe pacsdesc : pacsDescribes) {
+			nodeInfo = new NodeInfo();
+			nodeInfo.setName(pacsdesc.getName());
+
+			combiOpBillNeoDTO.getGroup().add(NeoUtil.updateNodeInfo(nodeInfo));
+		}
+
+
+		Set<Disease> diseases = combiOp.getDiseases();
+		for (Disease dis : diseases) {
+			nodeInfo = new NodeInfo();
+			nodeInfo.setName(dis.getName());
+
+			combiOpBillNeoDTO.getGroup().add(NeoUtil.updateNodeInfo(nodeInfo));
+		}
+
+
+		Set<MedAllergen> medAllergens = combiOp.getMedallergens();
+		for (MedAllergen medallergen : medAllergens) {
+			nodeInfo = new NodeInfo();
+			nodeInfo.setName(medallergen.getName());
+
+			combiOpBillNeoDTO.getGroup().add(NeoUtil.updateNodeInfo(nodeInfo));
+		}
+
+
+
+		return combiOpBillNeoDTO;
+	}
+}
+

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

@@ -0,0 +1,15 @@
+package com.diagbot.repository;
+
+import com.diagbot.entity.node.CombiOperation;
+import org.springframework.data.neo4j.repository.Neo4jRepository;
+
+import java.util.List;
+
+
+public interface CombiOperationRepository extends Neo4jRepository<CombiOperation, Long> {
+
+    List<CombiOperation> findByNameLike(String name);
+
+    List<CombiOperation> findByNameIs(String name);
+}
+

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

@@ -0,0 +1,75 @@
+package com.diagbot.repository;
+
+public class Constants {
+    final static String age = "年龄";
+    final static String allergicmed = "过敏药品";
+//    final static String clinicalfinding = "临床表现";
+    final static String complication = "并发症";
+    final static String conflictmed = "配伍";
+//    final static String lis = "实验室检查";
+//    final static String gender = "性别";
+//    final static String oralmed = "服用药品";
+    final static String operation = "手术和操作";
+//    final static String pacs = "辅助检查";
+//    final static String disease = "疾病";
+//    final static String medicine = "药品通用名";
+    final static String symptom = "症状";
+//    final static String vital = "体征";
+    final static String lispack = "实验室检查套餐";
+//    final static String group = "人群";
+//    final static String pacsdesc = "辅助检查描述";
+    final static String icddisease = "医保ICD_10疾病";
+    final static String medcodename = "药品代码通用名";
+    final static String medanatomy = "药品解剖学类别";
+    final static String liscritical = "实验室检查危急值";
+
+//    final static String "药品代码通用名";
+    final static String medcode = "药品代码";
+    final static String medjiepou = "药品解剖学类别";
+    final static String medzhiliao = "药品治疗学类别";
+    final static String medyaoli = "药品药理学类别";
+    final static String medhuaxue = "药品化学物质类别";
+    final static String medicine = "药品通用名称";
+    final static String medregname = "药品注册名称";
+    final static String medcate = "药品类别";
+    final static String medprodname = "药品商品名称";
+    final static String medyibaocate = "药品医保类别";
+    final static String pacs = "辅助检查";
+    final static String herbdeptcate = "中成药科室类别";
+    final static String herbzhiliaocate = "中成药治疗学类别";
+    final static String herbfangjiclass = "中成药方剂学大类";
+    final static String herbfangjicate = "中成药方剂学类别";
+    final static String regname = "注册名称";
+    final static String herbyibaocate = "中成药医保类别";
+    final static String prodname = "商品名称";
+    final static String lisname = "实验室检查名称";
+    final static String lisfirstclass = "实验室检查一级分类";
+    final static String lissecondclass = "实验室检查二级分类";
+    final static String lisalias = "实验室检查别名";
+    final static String lisset = "实验室检查套餐名";
+    final static String yibaodisease = "医保疾病名称";
+    final static String yibaoicd10code = "医保ICD_10代码";
+    final static String guolindisease = "国临疾病名称";
+    final static String guolinicd10code = "国临ICD_10代码";
+    final static String yibaoopname = "医保手术和操作名称";
+    final static String yibaoicd9code = "医保ICD_9_CM3代码";
+    final static String guolinopname = "国临手术和操作名称";
+    final static String guolinicd9code = "国临ICD_9_CM3代码";
+    final static String pacsname = "辅助检查名称";
+    final static String gender = "性别";
+    final static String group = "禁忌人群";
+    final static String lis = "实验室检查";
+    final static String disease = "疾病";
+    final static String oralmed = "服用药品";
+    final static String medallergen = "药物过敏原";
+    final static String clinicalfinding = "临床表现";
+    final static String vital = "体征";
+    final static String pacsnamesubname = "辅助检查名称子项目名称";
+    final static String pacssubname = "辅助检查子项目名称";
+    final static String liscode = "实验室检查代码";
+    final static String conflictdevice = "禁忌医疗器械及物品";
+    final static String pacsdesc = "辅助检查名称描述";
+    final static String combioperation = "联合项目";
+    final static String allergen = "过敏原";
+    final static String yibaooperation = "医保手术和操作";
+}

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

@@ -1,40 +0,0 @@
-package com.diagbot.repository;
-
-import com.diagbot.dto.BillNeoDTO;
-import com.diagbot.dto.DeptInfoDTO;
-import com.diagbot.dto.LisBillNeoDTO;
-import com.diagbot.dto.NodeNeoDTO;
-import com.diagbot.entity.node.*;
-import com.diagbot.util.NeoUtil;
-
-import java.math.BigDecimal;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-
-public class DeptNode {
-
-	/**
-	 * 获取科室名称列表
-	 */
-	public List<String> getDeptNameList(String name, DeptRepository deptRepository) {
-		String nodename;
-
-		List<String> deptlist = new ArrayList<>();
-
-		List<Dept> depts = deptRepository.findByNameLike("*"+name+"*");
-
-		for (Dept dept : depts) {
-			nodename = dept.getName();
-			if (!deptlist.contains(nodename)) {
-				deptlist.add(nodename);
-			}
-		}
-
-
-		return deptlist;
-	}
-
-}
-

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

@@ -1,15 +0,0 @@
-package com.diagbot.repository;
-
-import com.diagbot.entity.node.Dept;
-import org.springframework.data.neo4j.repository.Neo4jRepository;
-
-import java.util.List;
-
-
-public interface DeptRepository extends Neo4jRepository<Dept, Long> {
-
-    Dept findByNameIs(String name);
-
-    List<Dept> findByNameLike(String name);
-}
-

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

@@ -1,11 +0,0 @@
-package com.diagbot.repository;
-
-import com.diagbot.entity.node.Disease;
-import org.springframework.data.neo4j.repository.Neo4jRepository;
-
-
-public interface DiseaseRepository extends Neo4jRepository<Disease, Long> {
-
-    Disease findByNameIs(String name);
-}
-

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

@@ -1,243 +0,0 @@
-package com.diagbot.repository;
-
-import com.diagbot.dto.NeoPushDTO;
-import com.diagbot.dto.PushBaseDTO;
-import com.diagbot.dto.PushDTO;
-import com.diagbot.entity.node.*;
-import com.diagbot.util.NeoUtil;
-import com.diagbot.vo.NeoPushVO;
-
-import java.util.*;
-
-public class ICDDiseaseNode {
-
-	public NeoPushDTO ICDDiseasetoPushDTO(ICDDisease disease, NeoPushVO neoPushVO) {
-
-		NeoPushDTO pushDTO = null;
-		PushBaseDTO pushBaseDTO;
-		List<PushBaseDTO> pushBaseDTOS;
-
-		int gender = neoPushVO.getSex();
-		int age = neoPushVO.getAge();
-
-		if (matchBasic(disease, gender, age)) {
-
-			pushDTO = new NeoPushDTO();
-
-			pushBaseDTO = new PushBaseDTO();
-			pushBaseDTO.setName(disease.getName());
-			pushDTO.setDisease(pushBaseDTO);
-
-		/*
-		CureRate curerate = disease.getCurerate();
-		if (null != curerate) {
-			NeoUtil.updateNodeInfo(curerate.getName(), null, null, null);
-		}
-
-		TreatCycle treatcycle = disease.getTreatcycle();
-		if (null != treatcycle) {
-			NeoUtil.updateNodeInfo(treatcycle.getName(), null, null, null);
-		}
-
-		Set<Infection> infections = disease.getInfections();
-		for (Infection infection : infections) {
-			NeoUtil.updateNodeInfo(infection.getName(), null, null, null);
-		}
-
-		Set<Group> groups = disease.getGroups();
-		for (Group group : groups) {
-			NeoUtil.updateNodeInfo(group.getName(), null, null, null);
-		}
-
-		Set<Alias> aliass = disease.getAlias();
-		for (Alias alias : aliass) {
-			NeoUtil.updateNodeInfo(alias.getName(), null, null, null);
-		}
-
-
-		Set<Vital> vitals = disease.getVitals();
-		for (Vital vital : vitals) {
-			String name = vital.getName();
-			pushDTO.getVital().add(NeoUtil.updatePushInfo(name));
-		}
-
-		/*
-		Set<Dept> depts = disease.getDepts();
-		for (Dept dept : depts) {
-			NeoUtil.updateNodeInfo(dept.getName(), null, null, null);
-		}
-
-
-		Set<Symptom> symptoms = disease.getSymptoms();
-		for (Symptom symptom : symptoms) {
-            pushDTO.getSymptom().add(NeoUtil.updatePushInfo(symptom.getName()));
-		}
-
-		/*
-		Set<Situation> situations = disease.getSituations();
-		for (Situation situation : situations) {
-			NeoUtil.updateNodeInfo(situation.getName(), null, null, null);
-		}
-
-		Code code = disease.getCode();
-		if (null != code) {
-			NeoUtil.updateNodeInfo(code.getName(), null, null, null);
-		}
-
-		Set<Dept> stddepts = disease.getDepts();
-		for (Dept stddept : stddepts) {
-			NeoUtil.updateNodeInfo(stddept.getName(), null, null, null);
-		}
-
-
-		Set<Complication> complications = disease.getComplications();
-		for (Complication complication : complications) {
-			pushDTO.getComplications().add(NeoUtil.updatePushInfo(complication.getName()));
-		}
-		*/
-
-			Set<PACS> pacss = disease.getPacs();
-			for (PACS pacs : pacss) {
-				String name = pacs.getName();
-				pushDTO.getPacs().add(NeoUtil.updatePushInfo(name));
-			}
-
-		/*
-		Set<Medicine> medicines = disease.getMedicines();
-		for (Medicine medicine : medicines) {
-			pushDTO.getMedicines().add(NeoUtil.updatePushInfo(medicine.getName()));
-		}
-
-		/*
-		Set<Cause> causes = disease.getCauses();
-		for (Cause cause : causes) {
-			NeoUtil.updateNodeInfo(cause.getName(), null, null, null);
-		}
-
-
-		Set<Disease> diff_diseases = disease.getDiff_diseases();
-		List<PushBaseDTO> pushBaseDTOs = new ArrayList<>();
-		for (Disease diff_disease : diff_diseases) {
-			pushBaseDTOs.add(NeoUtil.updatePushInfo(diff_disease.getName()));
-		}
-		Map<String, List<PushBaseDTO>> dis = new HashMap<>();
-		dis.put("鉴别诊断", pushBaseDTOs);
-		pushDTO.setDis(dis);
-
-		Set<Operation> operations = disease.getOperations();
-		for (Operation operation : operations) {
-			pushDTO.getOperations().add(NeoUtil.updatePushInfo(operation.getName()));
-		}
-
-		/*
-		Set<Pathogen> pathogens = disease.getPathogens();
-		for (Pathogen pathogen : pathogens) {
-			NeoUtil.updateNodeInfo(pathogen.getName(), null, null, null);
-		}
-
-		Set<Heredity> hereditys = disease.getHereditys();
-		for (Heredity heredity : hereditys) {
-			NeoUtil.updateNodeInfo(heredity.getName(), null, null, null);
-		}
-
-		Set<Treatment> treatments = disease.getTreatments();
-		for (Treatment treatment : treatments) {
-			NeoUtil.updateNodeInfo(treatment.getName(), null, null, null);
-		}
-
-		Set<DiseaseType> diseasetypes = disease.getDiseasetypes();
-		for (DiseaseType diseasetype : diseasetypes) {
-			NeoUtil.updateNodeInfo(diseasetype.getName(), null, null, null);
-		}
-
-		Set<Complication> localcompls = disease.getLocalcompls();
-		for (Complication localcompl : localcompls) {
-			NeoUtil.updateNodeInfo(localcompl.getName(), null, null, null);
-		}
-
-		Set<Complication> generalcompls = disease.getGeneralcompls();
-		for (Complication generalcompl : generalcompls) {
-			NeoUtil.updateNodeInfo(generalcompl.getName(), null, null, null);
-		}
-		*/
-
-			Set<LIS> liss = disease.getLiss_dis();
-			for (LIS lis : liss) {
-				pushDTO.getLis().add(NeoUtil.updatePushInfo(lis.getName()));
-			}
-
-		/*
-		Set<PACS> pacs_disease= disease.getPacs_disease();
-		for (PACS pacs : pacs_disease) {
-			String name = pacs.getName();
-			String min = pacs.getMinval();
-			String max = pacs.getMaxval();
-			String unit = pacs.getUnit();
-			NeoUtil.updateNodeInfo(name, min, max, unit);
-		}
-
-		Medicine_Code medicine_code = disease.getMedicine_code();
-		if (null != medicine_code) {
-			NeoUtil.updateNodeInfo(medicine_code.getName(), null, null, null);
-		}
-		*/
-		}
-
-		return pushDTO;
-	}
-
-
-		private boolean matchBasic(ICDDisease disease, int gender_code, int age) {
-			boolean match = true;
-
-			String gender = null;
-
-			if (gender_code==1) {
-				gender = "男";
-			}
-			else if (gender_code==2) {
-				gender = "女";
-			}
-
-//		if (null!=disease.getGender() && gender!=null) {
-//			if (!disease.getGender().getName().contains(gender)) {
-//				match = false;
-//			}
-//		}
-//
-//		if (null!=disease.getAge()) {
-//			int min = disease.getAge().getMinval();
-//			int max = disease.getAge().getMaxval();
-//			if (age < min || age > max) {
-//				match = false;
-//			}
-//		}
-
-			return match;
-		}
-
-
-
-    /**
-	 * 获取疾病名称列表
-	 */
-	public List<String> getDiseaseNameList(String name, ICDDiseaseRepository diseaseRepository) {
-		String icdname;
-
-		List<String> dislist = new ArrayList<>();
-
-		List<ICDDisease> diseases = diseaseRepository.findByNameLike("*"+name+"*");
-
-		for (ICDDisease dis : diseases) {
-		    icdname = dis.getName();
-            if (!dislist.contains(icdname)) {
-                dislist.add(icdname);
-            }
-        }
-
-
-		return dislist;
-	}
-
-}
-

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

@@ -1,15 +0,0 @@
-package com.diagbot.repository;
-
-import com.diagbot.entity.node.ICDDisease;
-import org.springframework.data.neo4j.repository.Neo4jRepository;
-
-import java.util.List;
-
-
-public interface ICDDiseaseRepository extends Neo4jRepository<ICDDisease, Long> {
-
-    List<ICDDisease> findByNameLike(String name);
-
-    List<ICDDisease> findByNameIs(String name);
-}
-

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

@@ -1,19 +1,18 @@
 package com.diagbot.repository;
 
-import com.diagbot.biz.push.entity.Lis;
 import com.diagbot.dto.*;
 import com.diagbot.entity.node.*;
 import com.diagbot.util.NeoUtil;
 import com.diagbot.util.StringUtil;
 import com.diagbot.vo.CriticalNeoVO;
-import com.diagbot.vo.NeoEntityVO;
+import com.diagbot.biz.push.entity.Lis;
 
 import java.math.BigDecimal;
 import java.util.*;
 
-public class LisNode {
+public class LisNameNode {
 
-	public LisBillNeoDTO ListoLISDTO(LIS lis) {
+	public LisBillNeoDTO ListoLISDTO(LisName lis) {
 
 		LisBillNeoDTO lisBillNeoDTO = new LisBillNeoDTO();
 		NodeInfo nodeInfo;
@@ -26,7 +25,7 @@ public class LisNode {
 			lisBillNeoDTO.setGender(NeoUtil.updateNodeInfo(nodeInfo));
 		}
 
-
+/*
 		Age age = lis.getAge();
 		if (null!=age) {
 			NodeNeoDTO ageNeoDTO = new NodeNeoDTO();
@@ -107,7 +106,7 @@ public class LisNode {
 
 			lisBillNeoDTO.getDisease().add(NeoUtil.updateNodeInfo(nodeInfo));
 		}
-
+*/
 		Set<Group> groups = lis.getGroups();
 		for (Group group : groups) {
 			nodeInfo = new NodeInfo();
@@ -124,13 +123,13 @@ public class LisNode {
 	/**
 	 * 处理化验开单合理性
 	 */
-	public List<BillNeoDTO> getLisDetailBill(Map<String, String> listerm, LisRepository lisRepository) {
+	public List<BillNeoDTO> getLisDetailBill(Map<String, String> listerm, LisNameRepository lisRepository) {
 		List<BillNeoDTO> billNeoDTOs = new ArrayList<>();
 		BillNeoDTO billNeoDTO;
 
 		LisBillNeoDTO lisBillNeoDTO;
 
-		LIS lis;
+		LisName lis;
 		String lisname;
 
 		for (String term : listerm.keySet()) {
@@ -160,15 +159,15 @@ public class LisNode {
 	/**
 	 * 获取化验细项名称列表
 	 */
-	public List<LisDetailDTO> getLisDetailList(String name, LisRepository lisRepository) {
+	public List<LisDetailDTO> getLisDetailList(String name, LisNameRepository lisRepository) {
 		String nodename;
 
 		List<LisDetailDTO> lislist = new ArrayList<>();
 		LisDetailDTO lisDetailDTO;
 
-		List<LIS> lislt = lisRepository.findByNameLike("*"+name+"*");
+		List<LisName> lislt = lisRepository.findByNameLike("*"+name+"*");
 
-		for (LIS lis: lislt) {
+		for (LisName lis: lislt) {
 			lisDetailDTO = new LisDetailDTO();
 			nodename = lis.getName();
 			lisDetailDTO.setUniqueName(nodename);
@@ -185,13 +184,13 @@ public class LisNode {
 				lisDetailDTO.setUnits(lis.getUnit());
 			}
 
-			if (lis.getLisPacks_related_lis().size()>0) {
-				List<LISPack> lispacklist = new ArrayList<>(lis.getLisPacks_related_lis());
-				for (LISPack lisPack : lispacklist) {
+			if (lis.getLissets().size()>0) {
+				List<LisSet> lissetlist = new ArrayList<>(lis.getLissets());
+				for (LisSet lisset : lissetlist) {
 					lisDetailDTO = new LisDetailDTO();
 					nodename = lis.getName();
 					lisDetailDTO.setUniqueName(nodename);
-					lisDetailDTO.setName(lisPack.getName());
+					lisDetailDTO.setName(lisset.getName());
 					lislist.add(lisDetailDTO);
 				}
 			}
@@ -210,7 +209,7 @@ public class LisNode {
 	/**
 	 * 获取化验细项危急值
 	 */
-	public List<CriticalNeoDTO> getLisCritialList(CriticalNeoVO criticalNeoVO, LisRepository lisRepository) {
+	public List<CriticalNeoDTO> getLisCritialList(CriticalNeoVO criticalNeoVO, LisNameRepository lisRepository) {
 		String nodename;
 		Integer agemin, agemax;
 
@@ -227,15 +226,15 @@ public class LisNode {
 				String name = lisvo.getDetailName();
 
 				if (StringUtil.isNotBlank(name)) {
-					List<LIS> lislt = lisRepository.findByNameIs(name);
+					List<LisName> lislt = lisRepository.findByNameIs(name);
 
-					for (LIS lis : lislt) {
+					for (LisName lis : lislt) {
 						criticalNeoDTO = new CriticalNeoDTO();
 						nodename = lis.getName();
 						criticalNeoDTO.setName(nodename);
 						criticalNeoDTO.setStandname(nodename);
 						criticalNeoDTO.setType("化验");
-
+/*
 						List<LISCritical> lisCriticals = new ArrayList<>(lis.getLiscritial());
 
 						for (LISCritical lisCritical : lisCriticals) {
@@ -264,6 +263,7 @@ public class LisNode {
 								lislist.add(criticalNeoDTO);
 							}
 						}
+*/
 					}
 				}
 			}
@@ -279,15 +279,15 @@ public class LisNode {
 	/**
 	 * 更新实体属性信息
 	 */
-	public NeoEntityDTO updateEntity(String name, Map<String, String> props, List<String> keys, LisRepository lisRepository) {
+	public NeoEntityDTO updateEntity(String name, Map<String, String> props, List<String> keys, LisNameRepository lisRepository) {
 		NeoEntityDTO neoEntityDTO = new NeoEntityDTO();
 		neoEntityDTO.setName(name);
 
 		try {
-			List<LIS> lisres = lisRepository.findByNameIs(name);
+			List<LisName> lisres = lisRepository.findByNameIs(name);
 
 			if (lisres!= null && lisres.size()>0) {
-				LIS lis = lisres.get(0);
+				LisName lis = lisres.get(0);
 
 				for (String key : props.keySet()) {
 					switch (key) {
@@ -316,7 +316,7 @@ public class LisNode {
 	}
 
 
-	private NeoEntityDTO fillNeoDTO(LIS lis, List<String> keys) {
+	private NeoEntityDTO fillNeoDTO(LisName lis, List<String> keys) {
 		NeoEntityDTO neoEntityDTO = new NeoEntityDTO();
 		Map<String, String> props = new HashMap<>();
 		String val;

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

@@ -1,17 +1,17 @@
 package com.diagbot.repository;
 
-import com.diagbot.entity.node.LIS;
+import com.diagbot.entity.node.LisName;
 import org.springframework.data.neo4j.annotation.Query;
 import org.springframework.data.neo4j.repository.Neo4jRepository;
 
 import java.util.List;
 
 
-public interface LisRepository extends Neo4jRepository<LIS, Long> {
+public interface LisNameRepository extends Neo4jRepository<LisName, Long> {
 
-    List<LIS> findByNameIs(String name);
+    List<LisName> findByNameIs(String name);
 
-    List<LIS> findByNameLike(String name);
+    List<LisName> findByNameLike(String name);
 
     @Query("MATCH (n:实验室检查) RETURN DISTINCT(KEYS(n))")
     List<List<String>> getKeys();

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

@@ -7,18 +7,17 @@ import com.diagbot.dto.NodeNeoDTO;
 import com.diagbot.entity.node.*;
 import com.diagbot.util.NeoUtil;
 
-import javax.xml.soap.Node;
 import java.math.BigDecimal;
 import java.util.*;
 
-public class LisPackNode {
+public class LisSetNode {
 
-	public LisBillNeoDTO LisPacktoLISDTO(LISPack lispack) {
+	public LisBillNeoDTO LisPacktoLISDTO(LisSet lisset) {
 
 		LisBillNeoDTO lisBillNeoDTO = new LisBillNeoDTO();
 		NodeInfo nodeInfo;
 
-		Gender gender = lispack.getGender();
+		Gender gender = lisset.getGender();
 		if (null!=gender) {
 			nodeInfo = new NodeInfo();
 			nodeInfo.setName(gender.getName());
@@ -26,7 +25,7 @@ public class LisPackNode {
 			lisBillNeoDTO.setGender(NeoUtil.updateNodeInfo(nodeInfo));
 		}
 
-
+/*
 		Age age = lispack.getAge();
 		if (null!=age) {
 			NodeNeoDTO ageNeoDTO = new NodeNeoDTO();
@@ -97,7 +96,7 @@ public class LisPackNode {
 			nodeInfo.setName(group.getName());
 			lisBillNeoDTO.getGroup().add(NeoUtil.updateNodeInfo(nodeInfo));
 		}
-
+*/
 
 		return lisBillNeoDTO;
 	}
@@ -106,27 +105,27 @@ public class LisPackNode {
 	/**
 	 * 处理化验套餐开单合理性
 	 */
-	public List<BillNeoDTO> getLisBill(Map<String, String> lispackterm, LisPackRepository lisPackRepository) {
+	public List<BillNeoDTO> getLisBill(Map<String, String> lispackterm, LisSetRepository lisSetRepository) {
 		List<BillNeoDTO> billNeoDTOs = new ArrayList<>();
 		BillNeoDTO billNeoDTO;
 
 		LisBillNeoDTO lisBillNeoDTO;
 
-		List<LISPack> lispacks;
-		String lispackname;
+		List<LisSet> lisSetlist;
+		String lissetname;
 
 		for (String term : lispackterm.keySet()) {
 			billNeoDTO = new BillNeoDTO();
-			lispackname = lispackterm.get(term);
+			lissetname = lispackterm.get(term);
 			billNeoDTO.setName(term);
-			billNeoDTO.setStandname(lispackname);
+			billNeoDTO.setStandname(lissetname);
 
 			lisBillNeoDTO = new LisBillNeoDTO();
 
-			lispacks = lisPackRepository.findByNameIs(lispackname);
+			lisSetlist = lisSetRepository.findByNameIs(lissetname);
 
-			if (lispacks != null && lispacks.size()>0) {
-				lisBillNeoDTO = LisPacktoLISDTO(lispacks.get(0));
+			if (lisSetlist != null && lisSetlist.size()>0) {
+				lisBillNeoDTO = LisPacktoLISDTO(lisSetlist.get(0));
 			}
 
 			billNeoDTO.setLisBillNeoDTO(lisBillNeoDTO);
@@ -142,15 +141,15 @@ public class LisPackNode {
 	/**
 	 * 获取化验套餐名称列表
 	 */
-	public List<String> getLISPackNameList(String name, LisPackRepository lisPackRepository) {
+	public List<String> getLISPackNameList(String name, LisSetRepository lisPackRepository) {
 		String nodename;
 
 		List<String> lispacklist = new ArrayList<>();
 
-		List<LISPack> lisPacks = lisPackRepository.findByNameLike("*"+name+"*");
+		List<LisSet> lisSetlist = lisPackRepository.findByNameLike("*"+name+"*");
 
-		for (LISPack lisPack : lisPacks) {
-			nodename = lisPack.getName();
+		for (LisSet lisSet : lisSetlist) {
+			nodename = lisSet.getName();
 			if (!lispacklist.contains(nodename)) {
 				lispacklist.add(nodename);
 			}
@@ -165,33 +164,33 @@ public class LisPackNode {
 	/**
 	 * 更新实体属性信息
 	 */
-	public NeoEntityDTO updateEntity(String name, Map<String, String> props, List<String> keys, LisPackRepository lisPackRepository) {
+	public NeoEntityDTO updateEntity(String name, Map<String, String> props, List<String> keys, LisSetRepository lisPackRepository) {
 		NeoEntityDTO neoEntityDTO = new NeoEntityDTO();
 		neoEntityDTO.setName(name);
 
 		try {
-			List<LISPack> lispackres = lisPackRepository.findByNameIs(name);
+			List<LisSet> lisSetres = lisPackRepository.findByNameIs(name);
 
-			if (lispackres!= null && lispackres.size()>0) {
-				LISPack lispack = lispackres.get(0);
+			if (lisSetres!= null && lisSetres.size()>0) {
+				LisSet lisSet = lisSetres.get(0);
 
 				for (String key : props.keySet()) {
 					switch (key) {
 						case "最大值":
-							lispack.setMaxval(Double.parseDouble(props.get(key)));
+							lisSet.setMaxval(Double.parseDouble(props.get(key)));
 							break;
 						case "最小值":
-							lispack.setMinval(Double.parseDouble(props.get(key)));
+							lisSet.setMinval(Double.parseDouble(props.get(key)));
 							break;
 						case "单位":
-							lispack.setUnit(props.get(key));
+							lisSet.setUnit(props.get(key));
 							break;
 					}
 				}
 
-				lispack = lisPackRepository.save(lispack);
+				lisSet = lisPackRepository.save(lisSet);
 
-				neoEntityDTO = fillNeoDTO(lispack, keys);
+				neoEntityDTO = fillNeoDTO(lisSet, keys);
 			}
 		}
 		catch (Exception ex) {
@@ -202,22 +201,22 @@ public class LisPackNode {
 	}
 
 
-	private NeoEntityDTO fillNeoDTO(LISPack lisPack, List<String> keys) {
+	private NeoEntityDTO fillNeoDTO(LisSet lisSet, List<String> keys) {
 		NeoEntityDTO neoEntityDTO = new NeoEntityDTO();
 		Map<String, String> props = new HashMap<>();
 		String val = "";
 
-		neoEntityDTO.setName(lisPack.getName());
+		neoEntityDTO.setName(lisSet.getName());
 		for (String key:keys) {
 			switch(key) {
 				case "最大值":
-					val = String.format("%.2f",lisPack.getMaxval());
+					val = String.format("%.2f",lisSet.getMaxval());
 					break;
 				case "最小值":
-					val = String.format("%.2f", lisPack.getMinval());
+					val = String.format("%.2f", lisSet.getMinval());
 					break;
 				case "单位":
-					val = lisPack.getUnit();
+					val = lisSet.getUnit();
 					break;
 			}
 			props.put(key, val);

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

@@ -1,17 +1,17 @@
 package com.diagbot.repository;
 
-import com.diagbot.entity.node.LISPack;
+import com.diagbot.entity.node.LisSet;
 import org.springframework.data.neo4j.annotation.Query;
 import org.springframework.data.neo4j.repository.Neo4jRepository;
 
 import java.util.List;
 
 
-public interface LisPackRepository extends Neo4jRepository<LISPack, Long> {
+public interface LisSetRepository extends Neo4jRepository<LisSet, Long> {
 
-    List<LISPack> findByNameIs(String name);
+    List<LisSet> findByNameIs(String name);
 
-    List<LISPack> findByNameLike(String name);
+    List<LisSet> findByNameLike(String name);
 
     @Query("MATCH (n:实验室检查套餐) RETURN DISTINCT(KEYS(n))")
     List<List<String>> getKeys();

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

@@ -0,0 +1,275 @@
+package com.diagbot.repository;
+
+import com.diagbot.dto.*;
+import com.diagbot.entity.node.*;
+import com.diagbot.util.NeoUtil;
+import com.sun.xml.internal.bind.v2.runtime.reflect.opt.Const;
+
+import java.math.BigDecimal;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+public class MedicineCodeNode {
+
+
+    public DrugBillNeoDTO MedicinetoDrugDTO(MedCodeName medcode) {
+        DrugBillNeoDTO drugBillNeoDTO = new DrugBillNeoDTO();
+        NodeInfo nodeInfo = new NodeInfo();
+
+
+        Set<MedClass> medClass = medcode.getMedclasss();
+        for (MedClass medCls : medClass) {
+            NodeNeoDTO ageNeoDTO = new NodeNeoDTO();
+            nodeInfo.setName(medCls.getName());
+            nodeInfo.setTypeval(Constants.medcate);
+            drugBillNeoDTO.setAgeNeoDTO(ageNeoDTO);
+        }
+
+
+        Set<MedRegName> medRegNames = medcode.getMedregnames();
+        for (MedRegName medRegName : medRegNames) {
+            nodeInfo = new NodeInfo();
+            nodeInfo.setName(medRegName.getName());
+            nodeInfo.setTypeval(Constants.medregname);
+            drugBillNeoDTO.getClinicfindings().add(NeoUtil.updateNodeInfo(nodeInfo));
+        }
+
+
+        Set<Medicine> medicines = medcode.getMedicines();
+        for (Medicine medicine : medicines) {
+            nodeInfo = new NodeInfo();
+            nodeInfo.setName(medicine.getName());
+            nodeInfo.setTypeval(Constants.medicine);
+            drugBillNeoDTO.getVitals().add(NeoUtil.updateNodeInfo(nodeInfo));
+        }
+
+
+        Set<MedChemClass> medChemClasses = medcode.getMedchemclass();
+        for (MedChemClass medChemCls : medChemClasses) {
+            nodeInfo = new NodeInfo();
+            nodeInfo.setName(medChemCls.getName());
+            nodeInfo.setTypeval(Constants.medhuaxue);
+            drugBillNeoDTO.getLis().add(NeoUtil.updateNodeInfo(nodeInfo));
+        }
+
+
+        Set<MedYaoLiClass> medYaoLiClasses = medcode.getMedyaoliclass();
+        for (MedYaoLiClass medYaoLiCls : medYaoLiClasses) {
+            nodeInfo = new NodeInfo();
+            nodeInfo.setName(medYaoLiCls.getName());
+            nodeInfo.setTypeval(Constants.medyaoli);
+            drugBillNeoDTO.getPacs().add(NeoUtil.updateNodeInfo(nodeInfo));
+        }
+
+
+        Set<MedZhiLiaoClass> medZhiLiaoClasses = medcode.getMedzhiliaoclass();
+        for (MedZhiLiaoClass medZhiLiaoCls : medZhiLiaoClasses) {
+            nodeInfo = new NodeInfo();
+            nodeInfo.setName(medZhiLiaoCls.getName());
+            nodeInfo.setTypeval(Constants.medzhiliao);
+            drugBillNeoDTO.getAllergicmeds().add(NeoUtil.updateNodeInfo(nodeInfo));
+        }
+
+
+        Set<MedJiePouClass> medJiePouClasses = medcode.getMedjiepouclass();
+        for (MedJiePouClass medJiePouCls : medJiePouClasses) {
+            nodeInfo = new NodeInfo();
+            nodeInfo.setName(medJiePouCls.getName());
+            nodeInfo.setTypeval(Constants.medjiepou);
+            drugBillNeoDTO.getOperations().add(NeoUtil.updateNodeInfo(nodeInfo));
+        }
+
+
+        Set<MedCode> medCodes = medcode.getMedcodes();
+        for (MedCode medCode : medCodes) {
+            nodeInfo = new NodeInfo();
+            nodeInfo.setName(medCode.getName());
+            nodeInfo.setTypeval(Constants.medcode);
+            drugBillNeoDTO.getProcedures().add(NeoUtil.updateNodeInfo(nodeInfo));
+        }
+
+
+        Set<MedProdName> medProdNames = medcode.getMedprodnames();
+        for (MedProdName medProdName : medProdNames) {
+            nodeInfo = new NodeInfo();
+            nodeInfo.setName(medProdName.getName());
+            nodeInfo.setTypeval(Constants.medprodname);
+            drugBillNeoDTO.getDisease().add(NeoUtil.updateNodeInfo(nodeInfo));
+        }
+
+
+        Set<MedYiBaoClass> medYiBaoClasses = medcode.getMedyibaoclass();
+        for (MedYiBaoClass medYiBaoCls : medYiBaoClasses) {
+            nodeInfo = new NodeInfo();
+            nodeInfo.setName(medYiBaoCls.getName());
+            nodeInfo.setTypeval(Constants.medyibaocate);
+            drugBillNeoDTO.getGroup().add(NeoUtil.updateNodeInfo(nodeInfo));
+        }
+
+
+        Set<RegName> regNames = medcode.getRegnames();
+        for (RegName regName : regNames) {
+            nodeInfo = new NodeInfo();
+            nodeInfo.setName(regName.getName());
+            nodeInfo.setTypeval(Constants.regname);
+            drugBillNeoDTO.getConflictmeds().add(NeoUtil.updateNodeInfo(nodeInfo));
+        }
+
+
+        Set<HerbFangJiCate> herbFangJiCates = medcode.getHerbfangjicates();
+        for (HerbFangJiCate herbFangJiCate : herbFangJiCates) {
+            nodeInfo = new NodeInfo();
+            nodeInfo.setName(herbFangJiCate.getName());
+            nodeInfo.setTypeval(Constants.herbfangjicate);
+            drugBillNeoDTO.setGender(NeoUtil.updateNodeInfo(nodeInfo));
+        }
+
+
+        Set<HerbFangJiClass> herbFangJiClass = medcode.getHerbfangjiclass();
+        for (HerbFangJiClass herbFangJiCls : herbFangJiClass) {
+            nodeInfo = new NodeInfo();
+            nodeInfo.setName(herbFangJiCls.getName());
+            nodeInfo.setTypeval(Constants.herbfangjiclass);
+            drugBillNeoDTO.setGender(NeoUtil.updateNodeInfo(nodeInfo));
+        }
+
+
+        Set<HerbZhiLiaoClass> herbZhiLiaoClasses = medcode.getHerbzhiliaoclass();
+        for (HerbZhiLiaoClass herbZhiLiaoCls : herbZhiLiaoClasses) {
+            nodeInfo = new NodeInfo();
+            nodeInfo.setName(herbZhiLiaoCls.getName());
+            nodeInfo.setTypeval(Constants.herbzhiliaocate);
+            drugBillNeoDTO.setGender(NeoUtil.updateNodeInfo(nodeInfo));
+        }
+
+
+        Set<HerbDeptClass> herbDeptClasses = medcode.getHerbdeptclass();
+        for (HerbDeptClass herbDeptCls : herbDeptClasses) {
+            nodeInfo = new NodeInfo();
+            nodeInfo.setName(herbDeptCls.getName());
+            nodeInfo.setTypeval(Constants.herbdeptcate);
+            drugBillNeoDTO.setGender(NeoUtil.updateNodeInfo(nodeInfo));
+        }
+
+
+        Set<HerbYiBaoClass> herbYiBaoClasses = medcode.getHerbyibaoclass();
+        for (HerbYiBaoClass herbYiBaoCls : herbYiBaoClasses) {
+            nodeInfo = new NodeInfo();
+            nodeInfo.setName(herbYiBaoCls.getName());
+            nodeInfo.setTypeval(Constants.herbyibaocate);
+            drugBillNeoDTO.setGender(NeoUtil.updateNodeInfo(nodeInfo));
+        }
+
+
+        Set<ProdName> prodNames = medcode.getProdnames();
+        for (ProdName prodName : prodNames) {
+            nodeInfo = new NodeInfo();
+            nodeInfo.setName(prodName.getName());
+            nodeInfo.setTypeval(Constants.prodname);
+            drugBillNeoDTO.setGender(NeoUtil.updateNodeInfo(nodeInfo));
+        }
+
+
+        return drugBillNeoDTO;
+    }
+
+
+
+    /**
+     * 处理处方开单合理性
+     */
+    public List<BillNeoDTO> getDrugBill(Map<String, String> medsterm, MedicineCodeRepository medicineRepository) {
+        List<BillNeoDTO> billNeoDTOs = new ArrayList<>();
+        BillNeoDTO billNeoDTO;
+
+        DrugBillNeoDTO drugBillNeoDTO;
+
+        List<MedCodeName> medicine;
+        String medname;
+
+        for (String term : medsterm.keySet()) {
+            billNeoDTO = new BillNeoDTO();
+            medname = medsterm.get(term);
+            billNeoDTO.setName(term);
+            billNeoDTO.setStandname(medname);
+
+            drugBillNeoDTO = new DrugBillNeoDTO();
+
+            medicine = medicineRepository.findByNameIs(medname);
+
+            if (medicine != null && medicine.size()>0) {
+                drugBillNeoDTO = MedicinetoDrugDTO(medicine.get(0));
+
+                billNeoDTO.setDrugBillNeoDTO(drugBillNeoDTO);
+
+                billNeoDTOs.add(billNeoDTO);
+            }
+        }
+
+
+        return billNeoDTOs;
+    }
+
+
+
+    /**
+     * 获取药品商品名称列表
+     */
+    public List<DrugInfoDTO> getMedicineList(String name, MedicineCodeRepository medicineRepository) {
+        String nodename;
+
+        List<DrugInfoDTO> medslist = new ArrayList<>();
+        DrugInfoDTO drugInfoDTO;
+
+        List<MedCodeName> medicines = medicineRepository.findByNameLike("*"+name+"*");
+
+        for (MedCodeName med : medicines) {
+            drugInfoDTO = new DrugInfoDTO();
+            nodename = med.getName();
+
+            drugInfoDTO.setName(nodename);
+            medslist.add(drugInfoDTO);
+        }
+
+
+        return medslist;
+    }
+
+
+
+    /**
+     * 获取高危药品数据
+     */
+    public List<HighRiskNeoDTO> getHighRiskDrug(Map<String, String> drugsterm, MedicineCodeRepository medicineRepository) {
+        List<HighRiskNeoDTO> highRiskNeoDTOS = new ArrayList<>();
+        HighRiskNeoDTO highRiskNeoDTO;
+        String drugname;
+        List<Medicine> medicine;
+        Medicine med;
+/*
+        for (String term : drugsterm.keySet()) {
+            highRiskNeoDTO = new HighRiskNeoDTO();
+
+            drugname = drugsterm.get(term);
+            highRiskNeoDTO.setName(term);
+            highRiskNeoDTO.setStandname(drugname);
+
+            medicine = medicineRepository.findByNameIs(drugname);
+
+            if (null != medicine && medicine.size()>0) {
+                med = medicine.get(0);
+
+                if (null!=med.getRisklevel() && med.getRisklevel().trim().length()>0) {
+                    highRiskNeoDTO.setIsHighrisk(true);
+                    highRiskNeoDTO.setType("药品");
+                    highRiskNeoDTOS.add(highRiskNeoDTO);
+                }
+            }
+        }
+*/
+        return highRiskNeoDTOS;
+    }
+}
+

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

@@ -1,10 +1,15 @@
 package com.diagbot.repository;
 
-import com.diagbot.entity.node.Medicine_Code;
+import com.diagbot.entity.node.MedCodeName;
 import org.springframework.data.neo4j.repository.Neo4jRepository;
 
+import java.util.List;
 
-public interface MedicineCodeRepository extends Neo4jRepository<Medicine_Code, Long> {
 
+public interface MedicineCodeRepository extends Neo4jRepository<MedCodeName, Long> {
+
+    List<MedCodeName> findByNameIs(String name);
+
+    List<MedCodeName> findByNameLike(String name);
 }
 

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

@@ -1,233 +0,0 @@
-package com.diagbot.repository;
-
-import com.diagbot.dto.*;
-import com.diagbot.entity.node.*;
-import com.diagbot.util.NeoUtil;
-
-import java.math.BigDecimal;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-
-public class MedicineNode {
-
-
-    public DrugBillNeoDTO MedicinetoDrugDTO(Medicine medicine) {
-        DrugBillNeoDTO drugBillNeoDTO = new DrugBillNeoDTO();
-        NodeInfo nodeInfo = new NodeInfo();
-
-        Gender gender = medicine.getGender();
-        if (gender!=null) {
-            nodeInfo = new NodeInfo();
-            nodeInfo.setName(gender.getName());
-            nodeInfo.setTypeval("性别");
-            drugBillNeoDTO.setGender(NeoUtil.updateNodeInfo(nodeInfo));
-        }
-
-        Age age = medicine.getAge();
-        if (age!=null) {
-            NodeNeoDTO ageNeoDTO = new NodeNeoDTO();
-            ageNeoDTO.setMin(BigDecimal.valueOf(age.getMinval()));
-            ageNeoDTO.setMax(BigDecimal.valueOf(age.getMaxval()));
-            drugBillNeoDTO.setAgeNeoDTO(ageNeoDTO);
-        }
-
-
-        Set<ClinicalFinding> clinicalfindings = medicine.getClinicalfindings();
-        for (ClinicalFinding clinicalfinding : clinicalfindings) {
-            nodeInfo = new NodeInfo();
-            nodeInfo.setName(clinicalfinding.getName());
-            nodeInfo.setMinval(NeoUtil.DoubletoBigDecimal(clinicalfinding.getMinval()));
-            nodeInfo.setMaxval(NeoUtil.DoubletoBigDecimal(clinicalfinding.getMaxval()));
-            nodeInfo.setUnit(clinicalfinding.getUnit());
-            nodeInfo.setRange(clinicalfinding.getRange());
-            drugBillNeoDTO.getClinicfindings().add(NeoUtil.updateNodeInfo(nodeInfo));
-        }
-
-
-        Set<Vital> vitals = medicine.getVitals();
-        for (Vital vital : vitals) {
-            nodeInfo = new NodeInfo();
-            String name = vital.getName();
-            if (name.contains("禁忌")) {
-                name = name.substring(name.indexOf("禁忌")+2);
-            }
-            nodeInfo.setName(name);
-            nodeInfo.setMinval(NeoUtil.DoubletoBigDecimal(vital.getMinval()));
-            nodeInfo.setMaxval(NeoUtil.DoubletoBigDecimal(vital.getMaxval()));
-            nodeInfo.setUnit(vital.getUnit());
-            nodeInfo.setRange(vital.getRange());
-            drugBillNeoDTO.getVitals().add(NeoUtil.updateNodeInfo(nodeInfo));
-        }
-
-
-        Set<LIS> lisset = medicine.getLisset();
-        for (LIS lis : lisset) {
-            nodeInfo = new NodeInfo();
-            nodeInfo.setName(lis.getName());
-            nodeInfo.setMinval(NeoUtil.DoubletoBigDecimal(lis.getMinval()));
-            nodeInfo.setMaxval(NeoUtil.DoubletoBigDecimal(lis.getMaxval()));
-            nodeInfo.setUnit(lis.getUnit());
-            nodeInfo.setRange(lis.getRange());
-            drugBillNeoDTO.getLis().add(NeoUtil.updateNodeInfo(nodeInfo));
-        }
-
-
-        Set<PACS> pacsset = medicine.getPacs();
-        for (PACS pacs : pacsset) {
-            nodeInfo = new NodeInfo();
-            nodeInfo.setName(pacs.getName());
-            drugBillNeoDTO.getPacs().add(NeoUtil.updateNodeInfo(nodeInfo));
-        }
-
-
-        Set<AllergicMed> allergicmeds = medicine.getAllergicmeds();
-        for (AllergicMed allergicmed: allergicmeds) {
-            nodeInfo = new NodeInfo();
-            nodeInfo.setName(allergicmed.getName());
-            drugBillNeoDTO.getAllergicmeds().add(NeoUtil.updateNodeInfo(nodeInfo));
-        }
-
-
-        Set<Operation> operations = medicine.getOperations();
-        for (Operation operation : operations) {
-            nodeInfo = new NodeInfo();
-            nodeInfo.setName(operation.getName());
-            drugBillNeoDTO.getOperations().add(NeoUtil.updateNodeInfo(nodeInfo));
-        }
-
-
-        Set<Procedure> procedures = medicine.getProcedures();
-        for (Procedure procedure : procedures) {
-            nodeInfo = new NodeInfo();
-            nodeInfo.setName(procedure.getName());
-            drugBillNeoDTO.getProcedures().add(NeoUtil.updateNodeInfo(nodeInfo));
-        }
-
-
-        Set<Disease> diseases = medicine.getDiseases();
-        for (Disease disease : diseases) {
-            nodeInfo = new NodeInfo();
-            nodeInfo.setName(disease.getName());
-            drugBillNeoDTO.getDisease().add(NeoUtil.updateNodeInfo(nodeInfo));
-        }
-
-
-        Set<Group> groups = medicine.getGroups();
-        for (Group group : groups) {
-            nodeInfo = new NodeInfo();
-            nodeInfo.setName(group.getName());
-            drugBillNeoDTO.getGroup().add(NeoUtil.updateNodeInfo(nodeInfo));
-        }
-
-
-        Set<ConflictMed> conflict_medicines = medicine.getConflictmeds();
-        for (ConflictMed conflict_medicine : conflict_medicines) {
-            nodeInfo = new NodeInfo();
-            nodeInfo.setName(conflict_medicine.getName());
-            drugBillNeoDTO.getConflictmeds().add(NeoUtil.updateNodeInfo(nodeInfo));
-        }
-
-
-        return drugBillNeoDTO;
-    }
-
-
-
-    /**
-     * 处理处方开单合理性
-     */
-    public List<BillNeoDTO> getDrugBill(Map<String, String> medsterm, MedicineRepository medicineRepository) {
-        List<BillNeoDTO> billNeoDTOs = new ArrayList<>();
-        BillNeoDTO billNeoDTO;
-
-        DrugBillNeoDTO drugBillNeoDTO;
-
-        List<Medicine> medicine;
-        String medname;
-
-        for (String term : medsterm.keySet()) {
-            billNeoDTO = new BillNeoDTO();
-            medname = medsterm.get(term);
-            billNeoDTO.setName(term);
-            billNeoDTO.setStandname(medname);
-
-            drugBillNeoDTO = new DrugBillNeoDTO();
-
-            medicine = medicineRepository.findByNameIs(medname);
-
-            if (medicine != null && medicine.size()>0) {
-                drugBillNeoDTO = MedicinetoDrugDTO(medicine.get(0));
-
-                billNeoDTO.setDrugBillNeoDTO(drugBillNeoDTO);
-
-                billNeoDTOs.add(billNeoDTO);
-            }
-        }
-
-
-        return billNeoDTOs;
-    }
-
-
-
-    /**
-     * 获取药品商品名称列表
-     */
-    public List<DrugInfoDTO> getMedicineList(String name, MedicineRepository medicineRepository) {
-        String nodename;
-
-        List<DrugInfoDTO> medslist = new ArrayList<>();
-        DrugInfoDTO drugInfoDTO;
-
-        List<Medicine> medicines = medicineRepository.findByNameLike("*"+name+"*");
-
-        for (Medicine med : medicines) {
-            drugInfoDTO = new DrugInfoDTO();
-            nodename = med.getName();
-
-            drugInfoDTO.setName(nodename);
-            medslist.add(drugInfoDTO);
-        }
-
-
-        return medslist;
-    }
-
-
-
-    /**
-     * 获取高危药品数据
-     */
-    public List<HighRiskNeoDTO> getHighRiskDrug(Map<String, String> drugsterm, MedicineRepository medicineRepository) {
-        List<HighRiskNeoDTO> highRiskNeoDTOS = new ArrayList<>();
-        HighRiskNeoDTO highRiskNeoDTO;
-        String drugname;
-        List<Medicine> medicine;
-        Medicine med;
-
-        for (String term : drugsterm.keySet()) {
-            highRiskNeoDTO = new HighRiskNeoDTO();
-
-            drugname = drugsterm.get(term);
-            highRiskNeoDTO.setName(term);
-            highRiskNeoDTO.setStandname(drugname);
-
-            medicine = medicineRepository.findByNameIs(drugname);
-
-            if (null != medicine && medicine.size()>0) {
-                med = medicine.get(0);
-
-                if (null!=med.getRisklevel() && med.getRisklevel().trim().length()>0) {
-                    highRiskNeoDTO.setIsHighrisk(true);
-                    highRiskNeoDTO.setType("药品");
-                    highRiskNeoDTOS.add(highRiskNeoDTO);
-                }
-            }
-        }
-
-        return highRiskNeoDTOS;
-    }
-}
-

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

@@ -1,15 +0,0 @@
-package com.diagbot.repository;
-
-import com.diagbot.entity.node.Medicine;
-import org.springframework.data.neo4j.repository.Neo4jRepository;
-
-import java.util.List;
-
-
-public interface MedicineRepository extends Neo4jRepository<Medicine, Long> {
-
-    List<Medicine> findByNameIs(String name);
-
-    List<Medicine> findByNameLike(String name);
-}
-

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

@@ -1,15 +0,0 @@
-package com.diagbot.repository;
-
-import com.diagbot.entity.node.Operation;
-import org.springframework.data.neo4j.repository.Neo4jRepository;
-
-import java.util.List;
-
-
-public interface OperationRepository extends Neo4jRepository<Operation, Long> {
-
-    List<Operation> findByNameIs(String name);
-
-    List<Operation> findByNameLike(String name);
-}
-

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

@@ -2,31 +2,21 @@ package com.diagbot.repository;
 
 import com.diagbot.dto.BillNeoDTO;
 import com.diagbot.dto.PacsBillNeoDTO;
-import com.diagbot.dto.NodeNeoDTO;
 import com.diagbot.entity.node.*;
 import com.diagbot.util.NeoUtil;
 
-import java.math.BigDecimal;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
 
-public class PACSNode {
+public class PacsNameNode {
 
 
-    public PacsBillNeoDTO PacstoPACSDTO(PACS pacs) {
+    public PacsBillNeoDTO PacstoPACSDTO(PacsName pacs) {
         PacsBillNeoDTO pacsBillNeoDTO = new PacsBillNeoDTO();
         NodeInfo nodeInfo;
 
-        Age age = pacs.getAge();
-        if (age!=null) {
-            NodeNeoDTO ageNeoDTO = new NodeNeoDTO();
-            ageNeoDTO.setMin(BigDecimal.valueOf(age.getMinval()));
-            ageNeoDTO.setMax(BigDecimal.valueOf(age.getMaxval()));
-            pacsBillNeoDTO.setAgeNeoDTO(ageNeoDTO);
-        }
-
 
         Gender gender = pacs.getGender();
         if (gender!=null) {
@@ -65,45 +55,52 @@ public class PACSNode {
         }
 
 
-        Set<OralMedicine> conflict_medicines = pacs.getOralmeds();
-        for (OralMedicine conflict_medicine : conflict_medicines) {
+        Set<Lis> liss = pacs.getLis();
+        for (Lis lis : liss) {
             nodeInfo = new NodeInfo();
-            nodeInfo.setName(conflict_medicine.getName());
-            pacsBillNeoDTO.getOralmeds().add(NeoUtil.updateNodeInfo(nodeInfo));
+            nodeInfo.setName(lis.getName());
+            nodeInfo.setMinval(NeoUtil.DoubletoBigDecimal(lis.getMinval()));
+            nodeInfo.setMaxval(NeoUtil.DoubletoBigDecimal(lis.getMaxval()));
+            nodeInfo.setUnit(lis.getUnit());
+            nodeInfo.setRange(lis.getRange());
+            pacsBillNeoDTO.getLis().add(NeoUtil.updateNodeInfo(nodeInfo));
         }
 
-        Set<AllergicMed> allergicmeds = pacs.getAllergicmeds();
-        for (AllergicMed allergicmed : allergicmeds) {
+
+        Set<PacsDescribe> conflict_pacsdesc = pacs.getPacsdescribes();
+        for (PacsDescribe pacsdesc : conflict_pacsdesc) {
             nodeInfo = new NodeInfo();
-            nodeInfo.setName(allergicmed.getName());
-            pacsBillNeoDTO.getAllergicmeds().add(NeoUtil.updateNodeInfo(nodeInfo));
+            nodeInfo.setName(pacsdesc.getName());
+
+            pacsBillNeoDTO.getPacsDesc().add(NeoUtil.updateNodeInfo(nodeInfo));
         }
 
-        Set<Operation> operations = pacs.getOperations();
-        for (Operation operation : operations) {
+
+        Set<Group> groups = pacs.getGroups();
+        for (Group group : groups) {
             nodeInfo = new NodeInfo();
-            nodeInfo.setName(operation.getName());
-            pacsBillNeoDTO.getOperations().add(NeoUtil.updateNodeInfo(nodeInfo));
+            nodeInfo.setName(group.getName());
+
+            pacsBillNeoDTO.getGroup().add(NeoUtil.updateNodeInfo(nodeInfo));
         }
 
-        Set<Procedure> procedures = pacs.getProcedures();
-        for (Procedure procedure : procedures) {
+
+        Set<OralMedicine> conflict_medicines = pacs.getOralmedicines();
+        for (OralMedicine conflict_medicine : conflict_medicines) {
             nodeInfo = new NodeInfo();
-            nodeInfo.setName(procedure.getName());
-            pacsBillNeoDTO.getProcedures().add(NeoUtil.updateNodeInfo(nodeInfo));
+            nodeInfo.setName(conflict_medicine.getName());
+            pacsBillNeoDTO.getOralmeds().add(NeoUtil.updateNodeInfo(nodeInfo));
         }
 
-        Set<LIS> liss = pacs.getLiss();
-        for (LIS lis : liss) {
+
+        Set<MedAllergen> medAllergens = pacs.getMedallergens();
+        for (MedAllergen medAllergen : medAllergens) {
             nodeInfo = new NodeInfo();
-            nodeInfo.setName(lis.getName());
-            nodeInfo.setMinval(NeoUtil.DoubletoBigDecimal(lis.getMinval()));
-            nodeInfo.setMaxval(NeoUtil.DoubletoBigDecimal(lis.getMaxval()));
-            nodeInfo.setUnit(lis.getUnit());
-            nodeInfo.setRange(lis.getRange());
-            pacsBillNeoDTO.getLis().add(NeoUtil.updateNodeInfo(nodeInfo));
+            nodeInfo.setName(medAllergen.getName());
+            pacsBillNeoDTO.getAllergicmeds().add(NeoUtil.updateNodeInfo(nodeInfo));
         }
 
+
         Set<Disease> diseases = pacs.getDiseases();
         for (Disease disease : diseases) {
             nodeInfo = new NodeInfo();
@@ -112,20 +109,20 @@ public class PACSNode {
             pacsBillNeoDTO.getDisease().add(NeoUtil.updateNodeInfo(nodeInfo));
         }
 
-        Set<Group> groups = pacs.getGroups();
-        for (Group group : groups) {
-            nodeInfo = new NodeInfo();
-            nodeInfo.setName(group.getName());
 
-            pacsBillNeoDTO.getGroup().add(NeoUtil.updateNodeInfo(nodeInfo));
+        Set<Allergen> allergens = pacs.getAllergens();
+        for (Allergen allergen : allergens) {
+            nodeInfo = new NodeInfo();
+            nodeInfo.setName(allergen.getName());
+            pacsBillNeoDTO.getOperations().add(NeoUtil.updateNodeInfo(nodeInfo));
         }
 
-        Set<PACSDescribe> conflict_pacsdesc = pacs.getPacs_conflict_pacsdesc();
-        for (PACSDescribe pacsdesc : conflict_pacsdesc) {
-            nodeInfo = new NodeInfo();
-            nodeInfo.setName(pacsdesc.getName());
 
-            pacsBillNeoDTO.getPacsDesc().add(NeoUtil.updateNodeInfo(nodeInfo));
+        Set<ConflictDevice> conflictDevices = pacs.getConflictdevices();
+        for (ConflictDevice conflictDevice : conflictDevices) {
+            nodeInfo = new NodeInfo();
+            nodeInfo.setName(conflictDevice.getName());
+            pacsBillNeoDTO.getProcedures().add(NeoUtil.updateNodeInfo(nodeInfo));
         }
 
         return pacsBillNeoDTO;
@@ -135,13 +132,13 @@ public class PACSNode {
     /**
      * 处理辅检开单合理性
      */
-    public List<BillNeoDTO> getPacsBill(Map<String, String> pacsterm, PacsRepository pacsRepository) {
+    public List<BillNeoDTO> getPacsBill(Map<String, String> pacsterm, PacsNameRepository pacsRepository) {
         List<BillNeoDTO> billNeoDTOs = new ArrayList<>();
         BillNeoDTO billNeoDTO;
 
         PacsBillNeoDTO pacsBillNeoDTO;
 
-        List<PACS> pacslt;
+        List<PacsName> pacslt;
         String pacsname;
 
         for (String term : pacsterm.keySet()) {
@@ -170,14 +167,14 @@ public class PACSNode {
     /**
      * 获取辅检名称列表
      */
-    public List<String> getPACSNameList(String name, PacsRepository pacsRepository) {
+    public List<String> getPACSNameList(String name, PacsNameRepository pacsRepository) {
         String pacsname;
 
         List<String> pacslist = new ArrayList<>();
 
-        List<PACS> pacslt = pacsRepository.findByNameLike("*"+name+"*");
+        List<PacsName> pacslt = pacsRepository.findByNameLike("*"+name+"*");
 
-        for (PACS pacs : pacslt) {
+        for (PacsName pacs : pacslt) {
             pacsname = pacs.getName();
             if (!pacslist.contains(pacsname)) {
                 pacslist.add(pacsname);

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

@@ -0,0 +1,15 @@
+package com.diagbot.repository;
+
+import com.diagbot.entity.node.PacsName;
+import org.springframework.data.neo4j.repository.Neo4jRepository;
+
+import java.util.List;
+
+
+public interface PacsNameRepository extends Neo4jRepository<PacsName, Long> {
+
+    List<PacsName> findByNameIs(String name);
+
+    List<PacsName> findByNameLike(String name);
+}
+

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

@@ -1,15 +0,0 @@
-package com.diagbot.repository;
-
-import com.diagbot.entity.node.PACS;
-import org.springframework.data.neo4j.repository.Neo4jRepository;
-
-import java.util.List;
-
-
-public interface PacsRepository extends Neo4jRepository<PACS, Long> {
-
-    List<PACS> findByNameIs(String name);
-
-    List<PACS> findByNameLike(String name);
-}
-

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

@@ -0,0 +1,112 @@
+package com.diagbot.repository;
+
+import com.diagbot.dto.BillNeoDTO;
+import com.diagbot.dto.PacsBillNeoDTO;
+import com.diagbot.entity.node.*;
+import com.diagbot.util.NeoUtil;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+public class PacsSubNameNode {
+
+
+    public PacsBillNeoDTO PacstoPACSDTO(PacsSubName pacs) {
+        PacsBillNeoDTO pacsBillNeoDTO = new PacsBillNeoDTO();
+        NodeInfo nodeInfo;
+
+
+        Set<Group> groups = pacs.getGroups();
+        for (Group group : groups) {
+            nodeInfo = new NodeInfo();
+            nodeInfo.setName(group.getName());
+
+            pacsBillNeoDTO.getGroup().add(NeoUtil.updateNodeInfo(nodeInfo));
+        }
+
+
+        Set<Disease> diseases = pacs.getDiseases();
+        for (Disease disease : diseases) {
+            nodeInfo = new NodeInfo();
+            nodeInfo.setName(disease.getName());
+
+            pacsBillNeoDTO.getDisease().add(NeoUtil.updateNodeInfo(nodeInfo));
+        }
+
+
+        Set<MedAllergen> medAllergens = pacs.getMedallergens();
+        for (MedAllergen medAllergen : medAllergens) {
+            nodeInfo = new NodeInfo();
+            nodeInfo.setName(medAllergen.getName());
+            pacsBillNeoDTO.getOperations().add(NeoUtil.updateNodeInfo(nodeInfo));
+        }
+
+
+        return pacsBillNeoDTO;
+    }
+
+
+    /**
+     * 处理辅检开单合理性
+     */
+    public List<BillNeoDTO> getPacsBill(Map<String, String> pacsterm, PacsSubNameRepository pacsRepository) {
+        List<BillNeoDTO> billNeoDTOs = new ArrayList<>();
+        BillNeoDTO billNeoDTO;
+
+        PacsBillNeoDTO pacsBillNeoDTO;
+
+        List<PacsSubName> pacslt;
+        String pacsname;
+
+        for (String term : pacsterm.keySet()) {
+            billNeoDTO = new BillNeoDTO();
+            pacsname = pacsterm.get(term);
+            billNeoDTO.setName(term);
+            billNeoDTO.setStandname(pacsname);
+
+            pacsBillNeoDTO = new PacsBillNeoDTO();
+
+            pacslt = pacsRepository.findByNameIs(pacsname);
+
+            if (pacslt != null && pacslt.size()>0) {
+                pacsBillNeoDTO = PacstoPACSDTO(pacslt.get(0));
+            }
+
+            billNeoDTO.setPacsBillNeoDTO(pacsBillNeoDTO);
+
+            billNeoDTOs.add(billNeoDTO);
+        }
+
+        return billNeoDTOs;
+    }
+
+
+    /**
+     * 获取辅检子项目名称列表
+     */
+    public List<String> getPACSSubNameList(String name, PacsSubNameRepository pacsRepository) {
+        String pacsname;
+
+        List<String> pacslist = new ArrayList<>();
+
+        List<PacsSubName> pacslt = pacsRepository.findByNameLike("*"+name+"*");
+
+        for (PacsSubName pacs : pacslt) {
+            pacsname = pacs.getName();
+            if (!pacslist.contains(pacsname)) {
+                pacslist.add(pacsname);
+            }
+        }
+
+
+        return pacslist;
+    }
+}
+
+
+
+
+
+

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

@@ -0,0 +1,15 @@
+package com.diagbot.repository;
+
+import com.diagbot.entity.node.PacsSubName;
+import org.springframework.data.neo4j.repository.Neo4jRepository;
+
+import java.util.List;
+
+
+public interface PacsSubNameRepository extends Neo4jRepository<PacsSubName, Long> {
+
+    List<PacsSubName> findByNameIs(String name);
+
+    List<PacsSubName> findByNameLike(String name);
+}
+

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

@@ -7,11 +7,12 @@ import com.diagbot.util.NeoUtil;
 import java.math.BigDecimal;
 import java.util.*;
 
-public class DiseaseNode {
+public class YiBaoDiseaseNode {
 
-	public PushDTO DiseasetoDiseaseDTO(Disease disease) {
+	public PushDTO YiBaoDiseasetoDiseaseDTO(YiBaoDiseaseName disease) {
 
         PushDTO pushDTO = new PushDTO();
+        PushBaseDTO pushBaseDTO;
 
 		/*
 		CureRate curerate = disease.getCurerate();
@@ -38,7 +39,7 @@ public class DiseaseNode {
 		for (Alias alias : aliass) {
 			NeoUtil.updateNodeInfo(alias.getName(), null, null, null);
 		}
-		*/
+
 
 		Set<Vital> vitals = disease.getVitals();
 		for (Vital vital : vitals) {
@@ -46,19 +47,19 @@ public class DiseaseNode {
 			pushDTO.getVital().add(NeoUtil.updatePushInfo(name));
 		}
 
-		/*
+
 		Set<Dept> depts = disease.getDepts();
 		for (Dept dept : depts) {
 			NeoUtil.updateNodeInfo(dept.getName(), null, null, null);
 		}
-		*/
+
 
 		Set<Symptom> symptoms = disease.getSymptoms();
 		for (Symptom symptom : symptoms) {
             pushDTO.getSymptom().add(NeoUtil.updatePushInfo(symptom.getName()));
 		}
 
-		/*
+
 		Set<Situation> situations = disease.getSituations();
 		for (Situation situation : situations) {
 			NeoUtil.updateNodeInfo(situation.getName(), null, null, null);
@@ -73,7 +74,7 @@ public class DiseaseNode {
 		for (Dept stddept : stddepts) {
 			NeoUtil.updateNodeInfo(stddept.getName(), null, null, null);
 		}
-		*/
+
 
 		Set<Complication> complications = disease.getComplications();
 		for (Complication complication : complications) {
@@ -91,12 +92,12 @@ public class DiseaseNode {
 			pushDTO.getMedicines().add(NeoUtil.updatePushInfo(medicine.getName()));
 		}
 
-		/*
+
 		Set<Cause> causes = disease.getCauses();
 		for (Cause cause : causes) {
 			NeoUtil.updateNodeInfo(cause.getName(), null, null, null);
 		}
-		*/
+
 
 		Set<Disease> diff_diseases = disease.getDiff_diseases();
 		List<PushBaseDTO> pushBaseDTOs = new ArrayList<>();
@@ -112,7 +113,7 @@ public class DiseaseNode {
 			pushDTO.getOperations().add(NeoUtil.updatePushInfo(operation.getName()));
 		}
 
-		/*
+
 		Set<Pathogen> pathogens = disease.getPathogens();
 		for (Pathogen pathogen : pathogens) {
 			NeoUtil.updateNodeInfo(pathogen.getName(), null, null, null);
@@ -142,14 +143,14 @@ public class DiseaseNode {
 		for (Complication generalcompl : generalcompls) {
 			NeoUtil.updateNodeInfo(generalcompl.getName(), null, null, null);
 		}
-		*/
+
 
 		Set<LIS> liss = disease.getLiss_dis();
 		for (LIS lis : liss) {
 			pushDTO.getLis().add(NeoUtil.updatePushInfo(lis.getName()));
 		}
 
-		/*
+
 		Set<PACS> pacs_disease= disease.getPacs_disease();
 		for (PACS pacs : pacs_disease) {
 			String name = pacs.getName();
@@ -165,6 +166,26 @@ public class DiseaseNode {
 		}
 		*/
 
+		Set<YiBaoICD_10Code> yiBaoICD10Codes = disease.getYibaoicd_10codes();
+		for (YiBaoICD_10Code code : yiBaoICD10Codes) {
+		    pushBaseDTO = new PushBaseDTO();
+		    pushBaseDTO.setName(code.getName());
+        }
+
+
+		Set<GuoLinICD_10Code> guoLinICD10Codes = disease.getGuolinicd_10codes();
+		for (GuoLinICD_10Code code : guoLinICD10Codes) {
+			pushBaseDTO = new PushBaseDTO();
+			pushBaseDTO.setName(code.getName());
+		}
+
+		Set<GuoLinDiseaseName> guoLinDiseaseNames = disease.getGuolindiseasenames();
+		for (GuoLinDiseaseName glname : guoLinDiseaseNames) {
+			pushBaseDTO = new PushBaseDTO();
+			pushBaseDTO.setName(glname.getName());
+		}
+
+
 		return pushDTO;
 	}
 

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

@@ -0,0 +1,11 @@
+package com.diagbot.repository;
+
+import com.diagbot.entity.node.YiBaoDiseaseName;
+import org.springframework.data.neo4j.repository.Neo4jRepository;
+
+
+public interface YiBaoDiseaseRepository extends Neo4jRepository<YiBaoDiseaseName, Long> {
+
+    YiBaoDiseaseName findByNameIs(String name);
+}
+

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

@@ -15,10 +15,10 @@ import java.util.List;
 import java.util.Map;
 import java.util.Set;
 
-public class OperationNode {
+public class YiBaoOperationNameNode {
 
 
-    public OperationBillNeoDTO OperationtoOperationDTO(Operation operation) {
+    public OperationBillNeoDTO YiBaoOperationtoOperationDTO(YiBaoOperationName operation) {
         OperationBillNeoDTO opBillNeoDTO = new OperationBillNeoDTO();
         NodeInfo nodeInfo;
 
@@ -26,6 +26,7 @@ public class OperationNode {
         if (null!=gender) {
             nodeInfo = new NodeInfo();
             nodeInfo.setName(gender.getName());
+            nodeInfo.setTypeval(Constants.gender);
             opBillNeoDTO.setGender(NeoUtil.updateNodeInfo(nodeInfo));
         }
 
@@ -37,6 +38,7 @@ public class OperationNode {
             nodeInfo.setMaxval(NeoUtil.DoubletoBigDecimal(clinicalfinding.getMaxval()));
             nodeInfo.setUnit(clinicalfinding.getUnit());
             nodeInfo.setRange(clinicalfinding.getRange());
+            nodeInfo.setTypeval(Constants.clinicalfinding);
             opBillNeoDTO.getClinicfindings().add(NeoUtil.updateNodeInfo(nodeInfo));
         }
 
@@ -52,31 +54,35 @@ public class OperationNode {
             nodeInfo.setMaxval(NeoUtil.DoubletoBigDecimal(vital.getMaxval()));
             nodeInfo.setUnit(vital.getUnit());
             nodeInfo.setRange(vital.getRange());
+            nodeInfo.setTypeval(Constants.vital);
             opBillNeoDTO.getVitals().add(NeoUtil.updateNodeInfo(nodeInfo));
         }
 
-        Set<LIS> lisSet = operation.getConflict_lis();
-        for (LIS lis : lisSet) {
+        Set<Lis> lisSet = operation.getLiss();
+        for (Lis lis : lisSet) {
             nodeInfo = new NodeInfo();
             nodeInfo.setName(lis.getName());
             nodeInfo.setMinval(NeoUtil.DoubletoBigDecimal(lis.getMinval()));
             nodeInfo.setMaxval(NeoUtil.DoubletoBigDecimal(lis.getMaxval()));
             nodeInfo.setUnit(lis.getUnit());
             nodeInfo.setRange(lis.getRange());
+            nodeInfo.setTypeval(Constants.lis);
             opBillNeoDTO.getLis().add(NeoUtil.updateNodeInfo(nodeInfo));
         }
 
-        Set<OralMedicine> conflict_oralmeds = operation.getOralMedicines();
+        Set<OralMedicine> conflict_oralmeds = operation.getOralmeds();
         for (OralMedicine conflict_oralmed : conflict_oralmeds) {
             nodeInfo = new NodeInfo();
             nodeInfo.setName(conflict_oralmed.getName());
+            nodeInfo.setTypeval(Constants.oralmed);
             opBillNeoDTO.getOralmeds().add(NeoUtil.updateNodeInfo(nodeInfo));
         }
 
-        Set<Disease> conflict_disease = operation.getConflict_diseases();
+        Set<Disease> conflict_disease = operation.getDiseases();
         for (Disease disease : conflict_disease) {
             nodeInfo = new NodeInfo();
             nodeInfo.setName(disease.getName());
+            nodeInfo.setTypeval(Constants.disease);
             opBillNeoDTO.getDisease().add(NeoUtil.updateNodeInfo(nodeInfo));
         }
 
@@ -84,23 +90,41 @@ public class OperationNode {
         for (Group group : conflict_group) {
             nodeInfo = new NodeInfo();
             nodeInfo.setName(group.getName());
+            nodeInfo.setTypeval(Constants.group);
             opBillNeoDTO.getGroup().add(NeoUtil.updateNodeInfo(nodeInfo));
         }
 
-        Set<PACSDescribe> conflict_pacsdesc = operation.getConflict_pacsdesc();
-        for (PACSDescribe pacsdesc : conflict_pacsdesc) {
+        Set<PacsDescribe> conflict_pacsdesc = operation.getPacsdescs();
+        for (PacsDescribe pacsdesc : conflict_pacsdesc) {
             nodeInfo = new NodeInfo();
             nodeInfo.setName(pacsdesc.getName());
+            nodeInfo.setTypeval(Constants.pacsdesc);
             opBillNeoDTO.getPacsDesc().add(NeoUtil.updateNodeInfo(nodeInfo));
         }
 
+        Set<MedAllergen> conflict_medallegen = operation.getMedallergens();
+        for (MedAllergen medAllergen : conflict_medallegen) {
+            nodeInfo = new NodeInfo();
+            nodeInfo.setName(medAllergen.getName());
+            nodeInfo.setTypeval(Constants.medallergen);
+            opBillNeoDTO.getMedallegen().add(NeoUtil.updateNodeInfo(nodeInfo));
+        }
+
+        Set<ConflictDevice> conflictDevices = operation.getConflictdevices();
+        for (ConflictDevice device : conflictDevices) {
+            nodeInfo = new NodeInfo();
+            nodeInfo.setName(device.getName());
+            nodeInfo.setTypeval(Constants.conflictdevice);
+            opBillNeoDTO.getMedallegen().add(NeoUtil.updateNodeInfo(nodeInfo));
+        }
+
         return opBillNeoDTO;
     }
 
     /**
      * 处理手术开单合理性
      */
-    public List<BillNeoDTO> getOperationBill(Map<String, String> opterm, OperationRepository opRepository) {
+    public List<BillNeoDTO> getOperationBill(Map<String, String> opterm, YiBaoOperationNameRepository opRepository) {
         List<BillNeoDTO> billNeoDTOs = new ArrayList<>();
         BillNeoDTO billNeoDTO;
 
@@ -113,10 +137,10 @@ public class OperationNode {
             opname = opterm.get(term);
             billNeoDTO.setName(opname);
 
-            List<Operation> operations = opRepository.findByNameIs(opname);
+            List<YiBaoOperationName> operations = opRepository.findByNameIs(opname);
 
             if (null!=operations && operations.size()>0) {
-                opBillNeoDTO = OperationtoOperationDTO(operations.get(0));
+                opBillNeoDTO = YiBaoOperationtoOperationDTO(operations.get(0));
                 billNeoDTO.setOperationBillNeoDTO(opBillNeoDTO);
             }
 
@@ -129,15 +153,15 @@ public class OperationNode {
     /**
      * 获取手术操作名称列表
      */
-    public List<OperationInfoDTO> getOperationList(String name, OperationRepository operationRepository) {
+    public List<OperationInfoDTO> getOperationList(String name, YiBaoOperationNameRepository operationRepository) {
         String nodename;
 
         List<OperationInfoDTO> opslist = new ArrayList<>();
         OperationInfoDTO opInfoDTO;
 
-        List<Operation> operations = operationRepository.findByNameLike("*"+name+"*");
+        List<YiBaoOperationName> operations = operationRepository.findByNameLike("*"+name+"*");
 
-        for (Operation op : operations) {
+        for (YiBaoOperationName op : operations) {
             opInfoDTO = new OperationInfoDTO();
             nodename = op.getName();
 
@@ -154,11 +178,11 @@ public class OperationNode {
     /**
      * 获取高危手术和操作数据
      */
-    public List<HighRiskNeoDTO> getHighRiskOperation(Map<String, String> opsterm, OperationRepository operationRepository) {
+    public List<HighRiskNeoDTO> getHighRiskOperation(Map<String, String> opsterm, YiBaoOperationNameRepository operationRepository) {
         List<HighRiskNeoDTO> highRiskNeoDTOS = new ArrayList<>();
         HighRiskNeoDTO highRiskNeoDTO;
         String opname;
-        Operation operation;
+        YiBaoOperationName operation;
 
         for (String term : opsterm.keySet()) {
             highRiskNeoDTO = new HighRiskNeoDTO();
@@ -167,8 +191,8 @@ public class OperationNode {
             highRiskNeoDTO.setName(term);
             highRiskNeoDTO.setStandname(opname);
 
-            List<Operation> operations = operationRepository.findByNameIs(opname);
-
+            List<YiBaoOperationName> operations = operationRepository.findByNameIs(opname);
+/*
             if (null != operations) {
                 operation = operations.get(0);
                 if (null!=operation.getRisklevel() && operation.getRisklevel().trim().length()>0) {
@@ -177,6 +201,7 @@ public class OperationNode {
                     highRiskNeoDTOS.add(highRiskNeoDTO);
                 }
             }
+*/
         }
 
         return highRiskNeoDTOS;

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

@@ -0,0 +1,15 @@
+package com.diagbot.repository;
+
+import com.diagbot.entity.node.YiBaoOperationName;
+import org.springframework.data.neo4j.repository.Neo4jRepository;
+
+import java.util.List;
+
+
+public interface YiBaoOperationNameRepository extends Neo4jRepository<YiBaoOperationName, Long> {
+
+    List<YiBaoOperationName> findByNameIs(String name);
+
+    List<YiBaoOperationName> findByNameLike(String name);
+}
+