开单合理性维护

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

@@ -6,32 +6,26 @@ import com.diagbot.entity.node.BillConcept;
 import com.diagbot.entity.node.BillCondition;
 import com.diagbot.entity.node.BillItem;
 import com.diagbot.entity.node.ClinicalFinding;
-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.PacsName;
 import com.diagbot.entity.node.Vital;
-import com.diagbot.entity.relationship.PacsNameAllergen;
-import com.diagbot.entity.relationship.PacsNameClinicalFinding;
-import com.diagbot.entity.relationship.PacsNameConflictDevice;
-import com.diagbot.entity.relationship.PacsNameDisease;
-import com.diagbot.entity.relationship.PacsNameGender;
-import com.diagbot.entity.relationship.PacsNameGroup;
-import com.diagbot.entity.relationship.PacsNameLis;
-import com.diagbot.entity.relationship.PacsNameMedAllergen;
-import com.diagbot.entity.relationship.PacsNameOralMedicine;
-import com.diagbot.entity.relationship.PacsNamePacsDescribe;
-import com.diagbot.entity.relationship.PacsNameVital;
 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.util.Cn2SpellUtil;
@@ -51,7 +45,6 @@ import org.springframework.stereotype.Component;
 
 import java.util.List;
 import java.util.Map;
-import java.util.Set;
 import java.util.stream.Collectors;
 
 /**
@@ -68,7 +61,6 @@ public class BillManFacade {
     @Autowired
     PacsNameRepository pacsNameRepository;
 
-
     @Autowired
     MedAllergenRepository medAllergenRepository;
     @Autowired
@@ -83,8 +75,18 @@ public class BillManFacade {
     VitalRepository vitalRepository;
     @Autowired
     AgeRepository ageRepository;
-
-
+    @Autowired
+    DiseaseRepository diseaseRepository;
+    @Autowired
+    BillConflictItemRepository billConflictItemRepository;
+    @Autowired
+    ConflictDeviceRepository conflictDeviceRepository;
+    @Autowired
+    OralMedicineRepository oralMedicineRepository;
+    @Autowired
+    PacsDescribeRepository pacsDescribeRepository;
+    @Autowired
+    AllergenRepository allergenRepository;
 
     /**
      * 获取开单合理项列表
@@ -136,8 +138,8 @@ public class BillManFacade {
                 = EntityUtil.makeMapWithKeyValue(dicTypeConvert, "name", "val");
         Map<String, String> dicIndicationManTypeMap
                 = EntityUtil.makeMapWithKeyValue(dicIndicationManType, "val", "name");
-        Map<String,String> dicBillConditionTypeMap
-                =EntityUtil.makeMapWithKeyValue(dicBillConditionType,"name","val");
+        Map<String, String> dicBillConditionTypeMap
+                = EntityUtil.makeMapWithKeyValue(dicBillConditionType, "name", "val");
         if (dicIndicationManTypeMap.containsKey(conditionIndexVO.getType().toString())
                 && dicTypeConvertMap.containsKey(dicIndicationManTypeMap.get(conditionIndexVO.getType().toString()))) {
             conditionIndexVO.setConceptLabel(dicTypeConvertMap.get(dicIndicationManTypeMap.get(conditionIndexVO.getType().toString())));
@@ -272,7 +274,7 @@ public class BillManFacade {
             throw new CommonException(CommonErrorCode.IS_EXISTS, "规则已存在，不允许修改");
         }
 
-        //数值类型
+        //数值类型特殊处理
         if (billSaveVO.getRuleType() != null
                 && billSaveVO.getRuleType().equals("2")) {
             BillCondition tempCondition = billSaveVO.getCondition();
@@ -292,216 +294,111 @@ public class BillManFacade {
         BillConcept concept = billSaveVO.getConcept();
         BillCondition condition = billSaveVO.getCondition();
 
-        if (billSaveVO.getRelationId() == null) {
-            //新增
-            //ruleType=1 文本类型，ruleType=2 数值类型
-            if (billSaveVO.getRuleType().equals(1)) {
-                switch (concept.getConceptLabel()) {
-                    case "实验室检查名称":
-                        break;
-                    case "辅助检查名称":
-                        PacsName pacsName = pacsNameRepository.findByNameIs(billSaveVO.getConcept().getName()).get(0);
-                        updateRelation(pacsName, relationType, 1, billSaveVO.getRuleType(), billSaveVO.getCondition().getName(), pacsNameRepository);
-                        break;
-                    default:
-                        break;
-                }
-            } else if (billSaveVO.getRuleType().equals(2)) {
-                String name = billSaveVO.getConcept().getName() + "禁忌" + billSaveVO.getCondition().getName();
-                switch (condition.getConditionLabel()) {
-                    case "性别":
-                        break;
-                    case "实验室检查":
-                        Lis lis = new Lis();
-                        lis.setName(name);
-                        lis.setIs_kl(0);
-                        lis.setPycode(Cn2SpellUtil.converterToFirstSpell(name));
-                        lis.setStatus(1);
-                        lis.setMaxval(condition.getMaxValue());
-                        lis.setMinval(condition.getMinValue());
-                        lis.setRange(condition.getRange());
-                        lis.setUnit(condition.getUnit());
-                        lis = lisRepository.save(lis);
-                        break;
-                    case "临床表现":
-                        ClinicalFinding clinicalFinding = new ClinicalFinding();
-                        clinicalFinding.setName(name);
-                        clinicalFinding.setIs_kl(0);
-                        clinicalFinding.setPycode(Cn2SpellUtil.converterToFirstSpell(name));
-                        clinicalFinding.setStatus(1);
-                        clinicalFinding.setMaxval(condition.getMaxValue());
-                        clinicalFinding.setMinval(condition.getMinValue());
-                        clinicalFinding.setRange(condition.getRange());
-                        clinicalFinding.setUnit(condition.getUnit());
-                        clinicalFinding = clinicalFindingRepository.save(clinicalFinding);
-                        break;
-                    case "辅助检查名称描述":
-                        break;
-                    case "疾病":
-                        break;
-                    case "服用药品":
-                        break;
-                    case "药物过敏原":
-                        break;
-                    case "食物过敏原":
-                        break;
-                    case "手术":
-                        break;
-                    case "禁忌人群":
-                        Group group = groupRepository.saveNode(name, 0, Cn2SpellUtil.converterToFirstSpell(name), 1,
-                                condition.getMaxValue(), condition.getMinValue(),
-                                condition.getRange() == null ? 0 : condition.getRange(), condition.getUnit(),
-                                condition.getName());
-                        break;
-                    case "过敏原":
-                        break;
-                    case "体征":
-                        Vital vital = new Vital();
-                        vital.setName(name);
-                        vital.setIs_kl(0);
-                        //vital.setLabels();
-                        vital.setPycode(Cn2SpellUtil.converterToFirstSpell(name));
-                        vital.setStatus(1);
-                        vital.setMaxval(condition.getMaxValue());
-                        vital.setMinval(condition.getMinValue());
-                        vital.setRange(condition.getRange());
-                        vital.setUnit(condition.getUnit());
-                        vital = vitalRepository.save(vital);
-                        break;
-                    case "禁忌医疗器械及物品":
-                        break;
-                    case "年龄":
-                        Age age = new Age();
-                        age.setName(name);
-                        age.setIs_kl(0);
-                        age.setPycode(Cn2SpellUtil.converterToFirstSpell(name));
-                        age.setStatus(1);
-                        age.setMaxval(condition.getMaxValue());
-                        age.setMinval(condition.getMinValue());
-                        age.setRange(condition.getRange());
-                        age.setUnit(condition.getUnit());
-                        age = ageRepository.save(age);
-                        break;
-                    case "给药途径":
-                        break;
-                    case "开单项互斥":
-                        break;
-                }
-
-                switch (concept.getConceptLabel()) {
-                    case "实验室检查名称":
-                        break;
-                    case "辅助检查名称":
-                        PacsName pacsName = pacsNameRepository.findByNameIs(billSaveVO.getConcept().getName()).get(0);
-                        updateRelation(pacsName, relationType, 1, billSaveVO.getRuleType(), name, pacsNameRepository);
-                        break;
-                    default:
-                        break;
-                }
-
-            }
-
-        } else {
-            //修改
-        }
-
-        return true;
-    }
+        String conditionName = billSaveVO.getRuleType().equals(2)
+                ? concept.getName() + "禁忌" + condition.getName()
+                : condition.getName();
 
-    /**
-     * 更新关系状态属性
-     */
-    public void updateRelation(PacsName pacsName, String relname, Integer status, Integer ruleType,String e_name, PacsNameRepository pacsNameRepository) {
-
-        try {
-            switch (relname) {
-                case "辅助检查名称禁忌性别":
-                    Gender gender = genderRepository.findByNameIs(e_name).get(0);
-                    PacsNameGender pacsNameGender = new PacsNameGender();
-                    pacsNameGender.setGender(gender);
-                    pacsNameGender.setPacsName(pacsName);
-                    pacsNameGender.setStatus(status);
-                    pacsNameGender.setRuleType(ruleType);
-                    pacsName.setPacsNameGender(pacsNameGender);
-                    pacsNameRepository.save(pacsName, 1);
+        //条件明细节点更新
+        //数值类型可新增或更新条件明细节点，文本类型不允许新增或修改
+        if (billSaveVO.getRuleType().equals(1)) {
+        } else if (billSaveVO.getRuleType().equals(2)) {
+            switch (condition.getConditionLabel()) {
+                case "性别":
+                    break;
+                case "实验室检查":
+                    Lis lis = lisRepository.createOrUpdate(conditionName,
+                            0,
+                            Cn2SpellUtil.converterToFirstSpell(conditionName),
+                            1,
+                            condition.getMaxValue(),
+                            condition.getMinValue(),
+                            condition.getRange(),
+                            condition.getUnit(),
+                            condition.getName());
                     break;
-                case "辅助检查名称禁忌禁忌人群":
-                    Group group = groupRepository.findByNameIs(e_name).get(0);
-                    Set<PacsNameGroup> pacsNameGroupSet = pacsName.getPacsNameGroups();
-                    PacsNameGroup pacsNameGroup = new PacsNameGroup();
-                    pacsNameGroup.setGroup(group);
-                    pacsNameGroup.setPacsName(pacsName);
-                    pacsNameGroup.setStatus(status);
-                    pacsNameGroup.setRuleType(ruleType);
-                    pacsNameGroupSet.add(pacsNameGroup);
-                    pacsName.setPacsNameGroups(pacsNameGroupSet);
-                    pacsNameRepository.save(pacsName, 1);
+                case "临床表现":
+                    ClinicalFinding clinicalFinding = clinicalFindingRepository.createOrUpdate(conditionName,
+                            0,
+                            Cn2SpellUtil.converterToFirstSpell(conditionName),
+                            1,
+                            condition.getMaxValue(),
+                            condition.getMinValue(),
+                            condition.getRange(),
+                            condition.getUnit(),
+                            condition.getName());
                     break;
-                case "辅助检查名称禁忌药物过敏原":
-                    MedAllergen medAllergen = medAllergenRepository.findByNameIs(e_name).get(0);
-                    Set<PacsNameMedAllergen> pacsNameMedAllergenSet = pacsName.getPacsNameMedallergens();
-                    PacsNameMedAllergen pacsNameMedAllergen = new PacsNameMedAllergen();
-                    pacsNameMedAllergen.setMedAllergen(medAllergen);
-                    pacsNameMedAllergen.setPacsName(pacsName);
-                    pacsNameMedAllergen.setStatus(status);
-                    pacsNameMedAllergen.setRuleType(ruleType);
-                    pacsNameMedAllergenSet.add(pacsNameMedAllergen);
-                    pacsName.setPacsNameMedallergens(pacsNameMedAllergenSet);
-                    pacsNameRepository.save(pacsName, 1);
+                case "辅助检查名称描述":
                     break;
-                case "辅助检查名称禁忌临床表现":
-                    ClinicalFinding clinicalFinding = clinicalFindingRepository.findByNameIs(e_name).get(0);
-                    Set<PacsNameClinicalFinding> pacsNameClinicalFindingSet = pacsName.getPacsNameClinicalfindings();
-                    PacsNameClinicalFinding pacsNameClinicalFinding = new PacsNameClinicalFinding();
-                    pacsNameClinicalFinding.setClinicalFinding(clinicalFinding);
-                    pacsNameClinicalFinding.setPacsName(pacsName);
-                    pacsNameClinicalFinding.setStatus(status);
-                    pacsNameClinicalFinding.setRuleType(ruleType);
-                    pacsNameClinicalFindingSet.add(pacsNameClinicalFinding);
-                    pacsName.setPacsNameClinicalfindings(pacsNameClinicalFindingSet);
-                    pacsNameRepository.save(pacsName, 1);
+                case "疾病":
                     break;
-                case "辅助检查名称禁忌实验室检查名称":
+                case "服用药品":
                     break;
-                case "辅助检查名称禁忌实验室检查":
-                    Lis lis = lisRepository.findByNameIs(e_name).get(0);
-                    Set<PacsNameLis> pacsNameLisSet = pacsName.getPacsNameLis();
-                    PacsNameLis pacsNameLis = new PacsNameLis();
-                    pacsNameLis.setLis(lis);
-                    pacsNameLis.setPacsName(pacsName);
-                    pacsNameLis.setStatus(status);
-                    pacsNameLis.setRuleType(ruleType);
-                    pacsNameLisSet.add(pacsNameLis);
-                    pacsName.setPacsNameLis(pacsNameLisSet);
-                    pacsNameRepository.save(pacsName, 1);
+                case "药物过敏原":
                     break;
-                case "辅助检查名称禁忌疾病":
-                    List<PacsNameDisease> pacsNameDiseases = pacsName.getPacsNameDiseases().stream().filter(x -> x.getDisease().getName() == e_name).collect(Collectors.toList());
+                case "食物过敏原":
                     break;
-                case "辅助检查名称禁忌禁忌医疗器械及物品":
-                    List<PacsNameConflictDevice> pacsNameConflictDevices = pacsName.getPacsNameConflictdevices().stream().filter(x -> x.getConflictDevice().getName() == e_name).collect(Collectors.toList());
+                case "手术":
                     break;
-                case "辅助检查名称禁忌体征":
-                    List<PacsNameVital> pacsNameVitals = pacsName.getPacsNameVitals().stream().filter(x -> x.getVital().getName() == e_name).collect(Collectors.toList());
+                case "禁忌人群":
+                    Group group = groupRepository.createOrUpdate(conditionName,
+                            0,
+                            Cn2SpellUtil.converterToFirstSpell(conditionName),
+                            1,
+                            condition.getMaxValue(),
+                            condition.getMinValue(),
+                            condition.getRange(),
+                            condition.getUnit(),
+                            condition.getName());
                     break;
-                case "辅助检查名称禁忌服用药品":
-                    List<PacsNameOralMedicine> pacsNameOralMedicines = pacsName.getPacsNameOralmedicines().stream().filter(x -> x.getOralMedicine().getName() == e_name).collect(Collectors.toList());
+                case "过敏原":
                     break;
-                case "辅助检查名称禁忌辅助检查名称描述":
-                    List<PacsNamePacsDescribe> pacsNamePacsDescribes = pacsName.getPacsNamePacsdescribes().stream().filter(x -> x.getPacsDescribe().getName() == e_name).collect(Collectors.toList());
+                case "体征":
+                    Vital vital = vitalRepository.createOrUpdate(conditionName,
+                            0,
+                            Cn2SpellUtil.converterToFirstSpell(conditionName),
+                            1,
+                            condition.getMaxValue(),
+                            condition.getMinValue(),
+                            condition.getRange(),
+                            condition.getUnit(),
+                            condition.getName());
                     break;
-                case "辅助检查名称禁忌过敏原":
-                    List<PacsNameAllergen> pacsNameAllergens = pacsName.getPacsNameAllergens().stream().filter(x -> x.getAllergen().getName() == e_name).collect(Collectors.toList());
+                case "禁忌医疗器械及物品":
                     break;
-                case "辅助检查名称禁忌开单项互斥":
+                case "年龄":
+                    Age age = ageRepository.createOrUpdate(conditionName,
+                            0,
+                            Cn2SpellUtil.converterToFirstSpell(conditionName),
+                            1,
+                            condition.getMaxValue(),
+                            condition.getMinValue(),
+                            condition.getRange(),
+                            condition.getUnit(),
+                            condition.getName());
+                    break;
+                case "给药途径":
+                    break;
+                case "开单项互斥":
                     break;
             }
         }
-        catch (Exception ex) {
-            ex.printStackTrace();
-        }
-        finally {
 
+
+        //保存关系
+        switch (concept.getConceptLabel()) {
+            case "实验室检查名称":
+                break;
+            case "辅助检查名称":
+                PacsName pacsName = pacsNameRepository.findByNameIs(concept.getName()).get(0);
+                PacsNameNode pacsNameNode = new PacsNameNode();
+                pacsNameNode.updateRelationExt(pacsName, relationType, 1, billSaveVO.getRuleType(), conditionName, pacsNameRepository);
+                break;
+            default:
+                break;
         }
+
+        return true;
     }
+
+
 }

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

@@ -1,7 +1,9 @@
 package com.diagbot.repository;
 
 import com.diagbot.entity.node.Age;
+import org.springframework.data.neo4j.annotation.Query;
 import org.springframework.data.neo4j.repository.Neo4jRepository;
+import org.springframework.data.repository.query.Param;
 
 import java.util.List;
 
@@ -12,4 +14,34 @@ import java.util.List;
  */
 public interface AgeRepository extends Neo4jRepository<Age,Long> {
     List<Age> findByNameIs(String name);
-}
+
+    @Query("merge (n:年龄{name:{name}})  " +
+            "on create set  " +
+            "n.拼音编码={pycode}," +
+            "n.静态知识标识={is_kl}," +
+            "n.状态={status}," +
+            "n.最大值={maxValue}," +
+            "n.最小值={minValue}," +
+            "n.范围={range}," +
+            "n.单位={unit}, " +
+            "n.年龄指标={indication} " +
+            "on match set  " +
+            "n.拼音编码={pycode}," +
+            "n.静态知识标识={is_kl}," +
+            "n.状态={status}," +
+            "n.最大值={maxValue}," +
+            "n.最小值={minValue}," +
+            "n.范围={range}," +
+            "n.单位={unit}, " +
+            "n.年龄指标={indication} " +
+            "return 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);
+}

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

@@ -0,0 +1,15 @@
+package com.diagbot.repository;
+
+import com.diagbot.entity.node.BillConflictItem;
+import org.springframework.data.neo4j.repository.Neo4jRepository;
+
+import java.util.List;
+
+/**
+ * @Description:
+ * @Author:zhaops
+ * @time: 2020/11/26 10:11
+ */
+public interface BillConflictItemRepository extends Neo4jRepository<BillConflictItem,Long> {
+    List<BillConflictItem> findByNameIs(String name);
+}

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

@@ -16,5 +16,34 @@ public interface ClinicalFindingRepository extends Neo4jRepository<ClinicalFindi
 
     List<ClinicalFinding> findByNameContaining(String name);
 
+    @Query("merge (n:临床表现{name:{name}})  " +
+            "on create set  " +
+            "n.拼音编码={pycode}," +
+            "n.静态知识标识={is_kl}," +
+            "n.状态={status}," +
+            "n.最大值={maxValue}," +
+            "n.最小值={minValue}," +
+            "n.范围={range}," +
+            "n.单位={unit}, " +
+            "n.临床表现指标={indication} " +
+            "on match set  " +
+            "n.拼音编码={pycode}," +
+            "n.静态知识标识={is_kl}," +
+            "n.状态={status}," +
+            "n.最大值={maxValue}," +
+            "n.最小值={minValue}," +
+            "n.范围={range}," +
+            "n.单位={unit}, " +
+            "n.临床表现指标={indication} " +
+            "return n")
+    ClinicalFinding 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);
 }
 

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

