Merge branch 'gdb'

src/main/java/com/diagbot/aggregate/IndicationAggregate.java

@@ -6,6 +6,7 @@ import com.diagbot.facade.BillFacade;
 import com.diagbot.facade.CriticalFacade;
 import com.diagbot.facade.HighRiskFacade;
 import com.diagbot.util.CoreUtil;
+import com.diagbot.util.StringUtil;
 import com.diagbot.vo.IndicationPushVO;
 import io.github.lvyahui8.spring.annotation.DataConsumer;
 import io.github.lvyahui8.spring.annotation.DataProvider;
@@ -75,8 +76,10 @@ public class IndicationAggregate {
                 billFacade.billFac(indicationPushVO, wordCrfDTO, res);
                 CoreUtil.getDebugStr(start, "开单规则耗时", res.getDebug());
             } catch (Exception e) {
-                log.error("【开单规则出错】" + e.getMessage());
-                CoreUtil.getDebugStr("【开单规则出错】", e.getMessage(), res.getDebug());
+                String errMsg = StringUtil.isNotBlank(indicationPushVO.getIdNum()) ?
+                        "行号【" + indicationPushVO.getIdNum() + "】" : "";
+                log.error("【开单规则出错】" + errMsg + e.getMessage());
+                CoreUtil.getDebugStr("【开单规则出错】", errMsg + e.getMessage(), res.getDebug());
             }
             return res;
         }

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

@@ -28,6 +28,9 @@ public class BillNeoDTO {
     // 手术和操作开单合理性项目
     private OperationBillNeoDTO operationBillNeoDTO;
 
+    // 联合项目开单合理性项目
+    private CombiOpBillNeoDTO combiOpBillNeoDTO;
+
     // 输血开单合理性项目
     private TransfusionBillNeoDTO transfusionBillNeoDTO;
 }

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/Alias.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 Alias extends BaseNode  {
-
-    @Relationship(type="疾病相关别名", direction = Relationship.INCOMING)
-    private Set<Disease> diseases;
-}

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

@@ -0,0 +1,22 @@
+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.Set;
+import java.util.HashSet;
+
+@Setter
+@Getter
+@NodeEntity(label = "过敏原")
+public class Allergen extends BaseNode  {
+
+
+	@Relationship(type = "辅助检查名称禁忌过敏原", direction = Relationship.INCOMING)
+	private Set<Pacs> pacss = new HashSet<>();
+
+}

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,7 +1,6 @@
 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;
@@ -9,32 +8,29 @@ import org.neo4j.ogm.annotation.Property;
 import org.neo4j.ogm.annotation.Relationship;
 
 import java.util.Set;
+import java.util.HashSet;
 
 @Setter
 @Getter
-//@EqualsAndHashCode(callSuper = true)
 @NodeEntity(label = "临床表现")
 public class ClinicalFinding extends BaseNode  {
 
-    @Property(name = "最大值")
-    private Double maxval;
+	@Property(name = "单位")
+	private String unit;
 
-    @Property(name = "最小值")
-    private Double minval;
+	@Property(name = "最小值")
+	private Double minval;
 
-    @Property(name = "单位")
-    private String unit;
+	@Property(name = "最大值")
+	private Double maxval;
 
-    @Property(name = "范围")
-    private Integer range;
+	@Property(name = "范围")
+	private Integer range;
 
-    @Relationship(type="药品通用名禁忌临床表现", direction = Relationship.INCOMING)
-    private Set<Medicine> medicines;
+	@Relationship(type = "辅助检查名称禁忌临床表现", direction = Relationship.INCOMING)
+	private Set<Pacs> pacss = new HashSet<>();
 
-    @Relationship(type="辅助检查禁忌临床表现", direction = Relationship.INCOMING)
-    private Set<PACS> pacs;
+	@Relationship(type = "医保手术和操作名称禁忌临床表现", direction = Relationship.INCOMING)
+	private Set<YiBaoOperationName> yibaooperationnames = new HashSet<>();
 
-    @Relationship(type="实验室检查禁忌临床表现", direction = Relationship.INCOMING)
-    private Set<ClinicalFinding> clinicalfindings;
-
-}
+}

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

@@ -0,0 +1,40 @@
+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.Set;
+import java.util.HashSet;
+
+@Setter
+@Getter
+@NodeEntity(label = "联合项目")
+public class CombiOperation extends BaseNode  {
+
+
+	@Property(name = "联合操作")
+	private String combi_name;
+
+	@Relationship(type = "联合项目禁忌实验室检查", direction = Relationship.OUTGOING)
+	private Set<Lis> liss = new HashSet<>();
+
+	@Relationship(type = "联合项目禁忌辅助检查名称描述", direction = Relationship.OUTGOING)
+	private Set<PacsDescribe> pacsdescs = 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<MedAllergen> medallergens = new HashSet<>();
+
+	@Relationship(type = "联合项目禁忌性别", direction = Relationship.OUTGOING)
+	private Gender gender;
+
+}

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/ConflictDevice.java

@@ -0,0 +1,25 @@
+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.Set;
+import java.util.HashSet;
+
+@Setter
+@Getter
+@NodeEntity(label = "禁忌医疗器械及物品")
+public class ConflictDevice extends BaseNode  {
+
+
+	@Relationship(type = "辅助检查名称禁忌禁忌医疗器械及物品", direction = Relationship.INCOMING)
+	private Set<Pacs> pacss = new HashSet<>();
+
+	@Relationship(type = "医保手术和操作名称禁忌禁忌医疗器械及物品", direction = Relationship.INCOMING)
+	private Set<YiBaoOperationName> yibaooperationnames = new HashSet<>();
+
+}

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,126 +1,34 @@
 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;
+import java.util.HashSet;
 
 @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<Alias> alias = 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;
-}
 
+	@Relationship(type = "医保手术和操作名称禁忌疾病", direction = Relationship.INCOMING)
+	private Set<YiBaoOperationName> yibaooperationnames = new HashSet<>();
 
+	@Relationship(type = "辅助检查名称禁忌疾病", direction = Relationship.INCOMING)
+	private Set<Pacs> pacss = new HashSet<>();
 
+	@Relationship(type = "联合项目禁忌疾病", direction = Relationship.INCOMING)
+	private Set<CombiOperation> combioperations = new HashSet<>();
 
+	@Relationship(type = "辅助检查名称子项目名称禁忌疾病", direction = Relationship.INCOMING)
+	private Set<PacsNameSubName> pacsnamesubnames = new HashSet<>();
 
+	@Relationship(type = "辅助检查子项目名称禁忌疾病", direction = Relationship.INCOMING)
+	private Set<PacsSubName> pacssubnames = new HashSet<>();
 
+}

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 +1,37 @@
 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;
+import java.util.HashSet;
 
 @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> pacss = new HashSet<>();
 
-    @Relationship(type = "辅助检查禁忌性别", direction = Relationship.INCOMING)
-    private Set<PACS> pacs;
+	@Relationship(type = "实验室检查套餐名禁忌性别", direction = Relationship.INCOMING)
+	private Set<LisSet> lissets = new HashSet<>();
 
-    @Relationship(type="实验室检查禁忌性别", direction = Relationship.INCOMING)
-    private Set<LIS> lis;
-}
+	@Relationship(type = "医保手术和操作名称禁忌性别", direction = Relationship.INCOMING)
+	private Set<YiBaoOperationName> yibaooperationnames = new HashSet<>();
+
+	@Relationship(type = "辅助检查名称子项目名称禁忌性别", direction = Relationship.INCOMING)
+	private Set<PacsNameSubName> pacsnamesubnames = new HashSet<>();
+
+	@Relationship(type = "联合项目禁忌性别", direction = Relationship.INCOMING)
+	private Set<CombiOperation> combioperations = new HashSet<>();
+
+	@Relationship(type = "实验室检查名称禁忌性别", direction = Relationship.INCOMING)
+	private Set<LisName> lisnames = new HashSet<>();
+
+}

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

@@ -1,32 +1,37 @@
 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;
+import java.util.HashSet;
 
 @Setter
 @Getter
-//@EqualsAndHashCode(callSuper = false)
-@NodeEntity(label = "人群")
+@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<LisName> lisnames = new HashSet<>();
 
-    @Relationship(type="辅助检查禁忌人群", direction = Relationship.INCOMING)
-    private Set<PACS> pacs;
+	@Relationship(type = "医保手术和操作名称禁忌禁忌人群", direction = Relationship.INCOMING)
+	private Set<YiBaoOperationName> yibaooperationnames = new HashSet<>();
 
-    @Relationship(type="实验室检查禁忌人群", direction = Relationship.INCOMING)
-    private Set<LIS> lis;
-}
+	@Relationship(type = "辅助检查名称禁忌禁忌人群", direction = Relationship.INCOMING)
+	private Set<Pacs> pacss = new HashSet<>();
+
+	@Relationship(type = "联合项目禁忌禁忌人群", direction = Relationship.INCOMING)
+	private Set<CombiOperation> combioperations = new HashSet<>();
+
+	@Relationship(type = "辅助检查名称子项目名称禁忌禁忌人群", direction = Relationship.INCOMING)
+	private Set<PacsNameSubName> pacsnamesubnames = new HashSet<>();
+
+	@Relationship(type = "辅助检查子项目名称禁忌禁忌人群", direction = Relationship.INCOMING)
+	private Set<PacsSubName> pacssubnames = new HashSet<>();
+
+}

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

