开单合理项维护

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

@@ -8,26 +8,15 @@ import com.diagbot.entity.node.BillItem;
 import com.diagbot.entity.node.ClinicalFinding;
 import com.diagbot.entity.node.Group;
 import com.diagbot.entity.node.Lis;
+import com.diagbot.entity.node.LisSet;
+import com.diagbot.entity.node.MedRegName;
 import com.diagbot.entity.node.PacsName;
+import com.diagbot.entity.node.PacsSubName;
 import com.diagbot.entity.node.Vital;
+import com.diagbot.entity.node.YiBaoOperationName;
 import com.diagbot.exception.CommonErrorCode;
 import com.diagbot.exception.CommonException;
-import com.diagbot.repository.AgeRepository;
-import com.diagbot.repository.AllergenRepository;
-import com.diagbot.repository.BillConflictItemRepository;
-import com.diagbot.repository.BillManRepository;
-import com.diagbot.repository.ClinicalFindingRepository;
-import com.diagbot.repository.ConflictDeviceRepository;
-import com.diagbot.repository.DiseaseRepository;
-import com.diagbot.repository.GenderRepository;
-import com.diagbot.repository.GroupRepository;
-import com.diagbot.repository.LisRepository;
-import com.diagbot.repository.MedAllergenRepository;
-import com.diagbot.repository.OralMedicineRepository;
-import com.diagbot.repository.PacsDescribeRepository;
-import com.diagbot.repository.PacsNameNode;
-import com.diagbot.repository.PacsNameRepository;
-import com.diagbot.repository.VitalRepository;
+import com.diagbot.repository.*;
 import com.diagbot.util.Cn2SpellUtil;
 import com.diagbot.util.EntityUtil;
 import com.diagbot.util.ListUtil;
@@ -58,8 +47,29 @@ public class BillManFacade {
     BillManRepository billManRepository;
     @Autowired
     DictionaryFacade dictionaryFacade;
+
     @Autowired
     PacsNameRepository pacsNameRepository;
+    @Autowired
+    PacsSubNameRepository pacsSubNameRepository;
+    @Autowired
+    LisSetRepository lisSetRepository;
+    @Autowired
+    YiBaoOperationNameRepository yiBaoOperationNameRepository;
+    @Autowired
+    MedRegNameRepository medRegNameRepository;
+
+    @Autowired
+    PacsNameNode pacsNameNode;
+    @Autowired
+    PacsSubNameNode pacsSubNameNode;
+    @Autowired
+    MedRegNameNode medRegNameNode;
+    @Autowired
+    LisSetNode lisSetNode;
+    @Autowired
+    YiBaoOperationNameNode yiBaoOperationNameNode;
+
 
     @Autowired
     MedAllergenRepository medAllergenRepository;
@@ -340,7 +350,7 @@ public class BillManFacade {
                 case "手术":
                     break;
                 case "禁忌人群":
-                    Group group = groupRepository.createOrUpdate(conditionName,
+                    Group group=groupRepository.createOrUpdate(conditionName,
                             0,
                             Cn2SpellUtil.converterToFirstSpell(conditionName),
                             1,
@@ -366,7 +376,7 @@ public class BillManFacade {
                 case "禁忌医疗器械及物品":
                     break;
                 case "年龄":
-                    Age age = ageRepository.createOrUpdate(conditionName,
+                    Age age=ageRepository.createOrUpdate(conditionName,
                             0,
                             Cn2SpellUtil.converterToFirstSpell(conditionName),
                             1,
@@ -383,22 +393,31 @@ public class BillManFacade {
             }
         }
 
-
         //保存关系
         switch (concept.getConceptLabel()) {
-            case "实验室检查名称":
+            case "实验室检查套餐名":
+                LisSet lisSet = lisSetRepository.findByNameIs(concept.getName()).get(0);
+                lisSetNode.updateRelationExt(lisSet, relationType, 1, billSaveVO.getRuleType(), conditionName, lisSetRepository);
                 break;
             case "辅助检查名称":
                 PacsName pacsName = pacsNameRepository.findByNameIs(concept.getName()).get(0);
-                PacsNameNode pacsNameNode = new PacsNameNode();
                 pacsNameNode.updateRelationExt(pacsName, relationType, 1, billSaveVO.getRuleType(), conditionName, pacsNameRepository);
                 break;
+            case "辅助检查子项目名称":
+                PacsSubName pacsSubName = pacsSubNameRepository.findByNameIs(concept.getName()).get(0);
+                pacsSubNameNode.updateRelationExt(pacsSubName, relationType, 1, billSaveVO.getRuleType(), conditionName, pacsSubNameRepository);
+                break;
+            case "医保手术和操作名称":
+                YiBaoOperationName yiBaoOperationName = yiBaoOperationNameRepository.findByNameIs(concept.getName()).get(0);
+                yiBaoOperationNameNode.updateRelationExt(yiBaoOperationName, relationType, 1, billSaveVO.getRuleType(), conditionName, yiBaoOperationNameRepository);
+                break;
+            case "药品注册名称":
+                MedRegName medRegName = medRegNameRepository.findByNameIs(concept.getName()).get(0);
+                medRegNameNode.updateRelationExt(medRegName, relationType, 1, billSaveVO.getRuleType(), conditionName, medRegNameRepository);
+                break;
             default:
                 break;
         }
-
         return true;
     }
-
-
 }

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

@@ -33,15 +33,15 @@ public interface AgeRepository extends Neo4jRepository<Age,Long> {
             "n.最小值={minValue}," +
             "n.范围={range}," +
             "n.单位={unit}, " +
-            "n.年龄指标={indication} " +
-            "return n")
+            "n.年龄指标={indication} "+
+            "RETURN n,[ (n)-[r]->(m) | [ r, m ] ], ID(n)\n")
     Age createOrUpdate(@Param("name") String name,
-                       @Param("is_kl") Integer is_kl,
-                       @Param("pycode") String pycode,
-                       @Param("status") Integer status,
-                       @Param("maxValue") Double maxValue,
-                       @Param("minValue") Double minValue,
-                       @Param("range") Integer range,
-                       @Param("unit") String unit,
-                       @Param("indication") String indication);
+                        @Param("is_kl") Integer is_kl,
+                        @Param("pycode") String pycode,
+                        @Param("status") Integer status,
+                        @Param("maxValue") Double maxValue,
+                        @Param("minValue") Double minValue,
+                        @Param("range") Integer range,
+                        @Param("unit") String unit,
+                        @Param("indication") String indication);
 }

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

@@ -35,7 +35,7 @@ public interface ClinicalFindingRepository extends Neo4jRepository<ClinicalFindi
             "n.范围={range}," +
             "n.单位={unit}, " +
             "n.临床表现指标={indication} " +
-            "return n")
+            "RETURN n,[ (n)-[r]->(m) | [ r, m ] ], ID(n)\n")
     ClinicalFinding createOrUpdate(@Param("name") String name,
                                    @Param("is_kl") Integer is_kl,
                                    @Param("pycode") String pycode,
@@ -46,4 +46,3 @@ public interface ClinicalFindingRepository extends Neo4jRepository<ClinicalFindi
                                    @Param("unit") String unit,
                                    @Param("indication") String indication);
 }
-

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