@@ -0,0 +1,15 @@
+package com.diagbot.repository;
+
+import com.diagbot.entity.node.ConflictDevice;
+import org.springframework.data.neo4j.repository.Neo4jRepository;
+
+import java.util.List;
+
+/**
+ * @Description:
+ * @Author:zhaops
+ * @time: 2020/11/26 10:07
+ */
+public interface ConflictDeviceRepository extends Neo4jRepository<ConflictDevice,Long> {
+    List<ConflictDevice> findByNameIs(String name);
+}

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

@@ -0,0 +1,15 @@
+package com.diagbot.repository;
+
+import com.diagbot.entity.node.Disease;
+import org.springframework.data.neo4j.repository.Neo4jRepository;
+
+import java.util.List;
+
+/**
+ * @Description:
+ * @Author:zhaops
+ * @time: 2020/11/26 10:02
+ */
+public interface DiseaseRepository extends Neo4jRepository<Disease,Long> {
+    List<Disease> findByNameIs(String name);
+}

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

@@ -36,13 +36,13 @@ public interface GroupRepository extends Neo4jRepository<Group, Long> {
             "n.单位={unit}, " +
             "n.禁忌人群指标={indication} " +
             "return n")
-    Group saveNode(@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);
+    Group 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);
 }

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

@@ -1,7 +1,9 @@
 package com.diagbot.repository;
 
 import com.diagbot.entity.node.Lis;