@@ -0,0 +1,22 @@
+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.Set;
+import java.util.HashSet;
+
+@Setter
+@Getter
+@NodeEntity(label = "国临疾病名称")
+public class GuoLinDiseaseName extends BaseNode  {
+
+
+	@Relationship(type = "医保疾病名称相关国临疾病名称", direction = Relationship.INCOMING)
+	private Set<YiBaoDiseaseName> yibaodiseasenames = new HashSet<>();
+
+}

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

@@ -0,0 +1,22 @@
+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.Set;
+import java.util.HashSet;
+
+@Setter
+@Getter
+@NodeEntity(label = "国临ICD_10代码")
+public class GuoLinICD_10Code extends BaseNode  {
+
+
+	@Relationship(type = "医保疾病名称相关国临ICD-10代码", direction = Relationship.INCOMING)
+	private Set<YiBaoDiseaseName> yibaodiseasenames = new HashSet<>();
+
+}

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

@@ -0,0 +1,22 @@
+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.Set;
+import java.util.HashSet;
+
+@Setter
+@Getter
+@NodeEntity(label = "国临ICD_9_CM3代码")
+public class GuoLinICD_9_CM3Code extends BaseNode  {
+
+
+	@Relationship(type = "医保手术和操作名称相关国临ICD-9-CM3代码", direction = Relationship.INCOMING)
+	private Set<YiBaoOperationName> yibaooperationnames = new HashSet<>();
+
+}

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

@@ -0,0 +1,22 @@
+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.Set;
+import java.util.HashSet;
+
+@Setter
+@Getter
+@NodeEntity(label = "国临手术和操作名称")
+public class GuoLinOperationName extends BaseNode  {
+
+
+	@Relationship(type = "医保手术和操作名称相关国临手术和操作名称", direction = Relationship.INCOMING)
+	private Set<YiBaoOperationName> yibaooperationnames = new HashSet<>();
+
+}

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

@@ -0,0 +1,22 @@
+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.Set;
+import java.util.HashSet;
+
+@Setter
+@Getter
+@NodeEntity(label = "中成药科室类别")
+public class HerbDeptClass extends BaseNode  {
+
+
+	@Relationship(type = "药品相关中成药科室类别", direction = Relationship.INCOMING)
+	private Set<MedCodeName> medcodenames = new HashSet<>();
+
+}

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

@@ -0,0 +1,22 @@
+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.Set;
+import java.util.HashSet;
+
+@Setter
+@Getter
+@NodeEntity(label = "中成药方剂学大类")
+public class HerbFangJiCate extends BaseNode  {
+
+
+	@Relationship(type = "药品相关中成药方剂学大类", direction = Relationship.INCOMING)
+	private Set<MedCodeName> medcodenames = new HashSet<>();
+
+}

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

@@ -0,0 +1,22 @@
+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.Set;
+import java.util.HashSet;
+
+@Setter
+@Getter
+@NodeEntity(label = "中成药方剂学类别")
+public class HerbFangJiClass extends BaseNode  {
+
+
+	@Relationship(type = "药品相关中成药方剂学类别", direction = Relationship.INCOMING)
+	private Set<MedCodeName> medcodenames = new HashSet<>();
+
+}

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

@@ -0,0 +1,22 @@
+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.Set;
+import java.util.HashSet;
+
+@Setter
+@Getter
+@NodeEntity(label = "中成药医保类别")
+public class HerbYiBaoClass extends BaseNode  {
+
+
+	@Relationship(type = "药品相关中成药医保类别", direction = Relationship.INCOMING)
+	private Set<MedCodeName> medcodenames = new HashSet<>();
+
+}

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

@@ -0,0 +1,22 @@
+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.Set;
+import java.util.HashSet;
+
+@Setter
+@Getter
+@NodeEntity(label = "中成药治疗学类别")
+public class HerbZhiLiaoClass extends BaseNode  {
+
+
+	@Relationship(type = "药品相关中成药治疗学类别", direction = Relationship.INCOMING)
+	private Set<MedCodeName> medcodenames = new HashSet<>();
+
+}

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 +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.math.BigDecimal;
-import java.util.HashSet;
-import java.util.Set;
-
-@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<>();
-
-    @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_lis;
-
-    @Relationship(type="药品通用名禁忌实验室检查", direction = Relationship.INCOMING)
-    private Set<Medicine> medicine_conflict_lis;
-
-    @Relationship(type="辅助检查禁忌实验室检查", direction = Relationship.INCOMING)
-    private Set<PACS> pacs_conflict_lis;
-
-    @Relationship(type="医保ICD-10疾病相关实验室检查", direction = Relationship.INCOMING)
-    private Set<Disease> icddis_related_lis = new HashSet<>();
-
-    @Relationship(type="实验室检查套餐相关实验室检查", direction = Relationship.INCOMING)
-    private Set<LISPack> lisPacks_related_lis = new HashSet<>();
-}
-
-

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

@@ -29,8 +29,8 @@ public class LISCritical extends BaseNode  {
     @Property(name = "危急值范围")
     private String range;
 
-    @Relationship(type="实验室检查相关实验室检查危急值", direction = Relationship.INCOMING)
-    private LIS lis_related_liscritial;
+    @Relationship(type="实验室检查名称相关实验室检查危急值", direction = Relationship.INCOMING)
+    private LisName lisname;
 
 }
 

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/Lis.java