@@ -35,7 +35,7 @@ public interface GroupRepository extends Neo4jRepository<Group, Long> {
             "n.范围={range}," +
             "n.单位={unit}, " +
             "n.禁忌人群指标={indication} " +
-            "return n")
+            "RETURN n,[ (n)-[r]->(m) | [ r, m ] ], ID(n)\n")
     Group createOrUpdate(@Param("name") String name,
                          @Param("is_kl") Integer is_kl,
                          @Param("pycode") String pycode,

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

@@ -34,7 +34,7 @@ public interface LisRepository extends Neo4jRepository<Lis,Long> {
             "n.范围={range}," +
             "n.单位={unit}, " +
             "n.实验室检查指标={indication} " +
-            "return n")
+            "RETURN n,[ (n)-[r]->(m) | [ r, m ] ], ID(n)\n")
     Lis createOrUpdate(@Param("name") String name,
                        @Param("is_kl") Integer is_kl,
                        @Param("pycode") String pycode,

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

@@ -4,18 +4,32 @@ import com.diagbot.dto.BillNeoDTO;
 import com.diagbot.dto.LisBillNeoDTO;
 import com.diagbot.dto.NeoEntityDTO;
 import com.diagbot.entity.node.Gender;
-import com.diagbot.entity.node.LisSet;
 import com.diagbot.entity.node.Group;
+import com.diagbot.entity.node.LisSet;
 import com.diagbot.entity.relationship.LisSetGender;
 import com.diagbot.entity.relationship.LisSetGroup;
 import com.diagbot.util.ListUtil;
 import com.diagbot.util.NeoUtil;
-
-import java.util.*;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
 import java.util.stream.Collectors;
 
+@Component
 public class LisSetNode {
 
+	@Autowired
+	GenderRepository genderRepository;
+	@Autowired
+	GroupRepository groupRepository;
+
+
 	public LisBillNeoDTO LisPacktoLISDTO(LisSet lisset) {
 
 		LisBillNeoDTO lisBillNeoDTO = new LisBillNeoDTO();
@@ -182,7 +196,6 @@ public class LisSetNode {
 	}
 
 
-
 	/**
 	 * 获取化验套餐名称列表
 	 */
@@ -266,12 +279,11 @@ public class LisSetNode {
 	}
 
 
-
 	/**
 	 * 根据关系名查询对应节点
 	 */
 	public List<?> getNodesbyRelation(LisSet lisSet, String relname) {
-		List<?> nodelist =  new ArrayList<>();
+		List<?> nodelist = new ArrayList<>();
 
 		try {
 			switch (relname) {
@@ -282,11 +294,9 @@ public class LisSetNode {
 					nodelist = lisSet.getLisSetGroups().stream().map(x -> x.getGroup()).collect(Collectors.toList());
 					break;
 			}
-		}
-		catch (Exception ex) {
+		} catch (Exception ex) {
 			ex.printStackTrace();
-		}
-		finally {
+		} finally {
 			return nodelist;
 		}
 	}
@@ -304,24 +314,70 @@ public class LisSetNode {
 					lisSetRepository.save(lisSet);
 					break;
 				case "实验室检查名称禁忌禁忌人群":
-					lisSet.getLisSetGroups().stream().filter(x -> x.getGroup().getName()==e_name)
+					lisSet.getLisSetGroups().stream().filter(x -> x.getGroup().getName() == e_name)
 							.collect(Collectors.toList()).stream().forEach(y -> y.setStatus(status));
 					lisSetRepository.save(lisSet);
 					break;
-//				case "实验室检查名称相关实验室检查套餐名":
-//					lisSet.getLisnamelisSet().stream().filter(x -> x.getLisSet().getName()==e_name).
-//							collect(Collectors.toList()).stream().forEach(y -> y.setStatus(status));
-//					lisSetRepository.save(lisSet);
-//					break;
+				//				case "实验室检查名称相关实验室检查套餐名":
+				//					lisSet.getLisnamelisSet().stream().filter(x -> x.getLisSet().getName()==e_name).
+				//							collect(Collectors.toList()).stream().forEach(y -> y.setStatus(status));
+				//					lisSetRepository.save(lisSet);
+				//					break;
 			}
-		}
-		catch (Exception ex) {
+		} catch (Exception ex) {
 			ex.printStackTrace();
-		}
-		finally {
+		} finally {
 
 		}
 	}
 
+	/**
+	 * 更新关系状态属性
+	 */
+	public void updateRelationExt(LisSet lisSet, String relname, Integer status, Integer ruleType, String e_name, LisSetRepository lisSetRepository) {
+		Boolean isExist = false;
+		try {
+			switch (relname) {
+				case "实验室检查套餐名禁忌性别":
+					Gender gender = genderRepository.findByNameIs(e_name).get(0);
+					LisSetGender lisSetGender = new LisSetGender();
+					lisSetGender.setGender(gender);
+					lisSetGender.setLisSet(lisSet);
+					lisSetGender.setStatus(status);
+					lisSetGender.setRuleType(ruleType);
+					lisSet.setLisSetgender(lisSetGender);
+					break;
+				case "实验室检查套餐名禁忌禁忌人群":
+					Group group = groupRepository.findByNameIs(e_name).get(0);
+					Set<LisSetGroup> lisSetGroupSet = lisSet.getLisSetGroups();
+					isExist = false;
+					for (LisSetGroup item : lisSetGroupSet) {
+						if (item.getGroup() != null
+								&& item.getGroup().getName().equals(e_name)) {
+							isExist = true;
+							item.setLisSet(lisSet);
+							item.setGroup(group);
+							item.setStatus(status);
+							item.setRuleType(ruleType);
+						}
+					}
+					if (!isExist) {
+						LisSetGroup lisSetGroup = new LisSetGroup();
+						lisSetGroup.setGroup(group);
+						lisSetGroup.setLisSet(lisSet);
+						lisSetGroup.setStatus(status);
+						lisSetGroup.setRuleType(ruleType);
+						lisSetGroupSet.add(lisSetGroup);
+					}
+					lisSet.setLisSetGroups(lisSetGroupSet);
+					break;
+			}
+			lisSetRepository.save(lisSet, 1);
+		} catch (Exception ex) {
+			ex.printStackTrace();
+		} finally {
+
+		}
+	}
 }
 

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

@@ -1,23 +1,41 @@
 package com.diagbot.repository;
 
-import com.diagbot.dto.BillNeoDTO;
 import com.diagbot.dto.DrugBillNeoDTO;
 import com.diagbot.dto.HighRiskNeoDTO;
 import com.diagbot.dto.NodeNeoDTO;
-import com.diagbot.entity.node.*;
-import com.diagbot.entity.relationship.*;
+import com.diagbot.entity.node.Group;
+import com.diagbot.entity.node.MedAllergen;
+import com.diagbot.entity.node.MedCodeName;
+import com.diagbot.entity.node.MedRegName;
+import com.diagbot.entity.node.Medicine;
+import com.diagbot.entity.node.Vital;
+import com.diagbot.entity.relationship.MedCodeNameMedRegName;
+import com.diagbot.entity.relationship.MedCodeNameMedicine;
+import com.diagbot.entity.relationship.MedRegNameGroup;
+import com.diagbot.entity.relationship.MedRegNameMedAllergen;
+import com.diagbot.entity.relationship.MedRegNameMedRegName;
+import com.diagbot.entity.relationship.MedRegNameVital;
 import com.diagbot.util.NeoUtil;
 import com.diagbot.vo.Drug;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
 
-import java.math.BigDecimal;
 import java.util.ArrayList;
 import java.util.List;
-import java.util.Map;
 import java.util.Set;
 
-
+@Component
 public class MedRegNameNode {
 
+    @Autowired
+    GroupRepository groupRepository;
+    @Autowired
+    MedAllergenRepository medAllergenRepository;
+    @Autowired
+    VitalRepository vitalRepository;
+    @Autowired
+    MedRegNameRepository medRegNameRepository;
+
     /**
      * 获取高危药品数据
      */
@@ -41,7 +59,7 @@ public class MedRegNameNode {
             medicine = medRepository.findByNameIs(drugname);
 
             if (null != medicine) {
-                for (Medicine med: medicine) {
+                for (Medicine med : medicine) {
                     for (MedCodeNameMedicine medCodeMed : med.getMedcodenameMedicines()) {
                         if (NeoUtil.isExist(medCodeMed)) {
                             MedCodeName medcdname = medCodeMed.getMedCodeName();
@@ -70,7 +88,7 @@ public class MedRegNameNode {
                         }
                     }
 
-                    if (highRiskNeoDTO.getType()!=null) {
+                    if (highRiskNeoDTO.getType() != null) {
                         break;
                     }
 
@@ -98,7 +116,7 @@ public class MedRegNameNode {
         Set<MedRegNameGroup> medGroups = medRegName.getMedRegNameGroup();
         for (MedRegNameGroup medgroup : medGroups) {
             if (NeoUtil.isExist(medgroup) && NeoUtil.isExist(medgroup.getGroup())
-                    && !NeoUtil.inlist(medgroup.getGroup().getName(),drugBillNeoDTO.getGroup())) {
+                    && !NeoUtil.inlist(medgroup.getGroup().getName(), drugBillNeoDTO.getGroup())) {
                 NodeNeoDTO nodeNeoDTO = new NodeNeoDTO();
                 nodeNeoDTO.setName(medgroup.getGroup().getName());
                 nodeNeoDTO.setTermtype(Constants.group);
@@ -132,7 +150,7 @@ public class MedRegNameNode {
 
 
         String conflict_gender = medRegName.getConflict_gender();
-        if (null!=conflict_gender) {
+        if (null != conflict_gender) {
             NodeNeoDTO nodeNeoDTO = new NodeNeoDTO();
             nodeNeoDTO.setName(conflict_gender);
             nodeNeoDTO.setTermtype(Constants.gender);
@@ -141,7 +159,7 @@ public class MedRegNameNode {
 
 
         String conflict_geiyao = medRegName.getConflict_geiyao();
-        if (null!=conflict_geiyao) {
+        if (null != conflict_geiyao) {
             NodeNeoDTO nodeNeoDTO = new NodeNeoDTO();
             nodeNeoDTO.setName(conflict_geiyao);
             nodeNeoDTO.setTermtype(Constants.geiyao);
@@ -151,5 +169,94 @@ public class MedRegNameNode {
 
         return drugBillNeoDTO;
     }
-}
 
+    /**
+     * 更新关系状态属性
+     */
+    public void updateRelationExt(MedRegName medRegName, String relname, Integer status, Integer ruleType, String e_name, MedRegNameRepository medRegNameRepository) {
+        Boolean isExist = false;
+        try {
+            switch (relname) {
+                case "药品注册名称禁忌禁忌人群":
+                    Group group = groupRepository.findByNameIs(e_name).get(0);
+                    Set<MedRegNameGroup> medRegNameGroupSet = medRegName.getMedRegNameGroup();
+                    isExist = false;
+                    for (MedRegNameGroup item : medRegNameGroupSet) {
+                        if (item.getGroup() != null
+                                && item.getGroup().getName().equals(e_name)) {
+                            isExist = true;
+                            item.setMedRegName(medRegName);
+                            item.setGroup(group);
+                            item.setStatus(status);
+                            item.setRuleType(ruleType);
+                        }
+                    }
+                    if (!isExist) {
+                        MedRegNameGroup medRegNameGroup = new MedRegNameGroup();
+                        medRegNameGroup.setGroup(group);
+                        medRegNameGroup.setMedRegName(medRegName);
+                        medRegNameGroup.setStatus(status);
+                        medRegNameGroup.setRuleType(ruleType);
+                        medRegNameGroupSet.add(medRegNameGroup);
+                    }
+                    medRegName.setMedRegNameGroup(medRegNameGroupSet);
+                    break;
+                case "药品注册名称禁忌药物过敏原":
+                    MedAllergen medAllergen = medAllergenRepository.findByNameIs(e_name).get(0);
+                    Set<MedRegNameMedAllergen> medRegNameMedAllergenSet = medRegName.getMedRegNameMedAllergens();
+                    isExist = false;
+                    for (MedRegNameMedAllergen item : medRegNameMedAllergenSet) {
+                        if (item.getMedAllergen() != null
+                                && item.getMedAllergen().getName().equals(e_name)) {
+                            isExist = true;
+                            item.setMedRegName(medRegName);
+                            item.setMedAllergen(medAllergen);
+                            item.setStatus(status);
+                            item.setRuleType(ruleType);
+                        }
+                    }
+                    if (!isExist) {
+                        MedRegNameMedAllergen medRegNameMedAllergen = new MedRegNameMedAllergen();
+                        medRegNameMedAllergen.setMedAllergen(medAllergen);
+                        medRegNameMedAllergen.setMedRegName(medRegName);
+                        medRegNameMedAllergen.setStatus(status);
+                        medRegNameMedAllergen.setRuleType(ruleType);
+                        medRegNameMedAllergenSet.add(medRegNameMedAllergen);
+                    }
+                    medRegName.setMedRegNameMedAllergens(medRegNameMedAllergenSet);
+                    break;
+                case "药品注册名称禁忌药品注册名称":
+                    break;
+                case "药品注册名称禁忌体征":
+                    Vital vital = vitalRepository.findByNameIs(e_name).get(0);
+                    Set<MedRegNameVital> medRegNameVitalSet = medRegName.getMedRegNameVital();
+                    isExist = false;
+                    for (MedRegNameVital item : medRegNameVitalSet) {
+                        if (item.getVital() != null
+                                && item.getVital().getName().equals(e_name)) {
+                            isExist = true;
+                            item.setMedRegName(medRegName);
+                            item.setVital(vital);
+                            item.setStatus(status);
+                            item.setRuleType(ruleType);
+                        }
+                    }
+                    if (!isExist) {
+                        MedRegNameVital medRegNameVital = new MedRegNameVital();
+                        medRegNameVital.setVital(vital);
+                        medRegNameVital.setMedRegName(medRegName);
+                        medRegNameVital.setStatus(status);
+                        medRegNameVital.setRuleType(ruleType);
+                        medRegNameVitalSet.add(medRegNameVital);
+                    }
+                    medRegName.setMedRegNameVital(medRegNameVitalSet);
+                    break;
+            }
+            medRegNameRepository.save(medRegName, 1);
+        } catch (Exception ex) {
+            ex.printStackTrace();
+        } finally {
+
+        }
+    }
+}

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

@@ -31,6 +31,7 @@ import com.diagbot.entity.relationship.PacsNameVital;
 import com.diagbot.util.ListUtil;
 import com.diagbot.util.NeoUtil;
 import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
 
 import java.util.ArrayList;
 import java.util.Arrays;
@@ -39,6 +40,7 @@ import java.util.Map;
 import java.util.Set;
 import java.util.stream.Collectors;
 
+@Component
 public class PacsNameNode {
 
     @Autowired
@@ -360,7 +362,7 @@ public class PacsNameNode {
      * 根据关系名查询对应节点
      */
     public List<?> getNodesbyRelation(PacsName pacsName, String relname) {
-        List<?> nodelist =  new ArrayList<>();
+        List<?> nodelist = new ArrayList<>();
 
         try {
             switch (relname) {
@@ -398,11 +400,9 @@ public class PacsNameNode {
                     nodelist = pacsName.getPacsNameConflictdevices().stream().map(x -> x.getConflictDevice()).collect(Collectors.toList());
                     break;
             }
-        }
-        catch (Exception ex) {
+        } catch (Exception ex) {
             ex.printStackTrace();
-        }
-        finally {
+        } finally {
             return nodelist;
         }
     }
@@ -420,43 +420,41 @@ public class PacsNameNode {
                     pacsNameRepository.save(pacsName);
                     break;
                 case "辅助检查名称禁忌临床表现":
-                    pacsName.getPacsNameClinicalfindings().stream().filter(x -> x.getClinicalFinding().getName()==e_name).
+                    pacsName.getPacsNameClinicalfindings().stream().filter(x -> x.getClinicalFinding().getName() == e_name).
                             collect(Collectors.toList()).stream().forEach(y -> y.setStatus(status));
                     pacsNameRepository.save(pacsName);
                     break;
                 case "辅助检查名称禁忌体征":
-                    List<PacsNameVital> pacsNameVitals = pacsName.getPacsNameVitals().stream().filter(x -> x.getVital().getName()==e_name).collect(Collectors.toList());
+                    List<PacsNameVital> pacsNameVitals = pacsName.getPacsNameVitals().stream().filter(x -> x.getVital().getName() == e_name).collect(Collectors.toList());
                     break;
                 case "辅助检查名称禁忌实验室检查":
-                    List<PacsNameLis> pacsNameLis = pacsName.getPacsNameLis().stream().filter(x -> x.getLis().getName()==e_name).collect(Collectors.toList());
+                    List<PacsNameLis> pacsNameLis = pacsName.getPacsNameLis().stream().filter(x -> x.getLis().getName() == e_name).collect(Collectors.toList());
                     break;
                 case "辅助检查名称禁忌辅助检查名称描述":
-                    List<PacsNamePacsDescribe> pacsNamePacsDescribes = pacsName.getPacsNamePacsdescribes().stream().filter(x -> x.getPacsDescribe().getName()==e_name).collect(Collectors.toList());
+                    List<PacsNamePacsDescribe> pacsNamePacsDescribes = pacsName.getPacsNamePacsdescribes().stream().filter(x -> x.getPacsDescribe().getName() == e_name).collect(Collectors.toList());
                     break;
                 case "辅助检查名称禁忌禁忌人群":
-                    List<PacsNameGroup> pacsNameGroups = pacsName.getPacsNameGroups().stream().filter(x -> x.getGroup().getName()==e_name).collect(Collectors.toList());
+                    List<PacsNameGroup> pacsNameGroups = pacsName.getPacsNameGroups().stream().filter(x -> x.getGroup().getName() == e_name).collect(Collectors.toList());
                     break;
                 case "辅助检查名称禁忌服用药品":
-                    List<PacsNameOralMedicine> pacsNameOralMedicines = pacsName.getPacsNameOralmedicines().stream().filter(x -> x.getOralMedicine().getName()==e_name).collect(Collectors.toList());
+                    List<PacsNameOralMedicine> pacsNameOralMedicines = pacsName.getPacsNameOralmedicines().stream().filter(x -> x.getOralMedicine().getName() == e_name).collect(Collectors.toList());
                     break;
                 case "辅助检查名称禁忌药物过敏原":
-                    List<PacsNameMedAllergen> pacsNameMedAllergens = pacsName.getPacsNameMedallergens().stream().filter(x -> x.getMedAllergen().getName()==e_name).collect(Collectors.toList());
+                    List<PacsNameMedAllergen> pacsNameMedAllergens = pacsName.getPacsNameMedallergens().stream().filter(x -> x.getMedAllergen().getName() == e_name).collect(Collectors.toList());
                     break;
                 case "辅助检查名称禁忌疾病":
-                    List<PacsNameDisease> pacsNameDiseases = pacsName.getPacsNameDiseases().stream().filter(x -> x.getDisease().getName()==e_name).collect(Collectors.toList());
+                    List<PacsNameDisease> pacsNameDiseases = pacsName.getPacsNameDiseases().stream().filter(x -> x.getDisease().getName() == e_name).collect(Collectors.toList());
                     break;
                 case "辅助检查名称禁忌过敏原":
-                    List<PacsNameAllergen> pacsNameAllergens = pacsName.getPacsNameAllergens().stream().filter(x -> x.getAllergen().getName()==e_name).collect(Collectors.toList());
+                    List<PacsNameAllergen> pacsNameAllergens = pacsName.getPacsNameAllergens().stream().filter(x -> x.getAllergen().getName() == e_name).collect(Collectors.toList());
                     break;
                 case "辅助检查名称禁忌禁忌医疗器械及物品":
-                    List<PacsNameConflictDevice> pacsNameConflictDevices = pacsName.getPacsNameConflictdevices().stream().filter(x -> x.getConflictDevice().getName()==e_name).collect(Collectors.toList());
+                    List<PacsNameConflictDevice> pacsNameConflictDevices = pacsName.getPacsNameConflictdevices().stream().filter(x -> x.getConflictDevice().getName() == e_name).collect(Collectors.toList());
                     break;
             }
-        }
-        catch (Exception ex) {
+        } catch (Exception ex) {
             ex.printStackTrace();
-        }
-        finally {
+        } finally {
 
         }
     }
@@ -762,7 +760,6 @@ public class PacsNameNode {
 
         }
     }
-
 }
 
 

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

@@ -2,18 +2,69 @@ package com.diagbot.repository;
 
 import com.diagbot.dto.BillNeoDTO;
 import com.diagbot.dto.PacsBillNeoDTO;
-import com.diagbot.entity.node.*;
-import com.diagbot.entity.relationship.*;
+import com.diagbot.entity.node.Allergen;
+import com.diagbot.entity.node.ClinicalFinding;
+import com.diagbot.entity.node.ConflictDevice;
+import com.diagbot.entity.node.Disease;
+import com.diagbot.entity.node.Gender;
+import com.diagbot.entity.node.Group;
+import com.diagbot.entity.node.Lis;
+import com.diagbot.entity.node.MedAllergen;
+import com.diagbot.entity.node.OralMedicine;
+import com.diagbot.entity.node.PacsDescribe;
+import com.diagbot.entity.node.PacsSubName;
+import com.diagbot.entity.node.Vital;
+import com.diagbot.entity.relationship.PacsSubNameAllergen;
+import com.diagbot.entity.relationship.PacsSubNameClinicalFinding;
+import com.diagbot.entity.relationship.PacsSubNameConflictDevice;
+import com.diagbot.entity.relationship.PacsSubNameDisease;
+import com.diagbot.entity.relationship.PacsSubNameGender;
+import com.diagbot.entity.relationship.PacsSubNameGroup;
+import com.diagbot.entity.relationship.PacsSubNameLis;
+import com.diagbot.entity.relationship.PacsSubNameMedAllergen;
+import com.diagbot.entity.relationship.PacsSubNameOralMedicine;
+import com.diagbot.entity.relationship.PacsSubNamePacsDescribe;
+import com.diagbot.entity.relationship.PacsSubNameVital;
 import com.diagbot.util.ListUtil;
 import com.diagbot.util.NeoUtil;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
 
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
 
+@Component
 public class PacsSubNameNode {
 
+    @Autowired
+    MedAllergenRepository medAllergenRepository;
+    @Autowired
+    GenderRepository genderRepository;
+    @Autowired
+    LisRepository lisRepository;
+    @Autowired
+    GroupRepository groupRepository;
+    @Autowired
+    ClinicalFindingRepository clinicalFindingRepository;
+    @Autowired
+    VitalRepository vitalRepository;
+    @Autowired
+    AgeRepository ageRepository;
+    @Autowired
+    DiseaseRepository diseaseRepository;
+    @Autowired
+    BillConflictItemRepository billConflictItemRepository;
+    @Autowired
+    ConflictDeviceRepository conflictDeviceRepository;
+    @Autowired
+    OralMedicineRepository oralMedicineRepository;
+    @Autowired
+    PacsDescribeRepository pacsDescribeRepository;
+    @Autowired
+    AllergenRepository allergenRepository;
+
 
     public PacsBillNeoDTO PacstoPACSDTO(PacsSubName pacs) {
         PacsBillNeoDTO pacsBillNeoDTO = new PacsBillNeoDTO();
@@ -217,8 +268,272 @@ public class PacsSubNameNode {
 
         return pacslist;
     }
-}
 
+    /**
+     * 更新关系状态属性
+     */
+    public void updateRelationExt(PacsSubName pacsSubName, String relname, Integer status, Integer ruleType, String e_name, PacsSubNameRepository pacsSubNameRepository) {
+        Boolean isExist = false;
+        try {
+            switch (relname) {
+                case "辅助检查子项目名称禁忌性别":
+                    Gender gender = genderRepository.findByNameIs(e_name).get(0);
+                    PacsSubNameGender pacsSubNameGender = new PacsSubNameGender();
+                    pacsSubNameGender.setGender(gender);
+                    pacsSubNameGender.setPacsSubName(pacsSubName);
+                    pacsSubNameGender.setStatus(status);
+                    pacsSubNameGender.setRuleType(ruleType);
+                    pacsSubName.setPacsSubNameGender(pacsSubNameGender);
+                    break;
+                case "辅助检查子项目名称禁忌禁忌人群":
+                    Group group = groupRepository.findByNameIs(e_name).get(0);
+                    Set<PacsSubNameGroup> pacsSubNameGroupSet = pacsSubName.getPacsSubNameGroups();
+                    isExist = false;
+                    for (PacsSubNameGroup item : pacsSubNameGroupSet) {
+                        if (item.getGroup() != null
+                                && item.getGroup().getName().equals(e_name)) {
+                            isExist = true;
+                            item.setPacsSubName(pacsSubName);
+                            item.setGroup(group);
+                            item.setStatus(status);
+                            item.setRuleType(ruleType);
+                        }
+                    }
+                    if (!isExist) {
+                        PacsSubNameGroup pacsSubNameGroup = new PacsSubNameGroup();
+                        pacsSubNameGroup.setGroup(group);
+                        pacsSubNameGroup.setPacsSubName(pacsSubName);
+                        pacsSubNameGroup.setStatus(status);
+                        pacsSubNameGroup.setRuleType(ruleType);
+                        pacsSubNameGroupSet.add(pacsSubNameGroup);
+                    }
+                    pacsSubName.setPacsSubNameGroups(pacsSubNameGroupSet);
+                    break;
+                case "辅助检查子项目名称禁忌药物过敏原":
+                    MedAllergen medAllergen = medAllergenRepository.findByNameIs(e_name).get(0);
+                    Set<PacsSubNameMedAllergen> pacsSubNameMedAllergenSet = pacsSubName.getPacsSubNameMedallergens();
+                    isExist = false;
+                    for (PacsSubNameMedAllergen item : pacsSubNameMedAllergenSet) {
+                        if (item.getMedAllergen() != null
+                                && item.getMedAllergen().getName().equals(e_name)) {
+                            isExist = true;
+                            item.setPacsSubName(pacsSubName);
+                            item.setMedAllergen(medAllergen);
+                            item.setStatus(status);
+                            item.setRuleType(ruleType);
+                        }
+                    }
+                    if (!isExist) {
+                        PacsSubNameMedAllergen pacsSubNameMedAllergen = new PacsSubNameMedAllergen();
+                        pacsSubNameMedAllergen.setMedAllergen(medAllergen);
+                        pacsSubNameMedAllergen.setPacsSubName(pacsSubName);
+                        pacsSubNameMedAllergen.setStatus(status);
+                        pacsSubNameMedAllergen.setRuleType(ruleType);
+                        pacsSubNameMedAllergenSet.add(pacsSubNameMedAllergen);
+                    }
+                    pacsSubName.setPacsSubNameMedallergens(pacsSubNameMedAllergenSet);
+                    break;
+                case "辅助检查子项目名称禁忌临床表现":
+                    ClinicalFinding clinicalFinding = clinicalFindingRepository.findByNameIs(e_name).get(0);
+                    Set<PacsSubNameClinicalFinding> pacsSubNameClinicalFindingSet = pacsSubName.getPacsSubNameClinicalfindings();
+                    isExist = false;
+                    for (PacsSubNameClinicalFinding item : pacsSubNameClinicalFindingSet) {
+                        if (item.getClinicalFinding() != null
+                                && item.getClinicalFinding().getName().equals(e_name)) {
+                            isExist = true;
+                            item.setPacsSubName(pacsSubName);
+                            item.setClinicalFinding(clinicalFinding);
+                            item.setStatus(status);
+                            item.setRuleType(ruleType);
+                        }
+                    }
+                    if (!isExist) {
+                        PacsSubNameClinicalFinding pacsSubNameClinicalFinding = new PacsSubNameClinicalFinding();
+                        pacsSubNameClinicalFinding.setClinicalFinding(clinicalFinding);
+                        pacsSubNameClinicalFinding.setPacsSubName(pacsSubName);
+                        pacsSubNameClinicalFinding.setStatus(status);
+                        pacsSubNameClinicalFinding.setRuleType(ruleType);
+                        pacsSubNameClinicalFindingSet.add(pacsSubNameClinicalFinding);
+                    }
+                    pacsSubName.setPacsSubNameClinicalfindings(pacsSubNameClinicalFindingSet);
+                    break;
+                case "辅助检查子项目名称禁忌实验室检查":
+                    Lis lis = lisRepository.findByNameIs(e_name).get(0);
+                    Set<PacsSubNameLis> pacsSubNameLisSet = pacsSubName.getPacsSubNameLis();
+                    isExist = false;
+                    for (PacsSubNameLis item : pacsSubNameLisSet) {
+                        if (item.getLis() != null
+                                && item.getLis().getName().equals(e_name)) {
+                            isExist = true;
+                            item.setPacsSubName(pacsSubName);
+                            item.setLis(lis);
+                            item.setStatus(status);
+                            item.setRuleType(ruleType);
+                        }
+                    }
+                    if (!isExist) {
+                        PacsSubNameLis pacsSubNameLis = new PacsSubNameLis();
+                        pacsSubNameLis.setLis(lis);
+                        pacsSubNameLis.setPacsSubName(pacsSubName);
+                        pacsSubNameLis.setStatus(status);
+                        pacsSubNameLis.setRuleType(ruleType);
+                        pacsSubNameLisSet.add(pacsSubNameLis);
+                    }
+                    pacsSubName.setPacsSubNameLis(pacsSubNameLisSet);
+                    break;
+                case "辅助检查子项目名称禁忌疾病":
+                    Disease disease = diseaseRepository.findByNameIs(e_name).get(0);
+                    Set<PacsSubNameDisease> pacsSubNameDiseaseSet = pacsSubName.getPacsSubNameDiseases();
+                    isExist = false;
+                    for (PacsSubNameDisease item : pacsSubNameDiseaseSet) {
+                        if (item.getDisease() != null
+                                && item.getDisease().getName().equals(e_name)) {
+                            isExist = true;
+                            item.setPacsSubName(pacsSubName);
+                            item.setDisease(disease);
+                            item.setStatus(status);
+                            item.setRuleType(ruleType);
+                        }
+                    }
+                    if (!isExist) {
+                        PacsSubNameDisease pacsSubNameDisease = new PacsSubNameDisease();
+                        pacsSubNameDisease.setDisease(disease);
+                        pacsSubNameDisease.setPacsSubName(pacsSubName);
+                        pacsSubNameDisease.setStatus(status);
+                        pacsSubNameDisease.setRuleType(ruleType);
+                        pacsSubNameDiseaseSet.add(pacsSubNameDisease);
+                    }
+                    pacsSubName.setPacsSubNameDiseases(pacsSubNameDiseaseSet);
+                    break;
+                case "辅助检查子项目名称禁忌禁忌医疗器械及物品":
+                    ConflictDevice conflictDevice = conflictDeviceRepository.findByNameIs(e_name).get(0);
+                    Set<PacsSubNameConflictDevice> pacsSubNameConflictDeviceSet = pacsSubName.getPacsSubNameConflictdevices();
+                    isExist = false;
+                    for (PacsSubNameConflictDevice item : pacsSubNameConflictDeviceSet) {
+                        if (item.getConflictDevice() != null
+                                && item.getConflictDevice().getName().equals(e_name)) {
+                            isExist = true;
+                            item.setPacsSubName(pacsSubName);
+                            item.setConflictDevice(conflictDevice);
+                            item.setStatus(status);
+                            item.setRuleType(ruleType);
+                        }
+                    }
+                    if (!isExist) {
+                        PacsSubNameConflictDevice pacsSubNameConflictDevice = new PacsSubNameConflictDevice();
+                        pacsSubNameConflictDevice.setConflictDevice(conflictDevice);
+                        pacsSubNameConflictDevice.setPacsSubName(pacsSubName);
+                        pacsSubNameConflictDevice.setStatus(status);
+                        pacsSubNameConflictDevice.setRuleType(ruleType);
+                        pacsSubNameConflictDeviceSet.add(pacsSubNameConflictDevice);
+                    }
+                    pacsSubName.setPacsSubNameConflictdevices(pacsSubNameConflictDeviceSet);
+                    break;
+                case "辅助检查子项目名称禁忌体征":
+                    Vital vital = vitalRepository.findByNameIs(e_name).get(0);
+                    Set<PacsSubNameVital> pacsSubNameVitalSet = pacsSubName.getPacsSubNameVitals();
+                    isExist = false;
+                    for (PacsSubNameVital item : pacsSubNameVitalSet) {
+                        if (item.getVital() != null
+                                && item.getVital().getName().equals(e_name)) {
+                            isExist = true;
+                            item.setPacsSubName(pacsSubName);
+                            item.setVital(vital);
+                            item.setStatus(status);
+                            item.setRuleType(ruleType);
+                        }
+                    }
+                    if (!isExist) {
+                        PacsSubNameVital pacsSubNameVital = new PacsSubNameVital();
+                        pacsSubNameVital.setVital(vital);
+                        pacsSubNameVital.setPacsSubName(pacsSubName);
+                        pacsSubNameVital.setStatus(status);
+                        pacsSubNameVital.setRuleType(ruleType);
+                        pacsSubNameVitalSet.add(pacsSubNameVital);
+                    }
+                    pacsSubName.setPacsSubNameVitals(pacsSubNameVitalSet);
+                    break;
+                case "辅助检查子项目名称禁忌服用药品":
+                    OralMedicine oralMedicine = oralMedicineRepository.findByNameIs(e_name).get(0);
+                    Set<PacsSubNameOralMedicine> pacsSubNameOralMedicineSet = pacsSubName.getPacsSubNameOralmedicines();
+                    isExist = false;
+                    for (PacsSubNameOralMedicine item : pacsSubNameOralMedicineSet) {
+                        if (item.getOralMedicine() != null
+                                && item.getOralMedicine().getName().equals(e_name)) {
+                            isExist = true;
+                            item.setPacsSubName(pacsSubName);
+                            item.setOralMedicine(oralMedicine);
+                            item.setStatus(status);
+                            item.setRuleType(ruleType);
+                        }
+                    }
+                    if (!isExist) {
+                        PacsSubNameOralMedicine pacsSubNameOralMedicine = new PacsSubNameOralMedicine();
+                        pacsSubNameOralMedicine.setOralMedicine(oralMedicine);
+                        pacsSubNameOralMedicine.setPacsSubName(pacsSubName);
+                        pacsSubNameOralMedicine.setStatus(status);
+                        pacsSubNameOralMedicine.setRuleType(ruleType);
+                        pacsSubNameOralMedicineSet.add(pacsSubNameOralMedicine);
+                    }
+                    pacsSubName.setPacsSubNameOralmedicines(pacsSubNameOralMedicineSet);
+                    break;
+                case "辅助检查子项目名称禁忌辅助检查名称描述":
+                    PacsDescribe pacsDescribe = pacsDescribeRepository.findByNameIs(e_name).get(0);
+                    Set<PacsSubNamePacsDescribe> pacsSubNamePacsDescribeSet = pacsSubName.getPacsSubNamePacsdescribes();
+                    isExist = false;
+                    for (PacsSubNamePacsDescribe item : pacsSubNamePacsDescribeSet) {
+                        if (item.getPacsDescribe() != null
+                                && item.getPacsDescribe().getName().equals(e_name)) {
+                            isExist = true;
+                            item.setPacsSubName(pacsSubName);
+                            item.setPacsDescribe(pacsDescribe);
+                            item.setStatus(status);
+                            item.setRuleType(ruleType);
+                        }
+                    }
+                    if (!isExist) {
+                        PacsSubNamePacsDescribe pacsSubNamePacsDescribe = new PacsSubNamePacsDescribe();
+                        pacsSubNamePacsDescribe.setPacsDescribe(pacsDescribe);
+                        pacsSubNamePacsDescribe.setPacsSubName(pacsSubName);
+                        pacsSubNamePacsDescribe.setStatus(status);
+                        pacsSubNamePacsDescribe.setRuleType(ruleType);
+                        pacsSubNamePacsDescribeSet.add(pacsSubNamePacsDescribe);
+                    }
+                    pacsSubName.setPacsSubNamePacsdescribes(pacsSubNamePacsDescribeSet);
+                    break;
+                case "辅助检查子项目名称禁忌过敏原":
+                    Allergen allergen = allergenRepository.findByNameIs(e_name).get(0);
+                    Set<PacsSubNameAllergen> pacsSubNameAllergenSet = pacsSubName.getPacsSubNameAllergens();
+                    isExist = false;
+                    for (PacsSubNameAllergen item : pacsSubNameAllergenSet) {
+                        if (item.getAllergen() != null
+                                && item.getAllergen().getName().equals(e_name)) {
+                            isExist = true;
+                            item.setPacsSubName(pacsSubName);
+                            item.setAllergen(allergen);
+                            item.setStatus(status);
+                            item.setRuleType(ruleType);
+                        }
+                    }
+                    if (!isExist) {
+                        PacsSubNameAllergen pacsSubNameAllergen = new PacsSubNameAllergen();
+                        pacsSubNameAllergen.setAllergen(allergen);
+                        pacsSubNameAllergen.setPacsSubName(pacsSubName);
+                        pacsSubNameAllergen.setStatus(status);
+                        pacsSubNameAllergen.setRuleType(ruleType);
+                        pacsSubNameAllergenSet.add(pacsSubNameAllergen);
+                    }
+                    pacsSubName.setPacsSubNameAllergens(pacsSubNameAllergenSet);
+                    break;
+            }
+            pacsSubNameRepository.save(pacsSubName, 1);
+        } catch (Exception ex) {
+            ex.printStackTrace();
+        } finally {
+
+        }
+    }
+}
 
 
 

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

@@ -54,7 +54,7 @@ public interface VitalRepository extends Neo4jRepository<Vital, Long> {
             "n.范围={range}," +
             "n.单位={unit}, " +
             "n.体征指标={indication} " +
-            "return n")
+            "RETURN n,[ (n)-[r]->(m) | [ r, m ] ], ID(n)\n")
     Vital createOrUpdate(@Param("name") String name,
                          @Param("is_kl") Integer is_kl,
                          @Param("pycode") String pycode,

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

@@ -20,7 +20,16 @@ import com.diagbot.entity.node.OralMedicine;
 import com.diagbot.entity.node.PacsDescribe;
 import com.diagbot.entity.node.Vital;
 import com.diagbot.entity.node.YiBaoOperationName;
-import com.diagbot.entity.relationship.*;
+import com.diagbot.entity.relationship.YiBaoOperationNameClinicalFinding;
+import com.diagbot.entity.relationship.YiBaoOperationNameConflictDevice;
+import com.diagbot.entity.relationship.YiBaoOperationNameDisease;
+import com.diagbot.entity.relationship.YiBaoOperationNameGender;
+import com.diagbot.entity.relationship.YiBaoOperationNameGroup;
+import com.diagbot.entity.relationship.YiBaoOperationNameLis;
+import com.diagbot.entity.relationship.YiBaoOperationNameMedAllergen;
+import com.diagbot.entity.relationship.YiBaoOperationNameOralMedicine;
+import com.diagbot.entity.relationship.YiBaoOperationNamePacsDescribe;
+import com.diagbot.entity.relationship.YiBaoOperationNameVital;
 import com.diagbot.enums.TypeEnum;
 import com.diagbot.model.label.PacsLabel;
 import com.diagbot.model.label.VitalLabel;
@@ -28,14 +37,44 @@ import com.diagbot.util.CoreUtil;
 import com.diagbot.util.ListUtil;
 import com.diagbot.util.NeoUtil;
 import com.diagbot.util.StringUtil;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
 
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
 
+@Component
 public class YiBaoOperationNameNode {
 
+    @Autowired
+    MedAllergenRepository medAllergenRepository;
+    @Autowired
+    GenderRepository genderRepository;
+    @Autowired
+    LisRepository lisRepository;
+    @Autowired
+    GroupRepository groupRepository;
+    @Autowired
+    ClinicalFindingRepository clinicalFindingRepository;
+    @Autowired
+    VitalRepository vitalRepository;
+    @Autowired
+    AgeRepository ageRepository;
+    @Autowired
+    DiseaseRepository diseaseRepository;
+    @Autowired
+    BillConflictItemRepository billConflictItemRepository;
+    @Autowired
+    ConflictDeviceRepository conflictDeviceRepository;
+    @Autowired
+    OralMedicineRepository oralMedicineRepository;
+    @Autowired
+    PacsDescribeRepository pacsDescribeRepository;
+    @Autowired
+    AllergenRepository allergenRepository;
+
 
     public OperationBillNeoDTO YiBaoOperationtoOperationDTO(YiBaoOperationName operation) {
         OperationBillNeoDTO opBillNeoDTO = new OperationBillNeoDTO();
@@ -104,7 +143,7 @@ public class YiBaoOperationNameNode {
             }
         }
 
-        Set<YiBaoOperationNameOralMedicine> yiBaoOperationNameOralMeds= operation.getOralmeds();
+        Set<YiBaoOperationNameOralMedicine> yiBaoOperationNameOralMeds = operation.getOralmeds();
         for (YiBaoOperationNameOralMedicine yiBaoOperationNameOralMed : yiBaoOperationNameOralMeds) {
             if (NeoUtil.isExist(yiBaoOperationNameOralMed)) {
                 if (NeoUtil.isExist(yiBaoOperationNameOralMed.getOralMedicine())) {
@@ -326,7 +365,7 @@ public class YiBaoOperationNameNode {
             String cond = operation.getHighriskcond();
             JSONObject jobj = JSONObject.parseObject(cond);
 
-            if (null!=jobj) {
+            if (null != jobj) {
                 // 判断年龄
                 JSONObject ageobj = jobj.getJSONObject("年龄");
 
@@ -419,5 +458,244 @@ public class YiBaoOperationNameNode {
 
     }
 
+    /**
+     * 更新关系状态属性
+     */
+    public void updateRelationExt(YiBaoOperationName yiBaoOperationName, String relname, Integer status, Integer ruleType, String e_name, YiBaoOperationNameRepository yiBaoOperationNameRepository) {
+        Boolean isExist = false;
+        try {
+            switch (relname) {
+                case "医保手术和操作名称禁忌性别":
+                    Gender gender = genderRepository.findByNameIs(e_name).get(0);
+                    YiBaoOperationNameGender yiBaoOperationNameGender = new YiBaoOperationNameGender();
+                    yiBaoOperationNameGender.setGender(gender);
+                    yiBaoOperationNameGender.setYiBaoOperationName(yiBaoOperationName);
+                    yiBaoOperationNameGender.setStatus(status);
+                    yiBaoOperationNameGender.setRuleType(ruleType);
+                    yiBaoOperationName.setGender(yiBaoOperationNameGender);
+                    break;
+                case "医保手术和操作名称禁忌禁忌人群":
+                    Group group = groupRepository.findByNameIs(e_name).get(0);
+                    Set<YiBaoOperationNameGroup> yiBaoOperationNameGroupSet = yiBaoOperationName.getGroups();
+                    isExist = false;
+                    for (YiBaoOperationNameGroup item : yiBaoOperationNameGroupSet) {
+                        if (item.getGroup() != null
+                                && item.getGroup().getName().equals(e_name)) {
+                            isExist = true;
+                            item.setYiBaoOperationName(yiBaoOperationName);
+                            item.setGroup(group);
+                            item.setStatus(status);
+                            item.setRuleType(ruleType);
+                        }
+                    }
+                    if (!isExist) {
+                        YiBaoOperationNameGroup yiBaoOperationNameGroup = new YiBaoOperationNameGroup();
+                        yiBaoOperationNameGroup.setGroup(group);
+                        yiBaoOperationNameGroup.setYiBaoOperationName(yiBaoOperationName);
+                        yiBaoOperationNameGroup.setStatus(status);
+                        yiBaoOperationNameGroup.setRuleType(ruleType);
+                        yiBaoOperationNameGroupSet.add(yiBaoOperationNameGroup);
+                    }
+                    yiBaoOperationName.setGroups(yiBaoOperationNameGroupSet);
+                    break;
+                case "医保手术和操作名称禁忌药物过敏原":
+                    MedAllergen medAllergen = medAllergenRepository.findByNameIs(e_name).get(0);
+                    Set<YiBaoOperationNameMedAllergen> yiBaoOperationNameMedAllergenSet = yiBaoOperationName.getMedallergens();
+                    isExist = false;
+                    for (YiBaoOperationNameMedAllergen item : yiBaoOperationNameMedAllergenSet) {
+                        if (item.getMedAllergen() != null
+                                && item.getMedAllergen().getName().equals(e_name)) {
+                            isExist = true;
+                            item.setYiBaoOperationName(yiBaoOperationName);
+                            item.setMedAllergen(medAllergen);
+                            item.setStatus(status);
+                            item.setRuleType(ruleType);
+                        }
+                    }
+                    if (!isExist) {
+                        YiBaoOperationNameMedAllergen yiBaoOperationNameMedAllergen = new YiBaoOperationNameMedAllergen();
+                        yiBaoOperationNameMedAllergen.setMedAllergen(medAllergen);
+                        yiBaoOperationNameMedAllergen.setYiBaoOperationName(yiBaoOperationName);
+                        yiBaoOperationNameMedAllergen.setStatus(status);
+                        yiBaoOperationNameMedAllergen.setRuleType(ruleType);
+                        yiBaoOperationNameMedAllergenSet.add(yiBaoOperationNameMedAllergen);
+                    }
+                    yiBaoOperationName.setMedallergens(yiBaoOperationNameMedAllergenSet);
+                    break;
+                case "医保手术和操作名称禁忌临床表现":
+                    ClinicalFinding clinicalFinding = clinicalFindingRepository.findByNameIs(e_name).get(0);
+                    Set<YiBaoOperationNameClinicalFinding> yiBaoOperationNameClinicalFindingSet = yiBaoOperationName.getClinicalFindings();
+                    isExist = false;
+                    for (YiBaoOperationNameClinicalFinding item : yiBaoOperationNameClinicalFindingSet) {
+                        if (item.getClinicalFinding() != null
+                                && item.getClinicalFinding().getName().equals(e_name)) {
+                            isExist = true;
+                            item.setYiBaoOperationName(yiBaoOperationName);
+                            item.setClinicalFinding(clinicalFinding);
+                            item.setStatus(status);
+                            item.setRuleType(ruleType);
+                        }
+                    }
+                    if (!isExist) {
+                        YiBaoOperationNameClinicalFinding yiBaoOperationNameClinicalFinding = new YiBaoOperationNameClinicalFinding();
+                        yiBaoOperationNameClinicalFinding.setClinicalFinding(clinicalFinding);
+                        yiBaoOperationNameClinicalFinding.setYiBaoOperationName(yiBaoOperationName);
+                        yiBaoOperationNameClinicalFinding.setStatus(status);
+                        yiBaoOperationNameClinicalFinding.setRuleType(ruleType);
+                        yiBaoOperationNameClinicalFindingSet.add(yiBaoOperationNameClinicalFinding);
+                    }
+                    yiBaoOperationName.setClinicalFindings(yiBaoOperationNameClinicalFindingSet);
+                    break;
+                case "医保手术和操作名称禁忌实验室检查":
+                    Lis lis = lisRepository.findByNameIs(e_name).get(0);
+                    Set<YiBaoOperationNameLis> yiBaoOperationNameLisSet = yiBaoOperationName.getLiss();
+                    isExist = false;
+                    for (YiBaoOperationNameLis item : yiBaoOperationNameLisSet) {
+                        if (item.getLis() != null
+                                && item.getLis().getName().equals(e_name)) {
+                            isExist = true;
+                            item.setYiBaoOperationName(yiBaoOperationName);
+                            item.setLis(lis);
+                            item.setStatus(status);
+                            item.setRuleType(ruleType);
+                        }
+                    }
+                    if (!isExist) {
+                        YiBaoOperationNameLis yiBaoOperationNameLis = new YiBaoOperationNameLis();
+                        yiBaoOperationNameLis.setLis(lis);
+                        yiBaoOperationNameLis.setYiBaoOperationName(yiBaoOperationName);
+                        yiBaoOperationNameLis.setStatus(status);
+                        yiBaoOperationNameLis.setRuleType(ruleType);
+                        yiBaoOperationNameLisSet.add(yiBaoOperationNameLis);
+                    }
+                    yiBaoOperationName.setLiss(yiBaoOperationNameLisSet);
+                    break;
+                case "医保手术和操作名称禁忌疾病":
+                    Disease disease = diseaseRepository.findByNameIs(e_name).get(0);
+                    Set<YiBaoOperationNameDisease> yiBaoOperationNameDiseaseSet = yiBaoOperationName.getDiseases();
+                    isExist = false;
+                    for (YiBaoOperationNameDisease item : yiBaoOperationNameDiseaseSet) {
+                        if (item.getDisease() != null
+                                && item.getDisease().getName().equals(e_name)) {
+                            isExist = true;
+                            item.setYiBaoOperationName(yiBaoOperationName);
+                            item.setDisease(disease);
+                            item.setStatus(status);
+                            item.setRuleType(ruleType);
+                        }
+                    }
+                    if (!isExist) {
+                        YiBaoOperationNameDisease yiBaoOperationNameDisease = new YiBaoOperationNameDisease();
+                        yiBaoOperationNameDisease.setDisease(disease);
+                        yiBaoOperationNameDisease.setYiBaoOperationName(yiBaoOperationName);
+                        yiBaoOperationNameDisease.setStatus(status);
+                        yiBaoOperationNameDisease.setRuleType(ruleType);
+                        yiBaoOperationNameDiseaseSet.add(yiBaoOperationNameDisease);
+                    }
+                    yiBaoOperationName.setDiseases(yiBaoOperationNameDiseaseSet);
+                    break;
+                case "医保手术和操作名称禁忌禁忌医疗器械及物品":
+                    ConflictDevice conflictDevice = conflictDeviceRepository.findByNameIs(e_name).get(0);
+                    Set<YiBaoOperationNameConflictDevice> yiBaoOperationNameConflictDeviceSet = yiBaoOperationName.getConflictdevices();
+                    isExist = false;
+                    for (YiBaoOperationNameConflictDevice item : yiBaoOperationNameConflictDeviceSet) {
+                        if (item.getConflictDevice() != null
+                                && item.getConflictDevice().getName().equals(e_name)) {
+                            isExist = true;
+                            item.setYiBaoOperationName(yiBaoOperationName);
+                            item.setConflictDevice(conflictDevice);
+                            item.setStatus(status);
+                            item.setRuleType(ruleType);
+                        }
+                    }
+                    if (!isExist) {
+                        YiBaoOperationNameConflictDevice yiBaoOperationNameConflictDevice = new YiBaoOperationNameConflictDevice();
+                        yiBaoOperationNameConflictDevice.setConflictDevice(conflictDevice);
+                        yiBaoOperationNameConflictDevice.setYiBaoOperationName(yiBaoOperationName);
+                        yiBaoOperationNameConflictDevice.setStatus(status);
+                        yiBaoOperationNameConflictDevice.setRuleType(ruleType);
+                        yiBaoOperationNameConflictDeviceSet.add(yiBaoOperationNameConflictDevice);
+                    }
+                    yiBaoOperationName.setConflictdevices(yiBaoOperationNameConflictDeviceSet);
+                    break;
+                case "医保手术和操作名称禁忌体征":
+                    Vital vital = vitalRepository.findByNameIs(e_name).get(0);
+                    Set<YiBaoOperationNameVital> yiBaoOperationNameVitalSet = yiBaoOperationName.getVitals();
+                    isExist = false;
+                    for (YiBaoOperationNameVital item : yiBaoOperationNameVitalSet) {
+                        if (item.getVital() != null
+                                && item.getVital().getName().equals(e_name)) {
+                            isExist = true;
+                            item.setYiBaoOperationName(yiBaoOperationName);
+                            item.setVital(vital);
+                            item.setStatus(status);
+                            item.setRuleType(ruleType);
+                        }
+                    }
+                    if (!isExist) {
+                        YiBaoOperationNameVital yiBaoOperationNameVital = new YiBaoOperationNameVital();
+                        yiBaoOperationNameVital.setVital(vital);
+                        yiBaoOperationNameVital.setYiBaoOperationName(yiBaoOperationName);
+                        yiBaoOperationNameVital.setStatus(status);
+                        yiBaoOperationNameVital.setRuleType(ruleType);
+                        yiBaoOperationNameVitalSet.add(yiBaoOperationNameVital);
+                    }
+                    yiBaoOperationName.setVitals(yiBaoOperationNameVitalSet);
+                    break;
+                case "医保手术和操作名称禁忌服用药品":
+                    OralMedicine oralMedicine = oralMedicineRepository.findByNameIs(e_name).get(0);
+                    Set<YiBaoOperationNameOralMedicine> yiBaoOperationNameOralMedicineSet = yiBaoOperationName.getOralmeds();
+                    isExist = false;
+                    for (YiBaoOperationNameOralMedicine item : yiBaoOperationNameOralMedicineSet) {
+                        if (item.getOralMedicine() != null
+                                && item.getOralMedicine().getName().equals(e_name)) {
+                            isExist = true;
+                            item.setYiBaoOperationName(yiBaoOperationName);
+                            item.setOralMedicine(oralMedicine);
+                            item.setStatus(status);
+                            item.setRuleType(ruleType);
+                        }
+                    }
+                    if (!isExist) {
+                        YiBaoOperationNameOralMedicine yiBaoOperationNameOralMedicine = new YiBaoOperationNameOralMedicine();
+                        yiBaoOperationNameOralMedicine.setOralMedicine(oralMedicine);
+                        yiBaoOperationNameOralMedicine.setYiBaoOperationName(yiBaoOperationName);
+                        yiBaoOperationNameOralMedicine.setStatus(status);
+                        yiBaoOperationNameOralMedicine.setRuleType(ruleType);
+                        yiBaoOperationNameOralMedicineSet.add(yiBaoOperationNameOralMedicine);
+                    }
+                    yiBaoOperationName.setOralmeds(yiBaoOperationNameOralMedicineSet);
+                    break;
+                case "医保手术和操作名称禁忌辅助检查名称描述":
+                    PacsDescribe pacsDescribe = pacsDescribeRepository.findByNameIs(e_name).get(0);
+                    Set<YiBaoOperationNamePacsDescribe> yiBaoOperationNamePacsDescribeSet = yiBaoOperationName.getPacsdescs();
+                    isExist = false;
+                    for (YiBaoOperationNamePacsDescribe item : yiBaoOperationNamePacsDescribeSet) {
+                        if (item.getPacsDescribe() != null
+                                && item.getPacsDescribe().getName().equals(e_name)) {
+                            isExist = true;
+                            item.setYiBaoOperationName(yiBaoOperationName);
+                            item.setPacsDescribe(pacsDescribe);
+                            item.setStatus(status);
+                            item.setRuleType(ruleType);
+                        }
+                    }
+                    if (!isExist) {
+                        YiBaoOperationNamePacsDescribe yiBaoOperationNamePacsDescribe = new YiBaoOperationNamePacsDescribe();
+                        yiBaoOperationNamePacsDescribe.setPacsDescribe(pacsDescribe);
+                        yiBaoOperationNamePacsDescribe.setYiBaoOperationName(yiBaoOperationName);
+                        yiBaoOperationNamePacsDescribe.setStatus(status);
+                        yiBaoOperationNamePacsDescribe.setRuleType(ruleType);
+                        yiBaoOperationNamePacsDescribeSet.add(yiBaoOperationNamePacsDescribe);
+                    }
+                    yiBaoOperationName.setPacsdescs(yiBaoOperationNamePacsDescribeSet);
+                    break;
+            }
+            yiBaoOperationNameRepository.save(yiBaoOperationName, 1);
+        } catch (Exception ex) {
+            ex.printStackTrace();
+        } finally {
 
-}
+        }
+    }
+}