+import org.springframework.data.neo4j.annotation.Query;
 import org.springframework.data.neo4j.repository.Neo4jRepository;
+import org.springframework.data.repository.query.Param;
 
 import java.util.List;
 
@@ -13,4 +15,34 @@ import java.util.List;
 public interface LisRepository extends Neo4jRepository<Lis,Long> {
     List<Lis> findByNameIs(String name);
 
+    @Query("merge (n:实验室检查{name:{name}})  " +
+            "on create set  " +
+            "n.拼音编码={pycode}," +
+            "n.静态知识标识={is_kl}," +
+            "n.状态={status}," +
+            "n.最大值={maxValue}," +
+            "n.最小值={minValue}," +
+            "n.范围={range}," +
+            "n.单位={unit}, " +
+            "n.实验室检查指标={indication} " +
+            "on match set  " +
+            "n.拼音编码={pycode}," +
+            "n.静态知识标识={is_kl}," +
+            "n.状态={status}," +
+            "n.最大值={maxValue}," +
+            "n.最小值={minValue}," +
+            "n.范围={range}," +
+            "n.单位={unit}, " +
+            "n.实验室检查指标={indication} " +
+            "return n")
+    Lis 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);
+
 }

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

@@ -0,0 +1,15 @@
+package com.diagbot.repository;
+
+import com.diagbot.entity.node.OralMedicine;
+import org.springframework.data.neo4j.repository.Neo4jRepository;
+
+import java.util.List;
+
+/**
+ * @Description:
+ * @Author:zhaops
+ * @time: 2020/11/26 10:08
+ */
+public interface OralMedicineRepository extends Neo4jRepository<OralMedicine,Long> {
+    List<OralMedicine> findByNameIs(String name);
+}

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