@@ -0,0 +1,45 @@
+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.Set;
+import java.util.HashSet;
+
+@Setter
+@Getter
+@NodeEntity(label = "实验室检查")
+public class Lis extends BaseNode  {
+
+	@Property(name = "单位")
+	private String unit;
+
+	@Property(name = "最小值")
+	private Double minval;
+
+	@Property(name = "最大值")
+	private Double maxval;
+
+	@Property(name = "范围")
+	private Integer range;
+
+	@Relationship(type = "医保手术和操作名称禁忌实验室检查", direction = Relationship.INCOMING)
+	private Set<YiBaoOperationName> yibaooperationnames = new HashSet<>();
+
+	@Relationship(type = "辅助检查名称禁忌实验室检查", direction = Relationship.INCOMING)
+	private Set<Pacs> pacss = new HashSet<>();
+
+	@Relationship(type = "联合项目禁忌实验室检查", direction = Relationship.INCOMING)
+	private Set<CombiOperation> combioperations = 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/LisAlias.java

@@ -0,0 +1,22 @@
+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.Set;
+import java.util.HashSet;
+
+@Setter
+@Getter
+@NodeEntity(label = "实验室检查别名")
+public class LisAlias extends BaseNode  {
+
+
+	@Relationship(type = "实验室检查名称相关实验室检查别名", direction = Relationship.INCOMING)
+	private Set<LisName> lisnames = new HashSet<>();
+
+}

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

@@ -0,0 +1,22 @@
+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.Set;
+import java.util.HashSet;
+
+@Setter
+@Getter
+@NodeEntity(label = "实验室检查代码")
+public class LisCode extends BaseNode  {
+
+
+	@Relationship(type = "实验室检查名称相关实验室检查代码", direction = Relationship.INCOMING)
+	private Set<LisName> lisnames = new HashSet<>();
+
+}

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

@@ -0,0 +1,22 @@
+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.Set;
+import java.util.HashSet;
+
+@Setter
+@Getter
+@NodeEntity(label = "实验室检查一级分类")
+public class LisFirstClass extends BaseNode  {
+
+
+	@Relationship(type = "实验室检查名称相关实验室检查一级分类", direction = Relationship.INCOMING)
+	private Set<LisName> lisnames = new HashSet<>();
+
+}

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

@@ -0,0 +1,54 @@
+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.Set;
+import java.util.HashSet;
+
+@Setter
+@Getter
+@NodeEntity(label = "实验室检查名称")
+public class LisName extends BaseNode  {
+
+	@Property(name = "单位")
+	private String unit;
+
+	@Property(name = "最小值")
+	private Double minval;
+
+	@Property(name = "最大值")
+	private Double maxval;
+
+	@Property(name = "范围")
+	private Integer range;
+
+	@Relationship(type = "实验室检查名称相关实验室检查代码", direction = Relationship.OUTGOING)
+	private Set<LisCode> liscodes = new HashSet<>();
+
+	@Relationship(type = "实验室检查名称相关实验室检查别名", direction = Relationship.OUTGOING)
+	private Set<LisAlias> lisaliass = new HashSet<>();
+
+	@Relationship(type = "实验室检查名称相关实验室检查一级分类", direction = Relationship.OUTGOING)
+	private Set<LisFirstClass> lisfirstclasss = new HashSet<>();
+
+	@Relationship(type = "实验室检查名称相关实验室检查二级分类", direction = Relationship.OUTGOING)
+	private Set<LisSecondClass> lissecondclasss = new HashSet<>();
+
+	@Relationship(type = "实验室检查名称相关实验室检查套餐名", direction = Relationship.OUTGOING)
+	private Set<LisSet> lissets = new HashSet<>();
+
+	@Relationship(type = "实验室检查名称禁忌禁忌人群", direction = Relationship.OUTGOING)
+	private Set<Group> groups = new HashSet<>();
+
+	@Relationship(type = "实验室检查名称禁忌性别", direction = Relationship.OUTGOING)
+	private Gender gender;
+
+	@Relationship(type="实验室检查名称相关实验室检查危急值", direction = Relationship.OUTGOING)
+	private Set<LISCritical> liscritials = new HashSet<>();
+
+}

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

@@ -0,0 +1,22 @@
+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.Set;
+import java.util.HashSet;
+
+@Setter
+@Getter
+@NodeEntity(label = "实验室检查二级分类")
+public class LisSecondClass extends BaseNode  {
+
+
+	@Relationship(type = "实验室检查名称相关实验室检查二级分类", direction = Relationship.INCOMING)
+	private Set<LisName> lisnames = new HashSet<>();
+
+}

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

@@ -0,0 +1,36 @@
+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.Set;
+import java.util.HashSet;
+
+@Setter
+@Getter
+@NodeEntity(label = "实验室检查套餐名")
+public class LisSet extends BaseNode  {
+
+	@Property(name = "单位")
+	private String unit;
+
+	@Property(name = "最小值")
+	private Double minval;
+
+	@Property(name = "最大值")
+	private Double maxval;
+
+	@Property(name = "范围")
+	private Integer range;
+
+	@Relationship(type = "实验室检查套餐名禁忌性别", direction = Relationship.OUTGOING)
+	private Gender gender;
+
+	@Relationship(type = "实验室检查名称相关实验室检查套餐名", direction = Relationship.INCOMING)
+	private Set<LisName> lisnames = new HashSet<>();
+
+}

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

@@ -0,0 +1,34 @@
+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.Set;
+import java.util.HashSet;
+
+@Setter
+@Getter
+@NodeEntity(label = "药物过敏原")
+public class MedAllergen extends BaseNode  {
+
+
+	@Relationship(type = "辅助检查名称禁忌药物过敏原", direction = Relationship.INCOMING)
+	private Set<Pacs> pacss = new HashSet<>();
+
+	@Relationship(type = "医保手术和操作名称禁忌药物过敏原", direction = Relationship.INCOMING)
+	private Set<YiBaoOperationName> yibaooperationnames = new HashSet<>();
+
+	@Relationship(type = "辅助检查名称子项目名称禁忌药物过敏原", direction = Relationship.INCOMING)
+	private Set<PacsNameSubName> pacsnamesubnames = new HashSet<>();
+
+	@Relationship(type = "辅助检查子项目名称禁忌药物过敏原", direction = Relationship.INCOMING)
+	private Set<PacsSubName> pacssubnames = new HashSet<>();
+
+	@Relationship(type = "联合项目禁忌药物过敏原", direction = Relationship.INCOMING)
+	private Set<CombiOperation> combioperations = new HashSet<>();
+
+}

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

@@ -0,0 +1,22 @@
+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.Set;
+import java.util.HashSet;
+
+@Setter
+@Getter
+@NodeEntity(label = "药品化学物质类别")
+public class MedChemClass extends BaseNode  {
+
+
+	@Relationship(type = "药品相关药品化学物质类别", direction = Relationship.INCOMING)
+	private Set<MedCodeName> medcodenames = new HashSet<>();
+
+}

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

@@ -0,0 +1,22 @@
+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.Set;
+import java.util.HashSet;
+
+@Setter
+@Getter
+@NodeEntity(label = "药品类别")
+public class MedClass extends BaseNode  {
+
+
+	@Relationship(type = "药品相关药品类别", direction = Relationship.INCOMING)
+	private Set<MedCodeName> medcodenames = new HashSet<>();
+
+}

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

@@ -0,0 +1,22 @@
+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.Set;
+import java.util.HashSet;
+
+@Setter
+@Getter
+@NodeEntity(label = "药品代码")
+public class MedCode extends BaseNode  {
+
+
+	@Relationship(type = "药品相关药品代码", direction = Relationship.INCOMING)
+	private Set<MedCodeName> medcodenames = new HashSet<>();
+
+}

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

@@ -0,0 +1,97 @@
+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.Set;
+import java.util.HashSet;
+
+@Setter
+@Getter
+@NodeEntity(label = "药品代码通用名")
+public class MedCodeName extends BaseNode  {
+
+
+	@Property(name = "最小包装数量")
+	private Double min_pack_num;
+
+	@Property(name = "注册剂型")
+	private String reg_JiXin;
+
+	@Property(name = "药品本位码")
+	private String BenWei_Code;
+
+	@Property(name = "最小包装单位")
+	private String min_pack_unit;
+
+	@Property(name = "注册规格")
+	private String reg_GuiGe;
+
+	@Property(name = "包装材质")
+	private String pack_CaiLiao;
+
+	@Property(name = "药品企业")
+	private String producer;
+
+	@Property(name = "批准文号")
+	private String license_num ;
+
+	@Property(name = "最小制剂单位")
+	private String min_prod_unit;
+
+	@Relationship(type = "药品相关药品类别", direction = Relationship.OUTGOING)
+	private Set<MedClass> medclasss = new HashSet<>();
+
+	@Relationship(type = "药品相关药品注册名称", direction = Relationship.OUTGOING)
+	private Set<MedRegName> medregnames = new HashSet<>();
+
+	@Relationship(type = "药品相关药品通用名称", direction = Relationship.OUTGOING)
+	private Set<Medicine> medicines = new HashSet<>();
+
+	@Relationship(type = "药品相关药品化学物质类别", direction = Relationship.OUTGOING)
+	private Set<MedChemClass> medchemclass = new HashSet<>();
+
+	@Relationship(type = "药品相关药品药理学类别", direction = Relationship.OUTGOING)
+	private Set<MedYaoLiClass> medyaoliclass = new HashSet<>();
+
+	@Relationship(type = "药品相关药品治疗学类别", direction = Relationship.OUTGOING)
+	private Set<MedZhiLiaoClass> medzhiliaoclass = new HashSet<>();
+
+	@Relationship(type = "药品相关药品解剖学类别", direction = Relationship.OUTGOING)
+	private Set<MedJiePouClass> medjiepouclass = new HashSet<>();
+
+	@Relationship(type = "药品相关药品代码", direction = Relationship.OUTGOING)
+	private Set<MedCode> medcodes = new HashSet<>();
+
+	@Relationship(type = "药品相关药品商品名称", direction = Relationship.OUTGOING)
+	private Set<MedProdName> medprodnames = new HashSet<>();
+
+	@Relationship(type = "药品相关药品医保类别", direction = Relationship.OUTGOING)
+	private Set<MedYiBaoClass> medyibaoclass = new HashSet<>();
+
+	@Relationship(type = "药品相关注册名称", direction = Relationship.OUTGOING)
+	private Set<RegName> regnames = new HashSet<>();
+
+	@Relationship(type = "药品相关中成药方剂学大类", direction = Relationship.OUTGOING)
+	private Set<HerbFangJiCate> herbfangjicates = new HashSet<>();
+
+	@Relationship(type = "药品相关中成药方剂学类别", direction = Relationship.OUTGOING)
+	private Set<HerbFangJiClass> herbfangjiclass = new HashSet<>();
+
+	@Relationship(type = "药品相关中成药治疗学类别", direction = Relationship.OUTGOING)
+	private Set<HerbZhiLiaoClass> herbzhiliaoclass = new HashSet<>();
+
+	@Relationship(type = "药品相关中成药科室类别", direction = Relationship.OUTGOING)
+	private Set<HerbDeptClass> herbdeptclass = new HashSet<>();
+
+	@Relationship(type = "药品相关中成药医保类别", direction = Relationship.OUTGOING)
+	private Set<HerbYiBaoClass> herbyibaoclass = new HashSet<>();
+
+	@Relationship(type = "药品相关商品名称", direction = Relationship.OUTGOING)
+	private Set<ProdName> prodnames = new HashSet<>();
+
+}

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

@@ -0,0 +1,22 @@
+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.Set;
+import java.util.HashSet;
+
+@Setter
+@Getter
+@NodeEntity(label = "药品解剖学类别")
+public class MedJiePouClass extends BaseNode  {
+
+
+	@Relationship(type = "药品相关药品解剖学类别", direction = Relationship.INCOMING)
+	private Set<MedCodeName> medcodenames = new HashSet<>();
+
+}

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

@@ -0,0 +1,22 @@
+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.Set;
+import java.util.HashSet;
+
+@Setter
+@Getter
+@NodeEntity(label = "药品商品名称")
+public class MedProdName extends BaseNode  {
+
+
+	@Relationship(type = "药品相关药品商品名称", direction = Relationship.INCOMING)
+	private Set<MedCodeName> medcodenames = new HashSet<>();
+
+}

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

@@ -0,0 +1,22 @@
+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.Set;
+import java.util.HashSet;
+
+@Setter
+@Getter
+@NodeEntity(label = "药品注册名称")
+public class MedRegName extends BaseNode  {
+
+
+	@Relationship(type = "药品相关药品注册名称", direction = Relationship.INCOMING)
+	private Set<MedCodeName> medcodenames = new HashSet<>();
+
+}

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

@@ -0,0 +1,22 @@
+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.Set;
+import java.util.HashSet;
+
+@Setter
+@Getter
+@NodeEntity(label = "药品药理学类别")
+public class MedYaoLiClass extends BaseNode  {
+
+
+	@Relationship(type = "药品相关药品药理学类别", direction = Relationship.INCOMING)
+	private Set<MedCodeName> medcodenames = new HashSet<>();
+
+}

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

@@ -0,0 +1,22 @@
+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.Set;
+import java.util.HashSet;
+
+@Setter
+@Getter
+@NodeEntity(label = "药品医保类别")
+public class MedYiBaoClass extends BaseNode  {
+
+
+	@Relationship(type = "药品相关药品医保类别", direction = Relationship.INCOMING)
+	private Set<MedCodeName> medcodenames = new HashSet<>();
+
+}

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

@@ -0,0 +1,22 @@
+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.Set;
+import java.util.HashSet;
+
+@Setter
+@Getter
+@NodeEntity(label = "药品治疗学类别")
+public class MedZhiLiaoClass extends BaseNode  {
+
+
+	@Relationship(type = "药品相关药品治疗学类别", direction = Relationship.INCOMING)
+	private Set<MedCodeName> medcodenames = new HashSet<>();
+
+}

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

@@ -1,74 +1,24 @@
 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;
-
-}
+	@Property(name = "高危级别")
+	private String risklevel;
 