@@ -0,0 +1,15 @@
+package com.diagbot.repository;
+
+import com.diagbot.entity.node.PacsDescribe;
+import org.springframework.data.neo4j.repository.Neo4jRepository;
+
+import java.util.List;
+
+/**
+ * @Description:
+ * @Author:zhaops
+ * @time: 2020/11/26 10:10
+ */
+public interface PacsDescribeRepository extends Neo4jRepository<PacsDescribe,Long> {
+    List<PacsDescribe> findByNameIs(String name);
+}

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

@@ -3,19 +3,71 @@ package com.diagbot.repository;
 import com.diagbot.dto.BillNeoDTO;
 import com.diagbot.dto.PacsBillNeoDTO;
 import com.diagbot.entity.BaseNodeInfo;
+import com.diagbot.entity.node.Allergen;
 import com.diagbot.entity.node.BillConflictItem;
 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.PacsName;
-import com.diagbot.entity.relationship.*;
-import com.diagbot.entity.relationship.base.BaseRelation;
+import com.diagbot.entity.node.Vital;
+import com.diagbot.entity.relationship.PacsNameAllergen;
+import com.diagbot.entity.relationship.PacsNameBillConflictItem;
+import com.diagbot.entity.relationship.PacsNameClinicalFinding;
+import com.diagbot.entity.relationship.PacsNameConflictDevice;
+import com.diagbot.entity.relationship.PacsNameDisease;
+import com.diagbot.entity.relationship.PacsNameGender;
+import com.diagbot.entity.relationship.PacsNameGroup;
+import com.diagbot.entity.relationship.PacsNameLis;
+import com.diagbot.entity.relationship.PacsNameMedAllergen;
+import com.diagbot.entity.relationship.PacsNameOralMedicine;
+import com.diagbot.entity.relationship.PacsNamePacsDescribe;
+import com.diagbot.entity.relationship.PacsNameVital;
 import com.diagbot.util.ListUtil;
 import com.diagbot.util.NeoUtil;
+import org.springframework.beans.factory.annotation.Autowired;
 
-import java.util.*;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
 import java.util.stream.Collectors;
 
 public class PacsNameNode {
 
+    @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(PacsName pacs) {
         PacsBillNeoDTO pacsBillNeoDTO = new PacsBillNeoDTO();
@@ -409,6 +461,308 @@ public class PacsNameNode {
         }
     }
 
+    /**
+     * 更新关系状态属性
+     */
+    public void updateRelationExt(PacsName pacsName, String relname, Integer status, Integer ruleType, String e_name, PacsNameRepository pacsNameRepository) {
+        Boolean isExist = false;
+        try {
+            switch (relname) {
+                case "辅助检查名称禁忌性别":
+                    Gender gender = genderRepository.findByNameIs(e_name).get(0);
+                    PacsNameGender pacsNameGender = new PacsNameGender();
+                    pacsNameGender.setGender(gender);
+                    pacsNameGender.setPacsName(pacsName);
+                    pacsNameGender.setStatus(status);
+                    pacsNameGender.setRuleType(ruleType);
+                    pacsName.setPacsNameGender(pacsNameGender);
+                    pacsNameRepository.save(pacsName, 1);
+                    break;
+                case "辅助检查名称禁忌禁忌人群":
+                    Group group = groupRepository.findByNameIs(e_name).get(0);
+                    Set<PacsNameGroup> pacsNameGroupSet = pacsName.getPacsNameGroups();
+                    isExist = false;
+                    for (PacsNameGroup item : pacsNameGroupSet) {
+                        if (item.getGroup() != null
+                                && item.getGroup().getName().equals(e_name)) {
+                            isExist = true;
+                            item.setPacsName(pacsName);
+                            item.setGroup(group);
+                            item.setStatus(status);
+                            item.setRuleType(ruleType);
+                        }
+                    }
+                    if (!isExist) {
+                        PacsNameGroup pacsNameGroup = new PacsNameGroup();
+                        pacsNameGroup.setGroup(group);
+                        pacsNameGroup.setPacsName(pacsName);
+                        pacsNameGroup.setStatus(status);
+                        pacsNameGroup.setRuleType(ruleType);
+                        pacsNameGroupSet.add(pacsNameGroup);
+                    }
+                    pacsName.setPacsNameGroups(pacsNameGroupSet);
+                    pacsNameRepository.save(pacsName, 1);
+                    break;
+                case "辅助检查名称禁忌药物过敏原":
+                    MedAllergen medAllergen = medAllergenRepository.findByNameIs(e_name).get(0);
+                    Set<PacsNameMedAllergen> pacsNameMedAllergenSet = pacsName.getPacsNameMedallergens();
+                    isExist = false;
+                    for (PacsNameMedAllergen item : pacsNameMedAllergenSet) {
+                        if (item.getMedAllergen() != null
+                                && item.getMedAllergen().getName().equals(e_name)) {
+                            isExist = true;
+                            item.setPacsName(pacsName);
+                            item.setMedAllergen(medAllergen);
+                            item.setStatus(status);
+                            item.setRuleType(ruleType);
+                        }
+                    }
+                    if (!isExist) {
+                        PacsNameMedAllergen pacsNameMedAllergen = new PacsNameMedAllergen();
+                        pacsNameMedAllergen.setMedAllergen(medAllergen);
+                        pacsNameMedAllergen.setPacsName(pacsName);
+                        pacsNameMedAllergen.setStatus(status);
+                        pacsNameMedAllergen.setRuleType(ruleType);
+                        pacsNameMedAllergenSet.add(pacsNameMedAllergen);
+                    }
+                    pacsName.setPacsNameMedallergens(pacsNameMedAllergenSet);
+                    pacsNameRepository.save(pacsName, 1);
+                    break;
+                case "辅助检查名称禁忌临床表现":
+                    ClinicalFinding clinicalFinding = clinicalFindingRepository.findByNameIs(e_name).get(0);
+                    Set<PacsNameClinicalFinding> pacsNameClinicalFindingSet = pacsName.getPacsNameClinicalfindings();
+                    isExist = false;
+                    for (PacsNameClinicalFinding item : pacsNameClinicalFindingSet) {
+                        if (item.getClinicalFinding() != null
+                                && item.getClinicalFinding().getName().equals(e_name)) {
+                            isExist = true;
+                            item.setPacsName(pacsName);
+                            item.setClinicalFinding(clinicalFinding);
+                            item.setStatus(status);
+                            item.setRuleType(ruleType);
+                        }
+                    }
+                    if (!isExist) {
+                        PacsNameClinicalFinding pacsNameClinicalFinding = new PacsNameClinicalFinding();
+                        pacsNameClinicalFinding.setClinicalFinding(clinicalFinding);
+                        pacsNameClinicalFinding.setPacsName(pacsName);
+                        pacsNameClinicalFinding.setStatus(status);
+                        pacsNameClinicalFinding.setRuleType(ruleType);
+                        pacsNameClinicalFindingSet.add(pacsNameClinicalFinding);
+                    }
+                    pacsName.setPacsNameClinicalfindings(pacsNameClinicalFindingSet);
+                    pacsNameRepository.save(pacsName, 1);
+                    break;
+                case "辅助检查名称禁忌实验室检查名称":
+                    break;
+                case "辅助检查名称禁忌实验室检查":
+                    Lis lis = lisRepository.findByNameIs(e_name).get(0);
+                    Set<PacsNameLis> pacsNameLisSet = pacsName.getPacsNameLis();
+                    isExist = false;
+                    for (PacsNameLis item : pacsNameLisSet) {
+                        if (item.getLis() != null
+                                && item.getLis().getName().equals(e_name)) {
+                            isExist = true;
+                            item.setPacsName(pacsName);
+                            item.setLis(lis);
+                            item.setStatus(status);
+                            item.setRuleType(ruleType);
+                        }
+                    }
+                    if (!isExist) {
+                        PacsNameLis pacsNameLis = new PacsNameLis();
+                        pacsNameLis.setLis(lis);
+                        pacsNameLis.setPacsName(pacsName);
+                        pacsNameLis.setStatus(status);
+                        pacsNameLis.setRuleType(ruleType);
+                        pacsNameLisSet.add(pacsNameLis);
+                    }
+                    pacsName.setPacsNameLis(pacsNameLisSet);
+                    pacsNameRepository.save(pacsName, 1);
+                    break;
+                case "辅助检查名称禁忌疾病":
+                    Disease disease = diseaseRepository.findByNameIs(e_name).get(0);
+                    Set<PacsNameDisease> pacsNameDiseaseSet = pacsName.getPacsNameDiseases();
+                    isExist = false;
+                    for (PacsNameDisease item : pacsNameDiseaseSet) {
+                        if (item.getDisease() != null
+                                && item.getDisease().getName().equals(e_name)) {
+                            isExist = true;
+                            item.setPacsName(pacsName);
+                            item.setDisease(disease);
+                            item.setStatus(status);
+                            item.setRuleType(ruleType);
+                        }
+                    }
+                    if (!isExist) {
+                        PacsNameDisease pacsNameDisease = new PacsNameDisease();
+                        pacsNameDisease.setDisease(disease);
+                        pacsNameDisease.setPacsName(pacsName);
+                        pacsNameDisease.setStatus(status);
+                        pacsNameDisease.setRuleType(ruleType);
+                        pacsNameDiseaseSet.add(pacsNameDisease);
+                    }
+                    pacsName.setPacsNameDiseases(pacsNameDiseaseSet);
+                    pacsNameRepository.save(pacsName, 1);
+                    break;
+                case "辅助检查名称禁忌禁忌医疗器械及物品":
+                    ConflictDevice conflictDevice = conflictDeviceRepository.findByNameIs(e_name).get(0);
+                    Set<PacsNameConflictDevice> pacsNameConflictDeviceSet = pacsName.getPacsNameConflictdevices();
+                    isExist = false;
+                    for (PacsNameConflictDevice item : pacsNameConflictDeviceSet) {
+                        if (item.getConflictDevice() != null
+                                && item.getConflictDevice().getName().equals(e_name)) {
+                            isExist = true;
+                            item.setPacsName(pacsName);
+                            item.setConflictDevice(conflictDevice);
+                            item.setStatus(status);
+                            item.setRuleType(ruleType);
+                        }
+                    }
+                    if (!isExist) {
+                        PacsNameConflictDevice pacsNameConflictDevice = new PacsNameConflictDevice();
+                        pacsNameConflictDevice.setConflictDevice(conflictDevice);
+                        pacsNameConflictDevice.setPacsName(pacsName);
+                        pacsNameConflictDevice.setStatus(status);
+                        pacsNameConflictDevice.setRuleType(ruleType);
+                        pacsNameConflictDeviceSet.add(pacsNameConflictDevice);
+                    }
+                    pacsName.setPacsNameConflictdevices(pacsNameConflictDeviceSet);
+                    pacsNameRepository.save(pacsName, 1);
+                    break;
+                case "辅助检查名称禁忌体征":
+                    Vital vital = vitalRepository.findByNameIs(e_name).get(0);
+                    Set<PacsNameVital> pacsNameVitalSet = pacsName.getPacsNameVitals();
+                    isExist = false;
+                    for (PacsNameVital item : pacsNameVitalSet) {
+                        if (item.getVital() != null
+                                && item.getVital().getName().equals(e_name)) {
+                            isExist = true;
+                            item.setPacsName(pacsName);
+                            item.setVital(vital);
+                            item.setStatus(status);
+                            item.setRuleType(ruleType);
+                        }
+                    }
+                    if (!isExist) {
+                        PacsNameVital pacsNameVital = new PacsNameVital();
+                        pacsNameVital.setVital(vital);
+                        pacsNameVital.setPacsName(pacsName);
+                        pacsNameVital.setStatus(status);
+                        pacsNameVital.setRuleType(ruleType);
+                        pacsNameVitalSet.add(pacsNameVital);
+                    }
+                    pacsName.setPacsNameVitals(pacsNameVitalSet);
+                    pacsNameRepository.save(pacsName, 1);
+                    break;
+                case "辅助检查名称禁忌服用药品":
+                    OralMedicine oralMedicine = oralMedicineRepository.findByNameIs(e_name).get(0);
+                    Set<PacsNameOralMedicine> pacsNameOralMedicineSet = pacsName.getPacsNameOralmedicines();
+                    isExist = false;
+                    for (PacsNameOralMedicine item : pacsNameOralMedicineSet) {
+                        if (item.getOralMedicine() != null
+                                && item.getOralMedicine().getName().equals(e_name)) {
+                            isExist = true;
+                            item.setPacsName(pacsName);
+                            item.setOralMedicine(oralMedicine);
+                            item.setStatus(status);
+                            item.setRuleType(ruleType);
+                        }
+                    }
+                    if (!isExist) {
+                        PacsNameOralMedicine pacsNameOralMedicine = new PacsNameOralMedicine();
+                        pacsNameOralMedicine.setOralMedicine(oralMedicine);
+                        pacsNameOralMedicine.setPacsName(pacsName);
+                        pacsNameOralMedicine.setStatus(status);
+                        pacsNameOralMedicine.setRuleType(ruleType);
+                        pacsNameOralMedicineSet.add(pacsNameOralMedicine);
+                    }
+                    pacsName.setPacsNameOralmedicines(pacsNameOralMedicineSet);
+                    pacsNameRepository.save(pacsName, 1);
+                    break;
+                case "辅助检查名称禁忌辅助检查名称描述":
+                    PacsDescribe pacsDescribe = pacsDescribeRepository.findByNameIs(e_name).get(0);
+                    Set<PacsNamePacsDescribe> pacsNamePacsDescribeSet = pacsName.getPacsNamePacsdescribes();
+                    isExist = false;
+                    for (PacsNamePacsDescribe item : pacsNamePacsDescribeSet) {
+                        if (item.getPacsDescribe() != null
+                                && item.getPacsDescribe().getName().equals(e_name)) {
+                            isExist = true;
+                            item.setPacsName(pacsName);
+                            item.setPacsDescribe(pacsDescribe);
+                            item.setStatus(status);
+                            item.setRuleType(ruleType);
+                        }
+                    }
+                    if (!isExist) {
+                        PacsNamePacsDescribe pacsNamePacsDescribe = new PacsNamePacsDescribe();
+                        pacsNamePacsDescribe.setPacsDescribe(pacsDescribe);
+                        pacsNamePacsDescribe.setPacsName(pacsName);
+                        pacsNamePacsDescribe.setStatus(status);
+                        pacsNamePacsDescribe.setRuleType(ruleType);
+                        pacsNamePacsDescribeSet.add(pacsNamePacsDescribe);
+                    }
+                    pacsName.setPacsNamePacsdescribes(pacsNamePacsDescribeSet);
+                    pacsNameRepository.save(pacsName, 1);
+                    break;
+                case "辅助检查名称禁忌过敏原":
+                    Allergen allergen = allergenRepository.findByNameIs(e_name).get(0);
+                    Set<PacsNameAllergen> pacsNameAllergenSet = pacsName.getPacsNameAllergens();
+                    isExist = false;
+                    for (PacsNameAllergen item : pacsNameAllergenSet) {
+                        if (item.getAllergen() != null
+                                && item.getAllergen().getName().equals(e_name)) {
+                            isExist = true;
+                            item.setPacsName(pacsName);
+                            item.setAllergen(allergen);
+                            item.setStatus(status);
+                            item.setRuleType(ruleType);
+                        }
+                    }
+                    if (!isExist) {
+                        PacsNameAllergen pacsNameAllergen = new PacsNameAllergen();
+                        pacsNameAllergen.setAllergen(allergen);
+                        pacsNameAllergen.setPacsName(pacsName);
+                        pacsNameAllergen.setStatus(status);
+                        pacsNameAllergen.setRuleType(ruleType);
+                        pacsNameAllergenSet.add(pacsNameAllergen);
+                    }
+                    pacsName.setPacsNameAllergens(pacsNameAllergenSet);
+                    pacsNameRepository.save(pacsName, 1);
+                    break;
+                case "辅助检查名称禁忌开单项互斥":
+                    BillConflictItem billConflictItem = billConflictItemRepository.findByNameIs(e_name).get(0);
+                    Set<PacsNameBillConflictItem> pacsNameBillConflictItemSet = pacsName.getPacsNameBillConflictItems();
+                    isExist = false;
+                    for (PacsNameBillConflictItem item : pacsNameBillConflictItemSet) {
+                        if (item.getBillConflictItem() != null
+                                && item.getBillConflictItem().getName().equals(e_name)) {
+                            isExist = true;
+                            item.setPacsName(pacsName);
+                            item.setBillConflictItem(billConflictItem);
+                            item.setStatus(status);
+                            item.setRuleType(ruleType);
+                        }
+                    }
+                    if (!isExist) {
+                        PacsNameBillConflictItem pacsNameBillConflictItem = new PacsNameBillConflictItem();
+                        pacsNameBillConflictItem.setBillConflictItem(billConflictItem);
+                        pacsNameBillConflictItem.setPacsName(pacsName);
+                        pacsNameBillConflictItem.setStatus(status);
+                        pacsNameBillConflictItem.setRuleType(ruleType);
+                        pacsNameBillConflictItemSet.add(pacsNameBillConflictItem);
+                    }
+                    pacsName.setPacsNameBillConflictItems(pacsNameBillConflictItemSet);
+                    pacsNameRepository.save(pacsName, 1);
+                    break;
+            }
+        } catch (Exception ex) {
+            ex.printStackTrace();
+        } finally {
+
+        }
+    }
+
 }
 
 

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