+	@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 +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.math.BigDecimal;
-import java.util.HashSet;
-import java.util.Set;
-
-@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<>();
-
-}
-
-
-
-
-

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

@@ -1,29 +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 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;
-
-}
-
-
-
-
-

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

@@ -7,13 +7,15 @@ import org.neo4j.ogm.annotation.NodeEntity;
 import org.neo4j.ogm.annotation.Relationship;
 
 import java.util.Set;
+import java.util.HashSet;
 
 @Setter
 @Getter
-//@EqualsAndHashCode(callSuper = false)
-@NodeEntity(label = "编码")
-public class Code extends BaseNode  {
+@NodeEntity(label = "辅助检查")
+public class Pacs extends BaseNode  {
 
-    @Relationship(type="疾病相关编码", direction = Relationship.INCOMING)
-    private Set<Disease> diseases;
-}
+
+	@Relationship(type = "辅助检查禁忌实验室检查", direction = Relationship.OUTGOING)
+	private Set<Lis> liss = new HashSet<>();
+
+}

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

@@ -0,0 +1,27 @@
+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 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/PacsNameSubName.java

@@ -0,0 +1,31 @@
+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.Set;
+import java.util.HashSet;
+
+@Setter
+@Getter
+@NodeEntity(label = "辅助检查名称子项目名称")
+public class PacsNameSubName extends BaseNode  {
+
+
+	@Relationship(type = "辅助检查名称子项目名称禁忌性别", direction = Relationship.OUTGOING)
+	private Set<Gender> genders = new HashSet<>();
+
+	@Relationship(type = "辅助检查名称子项目名称禁忌疾病", direction = Relationship.OUTGOING)
+	private Set<Disease> diseases = new HashSet<>();
+
+	@Relationship(type = "辅助检查名称子项目名称禁忌药物过敏原", direction = Relationship.OUTGOING)
+	private Set<MedAllergen> medallergens = new HashSet<>();
+
+	@Relationship(type = "辅助检查名称子项目名称禁忌禁忌人群", direction = Relationship.OUTGOING)
+	private Set<Group> groups = new HashSet<>();
+
+}

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

@@ -0,0 +1,31 @@
+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.Set;
+import java.util.HashSet;
+
+@Setter
+@Getter
+@NodeEntity(label = "辅助检查子项目名称")
+public class PacsSubName extends BaseNode  {
+
+
+	@Relationship(type = "辅助检查子项目名称禁忌药物过敏原", direction = Relationship.OUTGOING)
+	private Set<MedAllergen> medallergens = new HashSet<>();
+
+	@Relationship(type = "辅助检查子项目名称禁忌禁忌人群", direction = Relationship.OUTGOING)
+	private Set<Group> groups = new HashSet<>();
+
+	@Relationship(type = "辅助检查子项目名称禁忌疾病", direction = Relationship.OUTGOING)
+	private Set<Disease> diseases = new HashSet<>();
+
+	@Relationship(type = "辅助检查名称包含辅助检查子项目名称", direction = Relationship.INCOMING)
+	private Set<Pacs> pacss = 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/PathwayName.java

@@ -0,0 +1,21 @@
+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 PathwayName extends BaseNode  {
+
+
+	@Relationship(type = "医保疾病名称相关临床路径名称", direction = Relationship.INCOMING)
+	private Set<YiBaoDiseaseName> yiBaoDiseaseNames = new HashSet<>();
+
+}

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/ProdName.java

@@ -0,0 +1,22 @@
+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.Set;
+import java.util.HashSet;
+
+@Setter
+@Getter
+@NodeEntity(label = "商品名称")
+public class ProdName extends BaseNode  {
+
+
+	@Relationship(type = "药品相关商品名称", direction = Relationship.INCOMING)
+	private Set<MedCodeName> medcodenames = new HashSet<>();
+
+}

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

@@ -0,0 +1,22 @@
+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.Set;
+import java.util.HashSet;
+
+@Setter
+@Getter
+@NodeEntity(label = "注册名称")
+public class RegName extends BaseNode  {
+
+
+	@Relationship(type = "药品相关注册名称", direction = Relationship.INCOMING)
+	private Set<MedCodeName> medcodenames = new HashSet<>();
+
+}

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

@@ -7,38 +7,31 @@ 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;
+import java.util.HashSet;
 
 @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 String unit;
 
-    @Property(name = "范围")
-    private Integer range;
+	@Property(name = "最小值")
+	private Double minval;
 
-    @Relationship(type="疾病相关体征", direction = Relationship.INCOMING)
-    private Set<Disease> diseases;
+	@Property(name = "最大值")
+	private Double maxval;
 
-    @Relationship(type="实验室检查禁忌体征", direction = Relationship.INCOMING)
-    private Set<LIS> conflict_lis = new HashSet<>();
+	@Property(name = "范围")
+	private Integer range;
 
-    @Relationship(type="辅助检查禁忌体征", direction = Relationship.INCOMING)
-    private Set<PACS> conflict_pacs = new HashSet<>();
+	@Relationship(type = "辅助检查名称禁忌体征", direction = Relationship.INCOMING)
+	private Set<Pacs> pacss = new HashSet<>();
 
-//    @Relationship(type = "药品通用名禁忌体征", direction = Relationship.INCOMING)
-//    private Set<Medicine> conflict_mediciness = new HashSet<>();
+	@Relationship(type = "医保手术和操作名称禁忌体征", direction = Relationship.INCOMING)
+	private Set<YiBaoOperationName> yibaooperationnames = new HashSet<>();
 
-}
+}

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

@@ -0,0 +1,34 @@
+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.Set;
+import java.util.HashSet;
+
+@Setter
+@Getter
+@NodeEntity(label = "医保疾病名称")
+public class YiBaoDiseaseName extends BaseNode  {
+
+	@Property(name = "性别")
+	private String gender;
+
+	@Relationship(type = "医保疾病名称相关医保ICD-10代码", direction = Relationship.OUTGOING)
+	private Set<YiBaoICD_10Code> yibaoicd_10codes = new HashSet<>();
+
+	@Relationship(type = "医保疾病名称相关国临疾病名称", direction = Relationship.OUTGOING)
+	private Set<GuoLinDiseaseName> guolindiseasenames = new HashSet<>();
+
+	@Relationship(type = "医保疾病名称相关国临ICD-10代码", direction = Relationship.OUTGOING)
+	private Set<GuoLinICD_10Code> guolinicd_10codes = new HashSet<>();
+
+	@Relationship(type = "医保疾病名称相关临床路径名称", direction = Relationship.OUTGOING)
+	private Set<PathwayName> pathwaynames = new HashSet<>();
+
+
+}

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

@@ -0,0 +1,22 @@
+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.Set;
+import java.util.HashSet;
+
+@Setter
+@Getter
+@NodeEntity(label = "医保ICD_10代码")
+public class YiBaoICD_10Code extends BaseNode  {
+
+
+	@Relationship(type = "医保疾病名称相关医保ICD-10代码", direction = Relationship.INCOMING)
+	private Set<YiBaoDiseaseName> yibaodiseasenames = new HashSet<>();
+
+}

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

@@ -0,0 +1,22 @@
+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.Set;
+import java.util.HashSet;
+
+@Setter
+@Getter
+@NodeEntity(label = "医保ICD_9_CM3代码")
+public class YiBaoICD_9_CM3Code extends BaseNode  {
+
+
+	@Relationship(type = "医保手术和操作名称相关医保ICD-9-CM3代码", direction = Relationship.INCOMING)
+	private Set<YiBaoOperationName> yibaooperationnames = new HashSet<>();
+
+}

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