@@ -1,6 +1,5 @@
 package com.diagbot.repository;
 
-import com.diagbot.entity.node.Symptom;
 import com.diagbot.entity.node.Vital;
 import org.springframework.data.neo4j.annotation.Query;
 import org.springframework.data.neo4j.repository.Neo4jRepository;
@@ -36,5 +35,34 @@ public interface VitalRepository extends Neo4jRepository<Vital, Long> {
     @Query("MATCH (n:体征) return distinct(n.name) as name LIMIT {size}")
     List<String> getVitalNames(@Param("size") Integer size);
 
+    @Query("merge (n:体征{name:{name}})  " +
+            "on create set  " +
+            "n.拼音编码={pycode}," +
+            "n.静态知识标识={is_kl}," +
+            "n.状态={status}," +
+            "n.最大值={maxValue}," +
+            "n.最小值={minValue}," +
+            "n.范围={range}," +
+            "n.单位={unit}, " +
+            "n.体征指标={indication} " +
+            "on match set  " +
+            "n.拼音编码={pycode}," +
+            "n.静态知识标识={is_kl}," +
+            "n.状态={status}," +
+            "n.最大值={maxValue}," +
+            "n.最小值={minValue}," +
+            "n.范围={range}," +
+            "n.单位={unit}, " +
+            "n.体征指标={indication} " +
+            "return n")
+    Vital 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);
 }