@@ -0,0 +1,22 @@
+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.Set;
+import java.util.HashSet;
+
+@Setter
+@Getter
+@NodeEntity(label = "医保手术和操作")
+public class YiBaoOperation extends BaseNode  {
+
+
+	@Relationship(type = "医保手术和操作禁忌实验室检查", direction = Relationship.OUTGOING)
+	private Set<Lis> liss = new HashSet<>();
+
+}

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

@@ -0,0 +1,60 @@
+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.Set;
+import java.util.HashSet;
+
+@Setter
+@Getter
+@NodeEntity(label = "医保手术和操作名称")
+public class YiBaoOperationName extends BaseNode  {
+
+	@Property(name = "高危级别")
+	private String risklevel;
+
+	@Relationship(type = "医保手术和操作名称相关国临ICD-9-CM3代码", direction = Relationship.OUTGOING)
+	private Set<GuoLinICD_9_CM3Code> guolinicd_9_cm3codes = new HashSet<>();
+
+	@Relationship(type = "医保手术和操作名称相关国临手术和操作名称", direction = Relationship.OUTGOING)
+	private Set<GuoLinOperationName> guolinoperationnames = new HashSet<>();
+
+	@Relationship(type = "医保手术和操作名称相关医保ICD-9-CM3代码", direction = Relationship.OUTGOING)
+	private Set<YiBaoICD_9_CM3Code> yibaoicd_9_cm3codes = 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> liss = new HashSet<>();
+
+	@Relationship(type = "医保手术和操作名称禁忌服用药品", direction = Relationship.OUTGOING)
+	private Set<OralMedicine> oralmeds = 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<PacsDescribe> pacsdescs = new HashSet<>();
+
+	@Relationship(type = "医保手术和操作名称禁忌药物过敏原", direction = Relationship.OUTGOING)
+	private Set<MedAllergen> medallergens = new HashSet<>();
+
+	@Relationship(type = "医保手术和操作名称禁忌禁忌医疗器械及物品", direction = Relationship.OUTGOING)
+	private Set<ConflictDevice> conflictdevices = 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/enums/StaticTypeEnum.java

@@ -1,6 +1,7 @@
 package com.diagbot.enums;
 
 import com.diagbot.core.KeyedNamed;
+import com.diagbot.repository.Constants;
 import lombok.Setter;
 
 /**
@@ -10,12 +11,12 @@ import lombok.Setter;
  */
 public enum StaticTypeEnum implements KeyedNamed {
 
-    DIS(1, "医保ICD_10疾病"),
-    DRUG(2, "药品通用名"),
-    LISMIX(3, "实验室检查套餐"),
-    LIS(4, "实验室检查"),
-    PACS(5, "辅助检查"),
-    OPT(6, "手术和操作");
+    DIS(1, Constants.yibaodisease),
+    DRUG(2, Constants.medicine),
+    LISSET(3, Constants.lissetname),
+    LIS(4, Constants.lisname),
+    PACS(5, Constants.pacsname),
+    OPT(6, Constants.yibaoopname);
 
     @Setter
     private int key;

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/facade/NeoFacade.java

@@ -9,27 +9,11 @@ import com.diagbot.dto.HighRiskNeoDTO;
 import com.diagbot.dto.NeoPushDTO;
 import com.diagbot.dto.StandConvertCrfBatchDTO;
 import com.diagbot.dto.StandConvertCrfDTO;
-import com.diagbot.entity.node.ICDDisease;
-import com.diagbot.entity.node.Medicine;
-import com.diagbot.entity.node.Medicine_Anatomy;
-import com.diagbot.entity.node.Medicine_Code;
+import com.diagbot.entity.node.*;
 import com.diagbot.enums.StandConvertEnum;
 import com.diagbot.exception.CommonErrorCode;
 import com.diagbot.exception.CommonException;
-import com.diagbot.repository.DiseaseRepository;
-import com.diagbot.repository.ICDDiseaseNode;
-import com.diagbot.repository.ICDDiseaseRepository;
-import com.diagbot.repository.LisNode;
-import com.diagbot.repository.LisPackNode;
-import com.diagbot.repository.LisPackRepository;
-import com.diagbot.repository.LisRepository;
-import com.diagbot.repository.MedicineCodeRepository;
-import com.diagbot.repository.MedicineNode;
-import com.diagbot.repository.MedicineRepository;
-import com.diagbot.repository.OperationNode;
-import com.diagbot.repository.OperationRepository;
-import com.diagbot.repository.PACSNode;
-import com.diagbot.repository.PacsRepository;
+import com.diagbot.repository.*;
 import com.diagbot.util.ListUtil;
 import com.diagbot.util.RedisUtil;
 import com.diagbot.util.StringUtil;
@@ -65,19 +49,21 @@ public class NeoFacade {
     @Autowired
     MedicineRepository medicineRepository;
     @Autowired
-    PacsRepository pacsRepository;
+    PacsNameRepository pacsNameRepository;
     @Autowired
-    LisRepository lisRepository;
+    LisNameRepository lisNameRepository;
     @Autowired
-    LisPackRepository lisPackRepository;
+    LisSetRepository lisSetRepository;
     @Autowired
-    DiseaseRepository diseaseRepository;
+    YiBaoDiseaseRepository yiBaodiseaseRepository;
     @Autowired
-    OperationRepository operationRepository;
+    YiBaoOperationNameRepository yiBaoOperationRepository;
     @Autowired
     MedicineCodeRepository medicineCodeRepository;
     @Autowired
-    ICDDiseaseRepository icdDiseaseRepository;
+    YiBaoDiseaseRepository yiBaoDiseaseRepository;
+    @Autowired
+    CombiOperationRepository combiOperationRepository;
     @Autowired
     ChiefPresentSimilarityServiceClient chiefPresentSimilarityServiceClient;
     @Autowired
@@ -101,24 +87,25 @@ public class NeoFacade {
         Iterator<Medicine> iterator = medicineRepository.findAll().iterator();
         Medicine current;
         String med_code, med_type;
-        List<Medicine_Code> medcodes;
-        List<Medicine_Anatomy> medcates;
+        List<MedCodeName> medcodename;
+        List<MedJiePouClass> medcates;
 
         while (iterator.hasNext()) {
             current = iterator.next();
-            if (null!=current.getMedicinecode_related_medicine() &&
-                    current.getMedicinecode_related_medicine().size() > 0) {
-                medcodes = new ArrayList<>(current.getMedicinecode_related_medicine());
-                for (Medicine_Code mcode : medcodes) {
-                    if (mcode.getMedicine_related_Anatomy().size()>0) {
+            if (null!=current.getMedcodenames() && current.getMedcodenames().size() > 0) {
+                medcodename = new ArrayList<>(current.getMedcodenames());
+                for (MedCodeName mcode : medcodename) {
+                    if (mcode.getMedjiepouclass().size()>0) {
                         med_code = mcode.getName();
-                        medcates = new ArrayList<>(mcode.getMedicine_related_Anatomy());
-                        med_type = medcates.get(0).getName();
-                        if (res.get(med_type) == null) {
-                            res.put(med_type, new ArrayList<>());
-                        }
-                        if (res.get(med_type).indexOf(med_code) == -1) {
-                            res.get(med_type).add(med_code);
+                        medcates = new ArrayList<>(mcode.getMedjiepouclass());
+                        if (ListUtil.isNotEmpty(medcates)) {
+                            med_type = medcates.get(0).getName();
+                            if (res.get(med_type) == null) {
+                                res.put(med_type, new ArrayList<>());
+                            }
+                            if (res.get(med_type).indexOf(med_code) == -1) {
+                                res.get(med_type).add(med_code);
+                            }
                         }
                     }
                 }
@@ -184,6 +171,7 @@ public class NeoFacade {
             billNeoDTOs.addAll(getLisDetailBill(billNeoVO.getLisDetailList()));
             billNeoDTOs.addAll(getLisBill(billNeoVO.getLisList()));
             billNeoDTOs.addAll(getOperationBill(billNeoVO.getOperationList()));
+            billNeoDTOs.addAll(getCombiOpBill(billNeoVO.getCombiopList()));
         }
         catch (Exception ex) {
             ex.printStackTrace();
@@ -225,8 +213,8 @@ public class NeoFacade {
      */
     public List<BillNeoDTO> getDrugBill(Map<String, String> medsterm) {
 
-        MedicineNode medicineNode = new MedicineNode();
-        List<BillNeoDTO> billNeoDTOs = medicineNode.getDrugBill(medsterm, medicineRepository);
+        MedicineCodeNode medicineNode = new MedicineCodeNode();
+        List<BillNeoDTO> billNeoDTOs = medicineNode.getDrugBill(medsterm, medicineCodeRepository);
 
         return billNeoDTOs;
     }
@@ -237,8 +225,8 @@ public class NeoFacade {
      */
     public List<BillNeoDTO> getPacsBill(Map<String, String> pacsterm) {
 
-        PACSNode pacsNode = new PACSNode();
-        List<BillNeoDTO> billNeoDTOs = pacsNode.getPacsBill(pacsterm, pacsRepository);
+        PacsNameNode pacsNode = new PacsNameNode();
+        List<BillNeoDTO> billNeoDTOs = pacsNode.getPacsBill(pacsterm, pacsNameRepository);
 
         return billNeoDTOs;
     }
@@ -247,10 +235,10 @@ public class NeoFacade {
     /**
      * 处理化验套餐开单合理性
      */
-    public List<BillNeoDTO> getLisBill(Map<String, String> lispackterm) {
+    public List<BillNeoDTO> getLisBill(Map<String, String> lissetterm) {
 
-        LisPackNode lisPackNode = new LisPackNode();
-        List<BillNeoDTO> billNeoDTOs = lisPackNode.getLisBill(lispackterm, lisPackRepository);
+        LisSetNode lisSetNode = new LisSetNode();
+        List<BillNeoDTO> billNeoDTOs = lisSetNode.getLisBill(lissetterm, lisSetRepository);
 
         return billNeoDTOs;
     }
@@ -261,8 +249,8 @@ public class NeoFacade {
      */
     public List<BillNeoDTO> getLisDetailBill(Map<String, String> listerm) {
 
-        LisNode lisNode = new LisNode();
-        List<BillNeoDTO> billNeoDTOs = lisNode.getLisDetailBill(listerm, lisRepository);
+        LisNameNode lisNode = new LisNameNode();
+        List<BillNeoDTO> billNeoDTOs = lisNode.getLisDetailBill(listerm, lisNameRepository);
 
         return billNeoDTOs;
     }
@@ -270,17 +258,29 @@ public class NeoFacade {
 
 
     /**
-     * 处理化验开单合理性
+     * 处理手术开单合理性
      */
     public List<BillNeoDTO> getOperationBill(Map<String, String> listerm) {
 
-        OperationNode opNode = new OperationNode();
-        List<BillNeoDTO> billNeoDTOs = opNode.getOperationBill(listerm, operationRepository);
+        YiBaoOperationNameNode yiBaoOpNode = new YiBaoOperationNameNode();
+        List<BillNeoDTO> billNeoDTOs = yiBaoOpNode.getOperationBill(listerm, yiBaoOperationRepository);
 
         return billNeoDTOs;
     }
 
 
+    /**
+     * 处理联合项目开单合理性
+     */
+    public List<BillNeoDTO> getCombiOpBill(Map<String, String> combiterm) {
+
+        CombiOperationNode combiNode = new CombiOperationNode();
+        List<BillNeoDTO> billNeoDTOS = combiNode.getCombiOpBill(combiterm, combiOperationRepository);
+
+        return billNeoDTOS;
+    }
+
+
     /**
      * 推送疾病信息
      *
@@ -292,18 +292,18 @@ public class NeoFacade {
         List<NeoPushDTO> neoPushDTOs = new ArrayList<>();
         NeoPushDTO pushDTO;
 
-        ICDDiseaseNode icdDiseaseNode = new ICDDiseaseNode();
+        YiBaoDiseaseNode icdDiseaseNode = new YiBaoDiseaseNode();
         String term;
 
         for (Diag diag : neoPushVO.getDiagVo().getDiags()) {
             term = diag.getName();
-            List<ICDDisease> byNameIs = icdDiseaseRepository.findByNameIs(term);
-            ICDDisease icdDisease = null;
-            if(ListUtil.isNotEmpty(byNameIs)){
-                icdDisease = icdDiseaseRepository.findByNameIs(term).get(0);
+            List<YiBaoDiseaseName> yiBaoName = yiBaoDiseaseRepository.findByNameIs(term);
+            YiBaoDiseaseName icdDisease = null;
+            if(ListUtil.isNotEmpty(yiBaoName)){
+                icdDisease = yiBaoName.get(0);
             }
             if (icdDisease != null) {
-                pushDTO = icdDiseaseNode.ICDDiseasetoPushDTO(icdDisease, neoPushVO);
+                pushDTO = icdDiseaseNode.YiBaoDiseasetoDiseaseDTO(icdDisease, neoPushVO);
 
                 if (null != pushDTO) {
                     neoPushDTOs.add(pushDTO);
@@ -320,8 +320,8 @@ public class NeoFacade {
      */
     public List<CriticalNeoDTO> getLisCritical(CriticalNeoVO criticalNeoVO) {
 
-        LisNode lisNode = new LisNode();
-        List<CriticalNeoDTO> criticalNeoDTOs = lisNode.getLisCritialList(criticalNeoVO, lisRepository);
+        LisNameNode lisNode = new LisNameNode();
+        List<CriticalNeoDTO> criticalNeoDTOs = lisNode.getLisCritialList(criticalNeoVO, lisNameRepository);
 
         return criticalNeoDTOs;
     }
@@ -347,8 +347,8 @@ public class NeoFacade {
      * @return
      */
     public List<HighRiskNeoDTO> getHighRiskOperationList(Map<String, String> operations) {
-        OperationNode operationNode = new OperationNode();
-        List<HighRiskNeoDTO> highRiskNeoDTOS = operationNode.getHighRiskOperation(operations, operationRepository);
+        YiBaoOperationNameNode yiBaoOperationNode = new YiBaoOperationNameNode();
+        List<HighRiskNeoDTO> highRiskNeoDTOS = yiBaoOperationNode.getHighRiskOperation(operations, yiBaoOperationRepository);
 
         return highRiskNeoDTOS;
     }

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

@@ -5,27 +5,9 @@ import com.diagbot.dto.LisDetailDTO;
 import com.diagbot.dto.OperationInfoDTO;
 import com.diagbot.dto.RetrievalDTO;
 import com.diagbot.dto.StaticKnowledgeIndexDTO;
-import com.diagbot.entity.node.ICDDisease;
-import com.diagbot.entity.node.LIS;
-import com.diagbot.entity.node.LISPack;
-import com.diagbot.entity.node.Medicine;
-import com.diagbot.entity.node.Operation;
-import com.diagbot.entity.node.PACS;
+import com.diagbot.entity.node.*;
 import com.diagbot.enums.StaticTypeEnum;
-import com.diagbot.repository.DeptNode;
-import com.diagbot.repository.DeptRepository;
-import com.diagbot.repository.ICDDiseaseNode;
-import com.diagbot.repository.ICDDiseaseRepository;
-import com.diagbot.repository.LisNode;
-import com.diagbot.repository.LisPackNode;
-import com.diagbot.repository.LisPackRepository;
-import com.diagbot.repository.LisRepository;
-import com.diagbot.repository.MedicineNode;
-import com.diagbot.repository.MedicineRepository;
-import com.diagbot.repository.OperationNode;
-import com.diagbot.repository.OperationRepository;
-import com.diagbot.repository.PACSNode;
-import com.diagbot.repository.PacsRepository;
+import com.diagbot.repository.*;
 import com.diagbot.util.ListUtil;
 import com.diagbot.vo.RetrievalVO;
 import com.diagbot.vo.StaticKnowledgeIndexVO;
@@ -44,25 +26,23 @@ import java.util.List;
 public class RetrievalFacade {
 
     @Autowired
-    LisPackRepository lisPackRepository;
+    LisSetRepository lisSetRepository;
 
     @Autowired
-    LisRepository lisRepository;
+    LisNameRepository lisRepository;
 
     @Autowired
-    ICDDiseaseRepository icdDiseaseRepository;
+    YiBaoDiseaseRepository icdDiseaseRepository;
 
     @Autowired
-    PacsRepository pacsRepository;
+    PacsNameRepository pacsRepository;
 
     @Autowired
     MedicineRepository medicineRepository;
 
     @Autowired
-    OperationRepository operationRepository;
+    YiBaoOperationNameRepository operationRepository;
 
-    @Autowired
-    DeptRepository deptRepository;
 
     /**
      * 检索
@@ -110,8 +90,8 @@ public class RetrievalFacade {
      */
     public List<String> getLisPacks(String name) {
 
-        LisPackNode lisPackNode = new LisPackNode();
-        List<String> lisPacklist = lisPackNode.getLISPackNameList(name, lisPackRepository);
+        LisSetNode lisPackNode = new LisSetNode();
+        List<String> lisPacklist = lisPackNode.getLISPackNameList(name, lisSetRepository);
 
         return lisPacklist;
     }
@@ -122,7 +102,7 @@ public class RetrievalFacade {
      */
     public List<LisDetailDTO> getLis(String name) {
 
-        LisNode lisNode = new LisNode();
+        LisNameNode lisNode = new LisNameNode();
         List<LisDetailDTO> lislist = lisNode.getLisDetailList(name, lisRepository);
 
         return lislist;
@@ -134,7 +114,7 @@ public class RetrievalFacade {
      */
     public List<String> getPACSs(String name) {
 
-        PACSNode pacsNode = new PACSNode();
+        PacsNameNode pacsNode = new PacsNameNode();
         List<String> pacslist = pacsNode.getPACSNameList(name, pacsRepository);
 
         return pacslist;
@@ -146,8 +126,8 @@ public class RetrievalFacade {
      */
     public List<String> getDiseases(String name) {
 
-        ICDDiseaseNode diseaseNode = new ICDDiseaseNode();
-        List<String> diseaselist = diseaseNode.getDiseaseNameList(name, icdDiseaseRepository);
+        YiBaoDiseaseNode yiBaoDiseaseNode = new YiBaoDiseaseNode();
+        List<String> diseaselist = yiBaoDiseaseNode.getDiseaseNameList(name, icdDiseaseRepository);
 
         return diseaselist;
     }
@@ -170,7 +150,7 @@ public class RetrievalFacade {
      */
     public List<OperationInfoDTO> getOperations(String name) {
 
-        OperationNode operationNode = new OperationNode();
+        YiBaoOperationNameNode operationNode = new YiBaoOperationNameNode();
         List<OperationInfoDTO> opslist = operationNode.getOperationList(name, operationRepository);
 
         return opslist;
@@ -179,7 +159,7 @@ public class RetrievalFacade {
 
     /*
      * 获取科室名称列表
-     */
+     *
     public List<String> getDepts(String name) {
 
         DeptNode deptNode = new DeptNode();
@@ -198,15 +178,11 @@ public class RetrievalFacade {
         List<StaticKnowledgeIndexDTO> retList = Lists.newLinkedList();
         String inputStr = staticKnowledgeIndexVO.getInputStr();
         List<Integer> types = staticKnowledgeIndexVO.getTypes();
-        List<ICDDisease> icdDiseaseList = icdDiseaseRepository.findByNameLike("*" + inputStr + "*");
-        List<Medicine> medicineList = medicineRepository.findByNameLike("*" + inputStr + "*");
-        List<LISPack> lisPackList = lisPackRepository.findByNameLike("*" + inputStr + "*");
-        List<LIS> lisList = lisRepository.findByNameLike("*" + inputStr + "*");
-        List<PACS> pacsList = pacsRepository.findByNameLike("*" + inputStr + "*");
-        List<Operation> operationList = operationRepository.findByNameLike("*" + inputStr + "*");
+
         //TODO 诊断
+        List<YiBaoDiseaseName> icdDiseaseList = icdDiseaseRepository.findByNameContaining(inputStr);
         List<StaticKnowledgeIndexDTO> disRetList = Lists.newLinkedList();
-        for (ICDDisease icdDisease : icdDiseaseList) {
+        for (YiBaoDiseaseName icdDisease : icdDiseaseList) {
             StaticKnowledgeIndexDTO staticDTO = new StaticKnowledgeIndexDTO();
             staticDTO.setName(icdDisease.getName());
             staticDTO.setType(StaticTypeEnum.DIS.getKey());
@@ -214,6 +190,8 @@ public class RetrievalFacade {
             disRetList.add(staticDTO);
         }
         //TODO 药品
+        List<Medicine> medicineList = medicineRepository.findByNameContaining(inputStr);
+
         List<StaticKnowledgeIndexDTO> drugRetList = Lists.newLinkedList();
         for (Medicine medicine : medicineList) {
             StaticKnowledgeIndexDTO staticDTO = new StaticKnowledgeIndexDTO();
@@ -223,31 +201,37 @@ public class RetrievalFacade {
             drugRetList.add(staticDTO);
         }
         //TODO 检验套餐
-        List<StaticKnowledgeIndexDTO> lisPackRetList = Lists.newLinkedList();
-        for (LISPack lisPack : lisPackList) {
+        List<LisSet> lisSetList = lisSetRepository.findByNameContaining(inputStr);
+
+        List<StaticKnowledgeIndexDTO> lisSetRetList = Lists.newLinkedList();
+        for (LisSet lisSet : lisSetList) {
             StaticKnowledgeIndexDTO staticDTO = new StaticKnowledgeIndexDTO();
-            staticDTO.setName(lisPack.getName());
-            staticDTO.setType(StaticTypeEnum.LISMIX.getKey());
-            staticDTO.setTypeName(StaticTypeEnum.LISMIX.getName());
-            lisPackRetList.add(staticDTO);
+            staticDTO.setName(lisSet.getName());
+            staticDTO.setType(StaticTypeEnum.LISSET.getKey());
+            staticDTO.setTypeName(StaticTypeEnum.LISSET.getName());
+            lisSetRetList.add(staticDTO);
         }
         //TODO 检验明细关联出检验套餐
-        List<StaticKnowledgeIndexDTO> lisPackRelatecLisRetList = Lists.newLinkedList();
-        for (LIS lis : lisList) {
-            if (lis.getLisPacks_related_lis().size() > 0) {
-                for (LISPack lisPack : lis.getLisPacks_related_lis()) {
+        List<LisName> lisList = lisRepository.findByNameContaining(inputStr);
+
+        List<StaticKnowledgeIndexDTO> lisSetRelatecLisRetList = Lists.newLinkedList();
+        for (LisName lis : lisList) {
+            if (lis.getLissets().size() > 0) {
+                for (LisSet lisSet : lis.getLissets()) {
                     StaticKnowledgeIndexDTO staticDTO = new StaticKnowledgeIndexDTO();
                     staticDTO.setRetrievalName(lis.getName());
-                    staticDTO.setName(lisPack.getName());
-                    staticDTO.setType(StaticTypeEnum.LISMIX.getKey());
-                    staticDTO.setTypeName(StaticTypeEnum.LISMIX.getName());
-                    lisPackRelatecLisRetList.add(staticDTO);
+                    staticDTO.setName(lisSet.getName());
+                    staticDTO.setType(StaticTypeEnum.LISSET.getKey());
+                    staticDTO.setTypeName(StaticTypeEnum.LISSET.getName());
+                    lisSetRelatecLisRetList.add(staticDTO);
                 }
             }
         }
         //TODO 检验明细
+        lisList = lisRepository.findByNameContaining(inputStr);
+
         List<StaticKnowledgeIndexDTO> lisRetList = Lists.newLinkedList();
-        for (LIS lis : lisList) {
+        for (LisName lis : lisList) {
             StaticKnowledgeIndexDTO staticDTO = new StaticKnowledgeIndexDTO();
             staticDTO.setName(lis.getName());
             staticDTO.setType(StaticTypeEnum.LIS.getKey());
@@ -255,29 +239,37 @@ public class RetrievalFacade {
             lisRetList.add(staticDTO);
         }
         //TODO 检查
+        List<PacsName> pacsList = pacsRepository.findByNameContaining(inputStr);
+
         List<StaticKnowledgeIndexDTO> pacsRetList = Lists.newLinkedList();
-        for (PACS pacs : pacsList) {
+        for (PacsName pacs : pacsList) {
             StaticKnowledgeIndexDTO staticDTO = new StaticKnowledgeIndexDTO();
             staticDTO.setName(pacs.getName());
             staticDTO.setType(StaticTypeEnum.PACS.getKey());
             staticDTO.setTypeName(StaticTypeEnum.PACS.getName());
             pacsRetList.add(staticDTO);
         }
+
+
         //TODO 手术和操作
+        List<YiBaoOperationName> operationList = operationRepository.findByNameContaining(inputStr);
+
         List<StaticKnowledgeIndexDTO> operationRetList = Lists.newLinkedList();
-        for (Operation operation : operationList) {
+
+        for (YiBaoOperationName operation : operationList) {
             StaticKnowledgeIndexDTO staticDTO = new StaticKnowledgeIndexDTO();
             staticDTO.setName(operation.getName());
             staticDTO.setType(StaticTypeEnum.OPT.getKey());
             staticDTO.setTypeName(StaticTypeEnum.OPT.getName());
             operationRetList.add(staticDTO);
         }
+
         //0-全部、1-诊断、2-药品、3-检验套餐、4-检验明细、5-检查、6-手术和操作
         if (ListUtil.isEmpty(types) || types.contains(0)) {
             retList.addAll(disRetList);
             retList.addAll(drugRetList);
-            retList.addAll(lisPackRetList);
-            retList.addAll(lisPackRelatecLisRetList);
+            retList.addAll(lisSetRetList);
+            retList.addAll(lisSetRelatecLisRetList);
             retList.addAll(lisRetList);
             retList.addAll(pacsRetList);
             retList.addAll(operationRetList);
@@ -290,9 +282,9 @@ public class RetrievalFacade {
             }
             if (types.contains(3)) {
                 //检索的套餐
-                retList.addAll(lisPackRetList);
+                retList.addAll(lisSetRetList);
                 //明细关联出的套餐
-                retList.addAll(lisPackRelatecLisRetList);
+                retList.addAll(lisSetRelatecLisRetList);
                 //明细
                 retList.addAll(lisRetList);
             }

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

@@ -53,7 +53,7 @@ public class TestFacade {
             indicationPushVO.setIdNum(bean.getIdNum());
             if (StringUtil.isNotBlank(bean.getOrderType())) {
                 switch (bean.getOrderType()) {
-                    case "实验室检查" : // 细项
+                    case "实验室检查名称" : // 细项
                         List<Lis> lisDetailOrder = new ArrayList<>();
                         Lis lisDetailBean = new Lis();
                         lisDetailBean.setName(bean.getStandName());
@@ -62,7 +62,7 @@ public class TestFacade {
                         lisDetailOrder.add(lisDetailBean);
                         indicationPushVO.setLisOrder(lisDetailOrder);
                         break;
-                    case "辅助检查" :
+                    case "辅助检查名称" :
                         List<Pacs> pacsOrder = new ArrayList<>();
                         Pacs pacsBean = new Pacs();
                         pacsBean.setName(bean.getStandName());
@@ -70,7 +70,7 @@ public class TestFacade {
                         pacsOrder.add(pacsBean);
                         indicationPushVO.setPacsOrder(pacsOrder);
                         break;
-                    case "实验室检查套餐" :
+                    case "实验室检查套餐名" :
                         List<Lis> lisOrder = new ArrayList<>();
                         Lis lisBean = new Lis();
                         lisBean.setName(bean.getStandName());
@@ -78,7 +78,7 @@ public class TestFacade {
                         lisOrder.add(lisBean);
                         indicationPushVO.setLisOrder(lisOrder);
                         break;
-                    case "手术和操作" :
+                    case "医保手术和操作名称" :
                         List<Item> operationOrder = new ArrayList<>();
                         Item operationItem = new Item();
                         operationItem.setName(bean.getStandName());
@@ -100,7 +100,7 @@ public class TestFacade {
                     //         indicationPushVO.setSex(2);
                     //     }
                     //     break;
-                    // case "2" : // 化验, 示例：血小板计数，＜，50，*10~9L
+                    // case "2" : // 化验, 示例：血小板计数，＜，50，10^9/L
                     //     String lisStr = bean.getNeoName();
                     //     String[] lisArr = lisStr.split("，");
                     //

src/main/java/com/diagbot/process/BillProcess.java

@@ -14,6 +14,7 @@ import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;
 
 import java.util.ArrayList;
+import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.stream.Collectors;
@@ -109,7 +110,7 @@ public class BillProcess {
     // 规则处理
     public void processRule(List<BillNeoMaxDTO> billNeoMaxDTOList, WordCrfDTO wordCrfDTO, IndicationDTO indicationDTO) {
         // 获取药品缓存
-        Map<String, List<String>> drugMap = neoFacade.getDrugCache();
+        Map<String, List<String>> drugMap = new LinkedHashMap<>();
         DiagLabel diagLabel = wordCrfDTO.getDiagLabel();
         ChiefLabel chiefLabel = wordCrfDTO.getChiefLabel();
         PresentLabel presentLabel = wordCrfDTO.getPresentLabel();

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

@@ -0,0 +1,111 @@
+package com.diagbot.repository;
+
+import com.diagbot.dto.BillNeoDTO;
+import com.diagbot.dto.CombiOpBillNeoDTO;
+import com.diagbot.entity.node.*;
+import com.diagbot.util.ListUtil;
+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(Constants.gender);
+			combiOpBillNeoDTO.setGender(NeoUtil.updateNodeInfo(nodeInfo));
+		}
+
+
+		Set<Group> groups = combiOp.getGroups();
+		for (Group group : groups) {
+			nodeInfo = new NodeInfo();
+			nodeInfo.setName(group.getName());
+			nodeInfo.setTypeval(Constants.group);
+			combiOpBillNeoDTO.getGroup().add(NeoUtil.updateNodeInfo(nodeInfo));
+		}
+
+
+		Set<Lis> lislist = combiOp.getLiss();
+		for (Lis lis : lislist) {
+			nodeInfo = new NodeInfo();
+			nodeInfo.setName(lis.getName());
+			nodeInfo.setTypeval(Constants.lis);
+			combiOpBillNeoDTO.getGroup().add(NeoUtil.updateNodeInfo(nodeInfo));
+		}
+
+
+		Set<PacsDescribe> pacsDescribes = combiOp.getPacsdescs();
+		for (PacsDescribe pacsdesc : pacsDescribes) {
+			nodeInfo = new NodeInfo();
+			nodeInfo.setName(pacsdesc.getName());
+			nodeInfo.setTypeval(Constants.pacsdesc);
+			combiOpBillNeoDTO.getGroup().add(NeoUtil.updateNodeInfo(nodeInfo));
+		}
+
+
+		Set<Disease> diseases = combiOp.getDiseases();
+		for (Disease dis : diseases) {
+			nodeInfo = new NodeInfo();
+			nodeInfo.setName(dis.getName());
+			nodeInfo.setTypeval(Constants.disease);
+			combiOpBillNeoDTO.getGroup().add(NeoUtil.updateNodeInfo(nodeInfo));
+		}
+
+
+		Set<MedAllergen> medAllergens = combiOp.getMedallergens();
+		for (MedAllergen medallergen : medAllergens) {
+			nodeInfo = new NodeInfo();
+			nodeInfo.setName(medallergen.getName());
+			nodeInfo.setTypeval(Constants.medallergen);
+			combiOpBillNeoDTO.getGroup().add(NeoUtil.updateNodeInfo(nodeInfo));
+		}
+
+
+
+		return combiOpBillNeoDTO;
+	}
+
+
+	/**
+	 * 获取联合项目开单合理性
+	 */
+	public List<BillNeoDTO> getCombiOpBill(Map<String, String> combiterm, CombiOperationRepository combiRepository) {
+
+		List<BillNeoDTO> billNeoDTOs = new ArrayList<>();
+		BillNeoDTO billNeoDTO;
+
+		CombiOpBillNeoDTO combiOpBillNeoDTO;
+
+		List<CombiOperation> oplist;
+		String opname;
+
+		for (String term : combiterm.keySet()) {
+			billNeoDTO = new BillNeoDTO();
+			opname = combiterm.get(term);
+			billNeoDTO.setName(term);
+			billNeoDTO.setStandname(opname);
+
+			oplist = combiRepository.findByNameIs(opname);
+
+			if (ListUtil.isNotEmpty(oplist)) {
+				combiOpBillNeoDTO = CombiOptoCombiOpDTO(oplist.get(0));
+
+				billNeoDTO.setCombiOpBillNeoDTO(combiOpBillNeoDTO);
+
+				billNeoDTOs.add(billNeoDTO);
+			}
+		}
+
+		return billNeoDTOs;
+	}
+}
+

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> findByNameContaining(String name);
+
+    List<CombiOperation> findByNameIs(String name);
+}
+

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

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

@@ -1,172 +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.*;
-
-public class DiseaseNode {
-
-	public PushDTO DiseasetoDiseaseDTO(Disease disease) {
-
-        PushDTO pushDTO = new PushDTO();
-
-		/*
-		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;
-	}
-
-}
-

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/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;
@@ -22,11 +21,11 @@ public class LisNode {
 		if (null!=gender) {
 			nodeInfo = new NodeInfo();
 			nodeInfo.setName(gender.getName());
-			nodeInfo.setTypeval("性别");
+			nodeInfo.setTypeval(Constants.gender);
 			lisBillNeoDTO.setGender(NeoUtil.updateNodeInfo(nodeInfo));
 		}
 
-
+/*
 		Age age = lis.getAge();
 		if (null!=age) {
 			NodeNeoDTO ageNeoDTO = new NodeNeoDTO();
@@ -107,11 +106,12 @@ public class LisNode {
 
 			lisBillNeoDTO.getDisease().add(NeoUtil.updateNodeInfo(nodeInfo));
 		}
-
+*/
 		Set<Group> groups = lis.getGroups();
 		for (Group group : groups) {
 			nodeInfo = new NodeInfo();
 			nodeInfo.setName(group.getName());
+			nodeInfo.setTypeval(Constants.group);
 
 			lisBillNeoDTO.getGroup().add(NeoUtil.updateNodeInfo(nodeInfo));
 		}
@@ -124,13 +124,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 +160,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.findByNameContaining(name);
 
-		for (LIS lis: lislt) {
+		for (LisName lis: lislt) {
 			lisDetailDTO = new LisDetailDTO();
 			nodename = lis.getName();
 			lisDetailDTO.setUniqueName(nodename);
@@ -185,13 +185,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 +210,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,16 +227,16 @@ 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());
+						List<LISCritical> lisCriticals = new ArrayList<>(lis.getLiscritials());
 
 						for (LISCritical lisCritical : lisCriticals) {
 							agemin = 0;
@@ -264,6 +264,7 @@ public class LisNode {
 								lislist.add(criticalNeoDTO);
 							}
 						}
+
 					}
 				}
 			}
@@ -279,15 +280,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 +317,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> findByNameContaining(String name);
 
     @Query("MATCH (n:实验室检查) RETURN DISTINCT(KEYS(n))")
     List<List<String>> getKeys();

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

@@ -7,26 +7,25 @@ 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());
-			nodeInfo.setTypeval("性别");
+			nodeInfo.setTypeval(Constants.gender);
 			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.findByNameContaining(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> findByNameContaining(String name);
 
     @Query("MATCH (n:实验室检查套餐) RETURN DISTINCT(KEYS(n))")
     List<List<String>> getKeys();