excel 编码、关联编码循环嵌套

jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/medical/ruleengine/FactorEnchangeFactory.java

@@ -83,7 +83,7 @@ public class FactorEnchangeFactory {
 
     public static Map<Integer, List<FactorCondRela>> factorCondRelaMap = new HashMap<>();
 
-    @PostConstruct
+//    @PostConstruct
     public void init() {
         List<EventAttr> eventAttrList = eventAttrService.lambdaQuery().eq(EventAttr::getDelFlag, CommonConstant.DEL_FLAG_0).list();
         enchanceAttrMap = eventAttrList.stream().collect(Collectors.toMap(EventAttr::getId, v -> v, (v1, v2) -> v1));

jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/medical/ruleengine/RuleEngine.java

@@ -141,7 +141,7 @@ public class RuleEngine {
     public static List<Integer> advanceWaringRuleIdList = new ArrayList<>();
     public static Map<String, Set<Integer>> itemCodeAndRuleIdMap = new HashMap<>();
 
-    @PostConstruct
+//    @PostConstruct
     public void initMedicalInsRule() {
         List<MedicalInsRuleInfo> medicalInsRuleInfoList = medicalInsRuleInfoService.lambdaQuery().eq(MedicalInsRuleInfo::getState, Constant.EFF_STATE).list();
         if (!CollectionUtil.isNotEmpty(medicalInsRuleInfoList)) {

jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/medical/ruleengine/projectcache/HisMedicalProjectCache.java

@@ -1,19 +1,26 @@
 package org.jeecg.modules.medical.ruleengine.projectcache;
 
+import cn.hutool.core.collection.CollectionUtil;
+import com.alibaba.fastjson.JSON;
+import com.alibaba.fastjson.JSONObject;
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.baomidou.mybatisplus.core.metadata.IPage;
 import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
 import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.lang.StringUtils;
+import org.jeecg.common.api.vo.Result;
+import org.jeecg.common.constant.CommonConstant;
+import org.jeecg.common.util.DateUtils;
 import org.jeecg.modules.medical.Constant;
-import org.jeecg.modules.medical.entity.DiagnoseItems;
-import org.jeecg.modules.medical.entity.MaterialItems;
-import org.jeecg.modules.medical.entity.MedicalInsuranceDrugs;
-import org.jeecg.modules.medical.entity.OperativeItems;
-import org.jeecg.modules.medical.entity.TreatmentItems;
-import org.jeecg.modules.medical.service.IDiagnoseItemsService;
-import org.jeecg.modules.medical.service.IMaterialItemsService;
-import org.jeecg.modules.medical.service.IMedicalInsuranceDrugsService;
-import org.jeecg.modules.medical.service.IOperativeItemsService;
-import org.jeecg.modules.medical.service.ITreatmentItemsService;
+import org.jeecg.modules.medical.SystemEventAttrConstant;
+import org.jeecg.modules.medical.entity.*;
+import org.jeecg.modules.medical.ruleengine.FactorEnchangeFactory;
+import org.jeecg.modules.medical.ruleengine.SPELUtil;
+import org.jeecg.modules.medical.ruleengine.SqlUtil;
+import org.jeecg.modules.medical.ruleengine.dict.DictUtil;
+import org.jeecg.modules.medical.ruleengine.plugin.InterfItemListPlugin;
+import org.jeecg.modules.medical.service.*;
+import org.jeecg.modules.message.websocket.WebSocket;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.data.redis.core.HashOperations;
 import org.springframework.data.redis.core.RedisTemplate;
@@ -21,9 +28,10 @@ import org.springframework.scheduling.annotation.Async;
 import org.springframework.stereotype.Component;
 
 import javax.annotation.PostConstruct;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
+import java.math.BigDecimal;
+import java.text.ParseException;
+import java.util.*;
+import java.util.stream.Collectors;
 
 /**
  * 医保和医院项目编码映射
@@ -31,19 +39,92 @@ import java.util.Map;
 @Slf4j
 @Component
 public class HisMedicalProjectCache {
+
     @Autowired
-    RedisTemplate redisTemplate;
+    private IMedicalInsRuleInfoService medicalInsRuleInfoService;
     @Autowired
-    IMedicalInsuranceDrugsService medicalInsuranceDrugsService;
+    private IFactorEnchanceService factorEnchanceService;
+    //    @Autowired
+//    private IEventAttrService eventAttrService;
+//    @Autowired
+//    private IFactorAttrRelaService factorAttrRelaService;
+//    @Autowired
+//    private IFactorCondRelaService factorCondRelaService;
     @Autowired
-    ITreatmentItemsService treatmentItemsService;
+    private IMedicalInsRuleProjectService medicalInsRuleProjectService;
+    @Autowired
+    private IRuleFactorRelaService ruleFactorRelaService;
+    @Autowired
+    private FactorEnchangeFactory factorEnchangeFactory;
+    @Autowired
+    private IRuleAttrService ruleAttrService;
+
+    @Autowired
+    private RedisTemplate redisTemplate;
+    @Autowired
+    InterfItemListPlugin interfItemListPlugin;
+    @Autowired
+    IMidIncidentAuditService midIncidentAuditService;
+    @Autowired
+    IMidIncidentAuditDiagnoseService midIncidentAuditDiagnoseService;
+    @Autowired
+    IMidIncidentVisitLogService midIncidentVisitLogService;
+    @Autowired
+    IMidIncidentVisitDetailLogService midIncidentVisitDetailLogService;
+    @Autowired
+    IAfterwardsAuditService afterwardsAuditService;
+    @Autowired
+    IAfterwardsAuditDetailService afterwardsAuditDetailService;
+    @Autowired
+    IAfterwardsIncidentAuditDiagnoseService afterwardsIncidentAuditDiagnoseService;
+    @Autowired
+    IMedicalInsRuleProjectDiagnoseService medicalInsRuleProjectDiagnoseService;
+    @Autowired
+    IAdvanceWarningAuditService advanceWarningAuditService;
+    @Autowired
+    IAdvanceWarningAuditDetailService advanceWarningAuditDetailService;
+    @Autowired
+    DictUtil dictUtil;
+    @Autowired
+    WebSocket webSocket;
     @Autowired
     IMaterialItemsService materialItemsService;
     @Autowired
+    ITreatmentItemsService treatmentItemsService;
+    @Autowired
+    IMedicalInsuranceDrugsService medicalInsuranceDrugsService;
+    @Autowired
     IDiagnoseItemsService diagnoseItemsService;
+
+    public static ThreadLocal<MidIncidentWarningVO> midIncidentWarningVOThreadLocal = new ThreadLocal<>();
+
+    public static Map<String, List<RuleAttr>> interfRuleAttrList = new HashMap<>();
+    public static List<Integer> advanceWaringRuleIdList = new ArrayList<>();
+    public static Map<String, Set<Integer>> itemCodeAndRuleIdMap = new HashMap<>();
+
     @Autowired
     IOperativeItemsService operativeItemsService;
 
+
+
+    @Autowired
+    SPELUtil spelUtil;
+    @Autowired
+    IFactorAttrRelaService factorAttrRelaService;
+    @Autowired
+    IEventAttrService eventAttrService;
+    @Autowired
+    IFactorCondRelaService factorCondRelaService;
+
+    @Autowired
+    IMidIncidentAuditDetailService midIncidentAuditDetailService;
+
+    @Autowired
+    SqlUtil sqlUtil;
+
+    public static Map<Integer, EventAttr> enchanceAttrMap = new HashMap<>();
+
+    public static Map<Integer, List<FactorCondRela>> factorCondRelaMap = new HashMap<>();
 //    @PostConstruct
     public void initHisMedicalProjectCache() {
         long count = medicalInsuranceDrugsService.lambdaQuery().isNotNull(MedicalInsuranceDrugs::getItemIdHosp).isNotNull(MedicalInsuranceDrugs::getMedicineCode).count();
@@ -106,8 +187,47 @@ public class HisMedicalProjectCache {
                 asyncOperativeItems(i);
             }
         }
+
+        init();
+        initMedicalInsRule();
+    }
+    public void init() {
+        List<EventAttr> eventAttrList = eventAttrService.lambdaQuery().eq(EventAttr::getDelFlag, CommonConstant.DEL_FLAG_0).list();
+        enchanceAttrMap = eventAttrList.stream().collect(Collectors.toMap(EventAttr::getId, v -> v, (v1, v2) -> v1));
+        List<FactorCondRela> factorCondRelaList = factorCondRelaService.lambdaQuery().orderByAsc(FactorCondRela::getSeqNum).list();
+        factorCondRelaMap = factorCondRelaList.stream().collect(Collectors.groupingBy(FactorCondRela::getFactorEnhanceId));
     }
 
+
+    public void initMedicalInsRule() {
+        List<MedicalInsRuleInfo> medicalInsRuleInfoList = medicalInsRuleInfoService.lambdaQuery().eq(MedicalInsRuleInfo::getState, Constant.EFF_STATE).list();
+        if (!CollectionUtil.isNotEmpty(medicalInsRuleInfoList)) {
+            log.error("规则配置表没有有效的规则");
+            return;
+        }
+        /*
+         * 根据规则id加载规则并初始化到redis里
+         * 后续提醒通过redis加载id，把id传入规则引擎，迅速调用对应规则
+         */
+        List<MedicalInsRuleInfo> midMedicalInsRuleInfoList = new ArrayList<>();
+        Map<Integer, MedicalInsRuleInfo> medicalMap = new HashMap<>();
+        for (MedicalInsRuleInfo medicalInsRuleInfo : medicalInsRuleInfoList) {
+            medicalMap.put(medicalInsRuleInfo.getId(), medicalInsRuleInfo);
+            if (Constant.TREATMEN_TYPE_ADVANCE_WARNING.equals(medicalInsRuleInfo.getCallScenario())) {
+                advanceWaringRuleIdList.add(medicalInsRuleInfo.getId());
+            } else
+//                if (Constant.TREATMEN_TYPE_MID_INCIDENT_WARNING.equals(medicalInsRuleInfo.getCallScenario())
+//                    || Constant.TREATMEN_TYPE_MID_EX_POST_SUPERVISION.equals(medicalInsRuleInfo.getCallScenario()))
+            {
+                midMedicalInsRuleInfoList.add(medicalInsRuleInfo);
+            }
+        }
+
+        genItemCodeAndRuleIdMap(midMedicalInsRuleInfoList);
+        List<RuleAttr> ruleAttrList = ruleAttrService.list();
+        interfRuleAttrList = ruleAttrList.stream().collect(Collectors.groupingBy(RuleAttr::getInterfName));
+
+    }
     public <R> R loadHisMedicalMapping(String medicalProjectCode) {
         HashOperations hashOperations = redisTemplate.opsForHash();
         R o = (R) hashOperations.get(Constant.HIS_MEDICAL_DICT_KEY, medicalProjectCode);
@@ -224,4 +344,929 @@ public class HisMedicalProjectCache {
             log.error(e.getMessage(), e);
         }
     }
+    public void genItemCodeAndRuleIdMap(List<MedicalInsRuleInfo> medicalInsRuleInfoList) {
+
+
+        try {
+        Map<String, Set<Integer>> ruleItemCodeAndRuleIdMap = new HashMap<>();
+
+        List<Integer> ruleIdList = medicalInsRuleInfoList.stream().map(MedicalInsRuleInfo::getId).collect(Collectors.toList());
+        for (Integer medicalInsInfoId : ruleIdList) {
+            List<MedicalInsRuleProject> medicalInsRuleProjectList = medicalInsRuleProjectService.lambdaQuery().eq(MedicalInsRuleProject::getMedicalInsRuleInfoId, medicalInsInfoId).list();
+            if (CollectionUtil.isNotEmpty(medicalInsRuleProjectList)) {
+                MedicalInsRuleProject medicalInsRuleProject = null;
+                Set<String> consumableProjectCodeList = new HashSet<>();
+                Set<String> restorativesProjectCodeList = new HashSet<>();
+                Set<String> treatmentProjectCodeList = new HashSet<>();
+                Map<String, String> ruleIdAndCodeMap = new HashMap<>();
+                for (int index = 0; index < medicalInsRuleProjectList.size(); index++) {
+                    medicalInsRuleProject = medicalInsRuleProjectList.get(index);
+                    String projectCode = medicalInsRuleProject.getProjectCode();
+                    String correlationProjectCode = medicalInsRuleProject.getCorrelationProjectCode();
+                    if (StringUtils.isNotBlank(projectCode)) {
+                        if (StringUtils.isNotBlank(medicalInsRuleProject.getViolationDesc())) {
+                            ruleIdAndCodeMap.put(medicalInsInfoId + "_" + projectCode, medicalInsRuleProject.getViolationDesc());
+                        }
+                        if (projectCode.startsWith(Constant.CONSUMABLE_START_KEY)) {
+                            consumableProjectCodeList.add(projectCode);
+                        } else if (projectCode.startsWith(Constant.RESTORATIVES_T_START_KEY) ||
+                                projectCode.startsWith(Constant.RESTORATIVES_X_START_KEY) ||
+                                projectCode.startsWith(Constant.RESTORATIVES_Z_START_KEY)) {
+                            restorativesProjectCodeList.add(projectCode);
+                            //耗材都是字母c开头， 药品是X或Z T， 医疗服务是数字开头
+                        } else if (SPELUtil.isNumeric(projectCode)) {
+                            treatmentProjectCodeList.add(projectCode);
+                        }
+                        if (ruleItemCodeAndRuleIdMap.containsKey(projectCode)) {
+                            ruleItemCodeAndRuleIdMap.get(projectCode).add(medicalInsRuleProject.getMedicalInsRuleInfoId());
+                        } else {
+                            Set<Integer> ruleIdSet = new HashSet<>();
+                            ruleIdSet.add(medicalInsRuleProject.getMedicalInsRuleInfoId());
+                            ruleItemCodeAndRuleIdMap.put(projectCode, ruleIdSet);
+                        }
+                    }
+                    if (StringUtils.isNotBlank(correlationProjectCode)) {
+                        if (correlationProjectCode.startsWith(Constant.CONSUMABLE_START_KEY)) {
+                            consumableProjectCodeList.add(correlationProjectCode);
+                        } else if (correlationProjectCode.startsWith(Constant.RESTORATIVES_T_START_KEY) ||
+                                correlationProjectCode.startsWith(Constant.RESTORATIVES_X_START_KEY) ||
+                                correlationProjectCode.startsWith(Constant.RESTORATIVES_Z_START_KEY)) {
+                            restorativesProjectCodeList.add(correlationProjectCode);
+                            //耗材都是字母c开头， 药品是X或Z T， 医疗服务是数字开头
+                        } else if (SPELUtil.isNumeric(correlationProjectCode)) {
+                            treatmentProjectCodeList.add(correlationProjectCode);
+                        }
+                        if (ruleItemCodeAndRuleIdMap.containsKey(correlationProjectCode)) {
+                            ruleItemCodeAndRuleIdMap.get(correlationProjectCode).add(medicalInsRuleProject.getMedicalInsRuleInfoId());
+                        } else {
+                            Set<Integer> ruleIdSet = new HashSet<>();
+                            ruleIdSet.add(medicalInsRuleProject.getMedicalInsRuleInfoId());
+                            ruleItemCodeAndRuleIdMap.put(correlationProjectCode, ruleIdSet);
+                        }
+                    }
+
+
+                }
+                setCache(consumableProjectCodeList, ruleItemCodeAndRuleIdMap, ruleIdAndCodeMap, Constant.PROJECT_TYPE_CONSUMABLE_METERIAL);
+                setCache(restorativesProjectCodeList, ruleItemCodeAndRuleIdMap, ruleIdAndCodeMap, Constant.PROJECT_TYPE_MEDICINE);
+                setCache(treatmentProjectCodeList, ruleItemCodeAndRuleIdMap, ruleIdAndCodeMap, Constant.PROJECT_TYPE_DIAGNOSIS_TREATMENT);
+
+            }
+        }
+
+
+        for (MedicalInsRuleInfo medicalInsRuleInfo : medicalInsRuleInfoList) {
+            if (StringUtils.isNotBlank(medicalInsRuleInfo.getSelectedRoles())) {
+                String[] rolesArr = medicalInsRuleInfo.getSelectedRoles().split(",");
+                boolean medicalDiagnoseCodeFlag = Arrays.stream(rolesArr).anyMatch(role -> role.equals("medicalDiagnoseCode"));
+                boolean cMedicalDiagnoseCodeFlag = Arrays.stream(rolesArr).anyMatch(role -> role.equals("correlationMedicalDiagnoseCode"));
+                boolean projectCodeFlag = Arrays.stream(rolesArr).anyMatch(role -> role.equals("projectCode"));
+                boolean correlationProjectCodeFlag = Arrays.stream(rolesArr).anyMatch(role -> role.equals("correlationProjectCode"));
+                if ((!projectCodeFlag && medicalDiagnoseCodeFlag) || (!correlationProjectCodeFlag && cMedicalDiagnoseCodeFlag)) {
+                    List<MedicalInsRuleProjectDiagnose> medicalInsRuleProjectDiagnoseList = medicalInsRuleProjectDiagnoseService.lambdaQuery().eq(MedicalInsRuleProjectDiagnose::getMedicalInsRuleInfoId, medicalInsRuleInfo.getId()).list();
+                    if (CollectionUtil.isNotEmpty(medicalInsRuleProjectDiagnoseList)) {
+                        Set<String> treatmentProjectCodeList = new HashSet<>();
+                        for (MedicalInsRuleProjectDiagnose medicalInsRuleProjectDiagnose : medicalInsRuleProjectDiagnoseList) {
+                            if (ruleItemCodeAndRuleIdMap.containsKey(medicalInsRuleProjectDiagnose.getMedicalDiagnoseCode())) {
+                                ruleItemCodeAndRuleIdMap.get(medicalInsRuleProjectDiagnose.getMedicalDiagnoseCode()).add(medicalInsRuleInfo.getId());
+                            } else {
+                                Set<Integer> ruleIdSet = new HashSet<>();
+                                ruleIdSet.add(medicalInsRuleInfo.getId());
+                                ruleItemCodeAndRuleIdMap.put(medicalInsRuleProjectDiagnose.getMedicalDiagnoseCode(), ruleIdSet);
+                            }
+                            treatmentProjectCodeList.add(medicalInsRuleProjectDiagnose.getMedicalDiagnoseCode());
+                        }
+                        setCache(treatmentProjectCodeList, ruleItemCodeAndRuleIdMap, null, Constant.PROJECT_TYPE_DIAG_CODE);
+                    }
+                }
+            }
+        }
+    } catch (Exception e) {
+        log.error(e.getMessage(), e);
+    }
+}
+
+
+    //    public boolean initTestMedicalInsRule(String medicalProjectCode, AfterwardsAuditDetail afterwardsAuditDetail,List<MedicalInsRuleInfo> medicalInsRuleInfoList,Map<Integer, MedicalInsRuleInfo> medicalMap,Map<String, Boolean> codeDataMap) {
+//        return genItemCodeAndRuleIdMapTest(medicalProjectCode, medicalMap, afterwardsAuditDetail, medicalInsRuleInfoList);
+//    }
+    public void genItemCodeAndRuleIdMapTest(String medicalProjectCode, AfterwardsAuditDetail afterwardsAuditDetail, List<MedicalInsRuleInfo> medicalInsRuleInfoList, Map<Integer, MedicalInsRuleInfo> medicalMap, Map<String, Boolean> codeDataMap) {
+        try {
+            List<Integer> ruleIdList = medicalInsRuleInfoList.stream().map(MedicalInsRuleInfo::getId).collect(Collectors.toList());
+            List<MedicalInsRuleProject> medicalInsRuleProjectList = medicalInsRuleProjectService.lambdaQuery().in(MedicalInsRuleProject::getMedicalInsRuleInfoId, ruleIdList).list();
+            if(CollectionUtil.isEmpty(medicalInsRuleProjectList)){
+                return;
+            }
+            Map<Integer, List<MedicalInsRuleProject>> ruleIdAndMap = medicalInsRuleProjectList.stream().collect(Collectors.groupingBy(MedicalInsRuleProject::getMedicalInsRuleInfoId));
+            for (Integer medicalInsInfoId : ruleIdList) {
+
+                List<MedicalInsRuleProject> medicalInsRuleProjectListTemp = ruleIdAndMap.get(medicalInsInfoId);
+                if (CollectionUtil.isNotEmpty(medicalInsRuleProjectListTemp)) {
+                    for (MedicalInsRuleProject medicalInsRuleProject : medicalInsRuleProjectListTemp) {
+                        boolean startFlag = SPELUtil.startWithKey(medicalProjectCode, medicalInsRuleProject.getProjectCode());
+                        if (startFlag) {
+                            afterwardsAuditDetail.setMedicalInsRuleInfoId(medicalInsRuleProject.getMedicalInsRuleInfoId());
+                            MedicalInsRuleInfo medicalInsRuleInfo = medicalMap.get(medicalInsRuleProject.getMedicalInsRuleInfoId());
+                            afterwardsAuditDetail.setTreatmentType(medicalInsRuleInfo.getTreatmentType());
+                            afterwardsAuditDetail.setMedicalInsRuleInfoName(medicalInsRuleInfo.getRuleName());
+                            afterwardsAuditDetail.setMedicalInsRuleInfoCode(medicalInsRuleInfo.getRuleCode());
+                            if (StringUtils.isNotBlank(medicalInsRuleProject.getViolationDesc())) {
+                                afterwardsAuditDetail.setDescription(medicalInsRuleProject.getViolationDesc());
+                            } else {
+                                afterwardsAuditDetail.setDescription(medicalInsRuleInfo.getDescription());
+                            }
+                            codeDataMap.put(medicalProjectCode + "_" + medicalInsInfoId, true);
+
+                            return;
+                        }
+                        if (StringUtils.isNotBlank(medicalInsRuleProject.getCorrelationProjectCode())) {
+                            startFlag = SPELUtil.startWithKey(medicalProjectCode, medicalInsRuleProject.getCorrelationProjectCode());
+                            if (startFlag) {
+                                afterwardsAuditDetail.setMedicalInsRuleInfoId(medicalInsRuleProject.getMedicalInsRuleInfoId());
+                                MedicalInsRuleInfo medicalInsRuleInfo = medicalMap.get(medicalInsRuleProject.getMedicalInsRuleInfoId());
+                                afterwardsAuditDetail.setTreatmentType(medicalInsRuleInfo.getTreatmentType());
+                                afterwardsAuditDetail.setMedicalInsRuleInfoName(medicalInsRuleInfo.getRuleName());
+                                afterwardsAuditDetail.setMedicalInsRuleInfoCode(medicalInsRuleInfo.getRuleCode());
+                                if (StringUtils.isNotBlank(medicalInsRuleProject.getViolationDesc())) {
+                                    afterwardsAuditDetail.setDescription(medicalInsRuleProject.getViolationDesc());
+                                } else {
+                                    afterwardsAuditDetail.setDescription(medicalInsRuleInfo.getDescription());
+                                }
+                                codeDataMap.put(medicalProjectCode + "_" + medicalInsInfoId, true);
+
+                                return;
+                            }
+                        }
+                    }
+                }
+            }
+
+            codeDataMap.put(medicalProjectCode, false);
+
+        } catch (Exception e) {
+            log.error(e.getMessage(), e);
+        }
+
+    }
+
+
+    public void setDesc(Map<String, String> ruleIdAndCodeMap, String medicineCode, String projectCode, Set<Integer> medicalRuleInfoIdSet) {
+        if (CollectionUtil.isNotEmpty(ruleIdAndCodeMap)) {
+            for (Integer medicalRuleInfoId : medicalRuleInfoIdSet) {
+                if (ruleIdAndCodeMap.containsKey(medicalRuleInfoId + "_" + projectCode)) {
+                    String desc = ruleIdAndCodeMap.get(medicalRuleInfoId + "_" + projectCode);
+                    redisTemplate.opsForHash().put(Constant.PROJECT_VOLIDATION_DESC_KEY + medicalRuleInfoId, medicineCode, desc);
+                }
+            }
+        }
+    }
+
+    public void setCache(Set<String> projectCodeList, Map<String, Set<Integer>> ruleItemCodeAndRuleIdMap, Map<String, String> ruleIdAndCodeMap, String projectType) {
+        if (Constant.PROJECT_TYPE_MEDICINE.equals(projectType) && CollectionUtil.isNotEmpty(ruleItemCodeAndRuleIdMap)) {
+            List<MedicalInsuranceDrugs> medicalInsuranceDrugsList = medicalInsuranceDrugsService.lambdaQuery().isNotNull(MedicalInsuranceDrugs::getItemIdHosp).isNotNull(MedicalInsuranceDrugs::getMedicineCode).list();
+            if (CollectionUtil.isNotEmpty(medicalInsuranceDrugsList)) {
+                for (MedicalInsuranceDrugs medicalInsuranceDrugs : medicalInsuranceDrugsList) {
+                    for (String projectCode : projectCodeList) {
+                        boolean startFlag = SPELUtil.startWithKey(medicalInsuranceDrugs.getMedicineCode(), projectCode);
+                        if (startFlag) {
+                            Set<Integer> medicalRuleInfoIdSet = ruleItemCodeAndRuleIdMap.get(projectCode);
+                            if (CollectionUtil.isNotEmpty(medicalRuleInfoIdSet)) {
+                                itemCodeAndRuleIdMap.put(medicalInsuranceDrugs.getMedicineCode(), medicalRuleInfoIdSet);
+                                setDesc(ruleIdAndCodeMap, medicalInsuranceDrugs.getMedicineCode(), projectCode, medicalRuleInfoIdSet);
+                            }
+                        }
+                    }
+                }
+            }
+        } else if (Constant.PROJECT_TYPE_CONSUMABLE_METERIAL.equals(projectType) && CollectionUtil.isNotEmpty(ruleItemCodeAndRuleIdMap)) {
+            List<MaterialItems> materialItemsList = materialItemsService.lambdaQuery().isNotNull(MaterialItems::getItemIdHosp).isNotNull(MaterialItems::getItemId).list();
+            if (CollectionUtil.isNotEmpty(materialItemsList)) {
+                for (MaterialItems materialItems : materialItemsList) {
+                    for (String projectCode : projectCodeList) {
+                        boolean startFlag = SPELUtil.startWithKey(materialItems.getItemId(), projectCode);
+                        if (startFlag) {
+                            Set<Integer> medicalRuleInfoIdSet = ruleItemCodeAndRuleIdMap.get(projectCode);
+                            if (CollectionUtil.isNotEmpty(medicalRuleInfoIdSet)) {
+                                itemCodeAndRuleIdMap.put(materialItems.getItemId(), medicalRuleInfoIdSet);
+                                setDesc(ruleIdAndCodeMap, materialItems.getItemId(), projectCode, medicalRuleInfoIdSet);
+                            }
+                        }
+                    }
+                }
+            }
+        } else if (Constant.PROJECT_TYPE_DIAGNOSIS_TREATMENT.equals(projectType) && CollectionUtil.isNotEmpty(ruleItemCodeAndRuleIdMap)) {
+            List<TreatmentItems> treatmentItemsList = treatmentItemsService.lambdaQuery().isNotNull(TreatmentItems::getItemIdHosp).isNotNull(TreatmentItems::getItemId).list();
+            if (CollectionUtil.isNotEmpty(treatmentItemsList)) {
+                for (TreatmentItems treatmentItems : treatmentItemsList) {
+                    for (String projectCode : projectCodeList) {
+                        boolean startFlag = SPELUtil.startWithKey(treatmentItems.getItemId(), projectCode);
+                        if (startFlag) {
+                            Set<Integer> medicalRuleInfoIdSet = ruleItemCodeAndRuleIdMap.get(projectCode);
+                            if (CollectionUtil.isNotEmpty(medicalRuleInfoIdSet)) {
+                                itemCodeAndRuleIdMap.put(treatmentItems.getItemId(), medicalRuleInfoIdSet);
+                                setDesc(ruleIdAndCodeMap, treatmentItems.getItemId(), projectCode, medicalRuleInfoIdSet);
+                            }
+                        }
+                    }
+                }
+            }
+        } else if (Constant.PROJECT_TYPE_DIAG_CODE.equals(projectType) && CollectionUtil.isNotEmpty(ruleItemCodeAndRuleIdMap)) {
+            List<DiagnoseItems> diagnoseItemsList = diagnoseItemsService.lambdaQuery().isNotNull(DiagnoseItems::getDiagnoseCode).isNotNull(DiagnoseItems::getMedicalDiagnoseCode).list();
+            if (CollectionUtil.isNotEmpty(diagnoseItemsList)) {
+                for (DiagnoseItems diagnoseItems : diagnoseItemsList) {
+                    for (String projectCode : projectCodeList) {
+                        boolean startFlag = SPELUtil.startWithKey(diagnoseItems.getDiagnoseCode(), projectCode);
+                        if (startFlag) {
+                            Set<Integer> medicalRuleInfoIdSet = ruleItemCodeAndRuleIdMap.get(projectCode);
+                            if (CollectionUtil.isNotEmpty(medicalRuleInfoIdSet)) {
+                                itemCodeAndRuleIdMap.put(diagnoseItems.getDiagnoseCode(), medicalRuleInfoIdSet);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+    /**
+     * 根据关联的规则项目设置redis规则缓存
+     * 后续作为处方/医嘱快速匹配的索引
+     */
+    public void setMIDProjectCodeToRedis(MedicalInsRuleProject medicalInsRuleProject) {
+        redisTemplate.opsForHash().put(Constant.MEDICAL_RULE_CACHE_KEY + "_" + Constant.TREATMEN_TYPE_MID_INCIDENT_WARNING,
+                medicalInsRuleProject.getProjectCode(), medicalInsRuleProject.getMedicalInsRuleInfoId());
+        if (StringUtils.isNotBlank(medicalInsRuleProject.getCorrelationProjectCode())) {
+            redisTemplate.opsForHash().put(Constant.MEDICAL_RULE_CACHE_KEY + "_" + Constant.TREATMEN_TYPE_MID_INCIDENT_WARNING,
+                    medicalInsRuleProject.getCorrelationProjectCode(), medicalInsRuleProject.getMedicalInsRuleInfoId());
+        }
+    }
+
+    /**
+     * 事前提醒接口
+     *
+     * @param advanceWarningVO
+     * @param ipStr
+     * @return
+     */
+    public Result dealPreInterfaceEngin(AdvanceWarningVO advanceWarningVO, String ipStr) {
+        JSONObject sendJson = new JSONObject();
+        try {
+            String jsonStr = JSON.toJSONString(advanceWarningVO);
+            log.info("事中提醒接收报文:{}", jsonStr);
+            JSONObject paramMap = JSON.parseObject(jsonStr);
+
+            AdvanceWarningAudit advanceWarningAudit = insertAdvanceWarning(advanceWarningVO);
+            if (CollectionUtil.isEmpty(advanceWaringRuleIdList)) {
+                log.error("事前提醒未配置对应的提醒规则");
+                return Result.ok();
+            }
+            for (Integer medicalRuleInsInfoId : advanceWaringRuleIdList) {
+                MedicalInsRuleInfo medicalInsRuleInfo = medicalInsRuleInfoService.getById(medicalRuleInsInfoId);
+                paramMap.put(SystemEventAttrConstant.PRE_ADVANCEWARNINGAUDIT_ID_KEY, advanceWarningAudit.getId());
+                runAdvanceWaringEngine(paramMap, medicalInsRuleInfo, advanceWarningAudit);
+            }
+
+            sendJson.put("id", advanceWarningAudit.getId());
+        } catch (Exception e) {
+            log.error(e.getMessage(), e);
+        }
+
+        return Result.ok(sendJson);
+    }
+
+    /**
+     * 事前提醒接口
+     *
+     * @param advanceWarningVO
+     * @param ipStr
+     * @return
+     */
+    public Result dealPreInterfaceEnginSocket(AdvanceWarningVO advanceWarningVO, String ipStr) {
+
+        try {
+            String jsonStr = JSON.toJSONString(advanceWarningVO);
+            log.info("事中提醒接收报文:{}", jsonStr);
+            JSONObject paramMap = JSON.parseObject(jsonStr);
+
+            AdvanceWarningAudit advanceWarningAudit = insertAdvanceWarning(advanceWarningVO);
+            if (CollectionUtil.isEmpty(advanceWaringRuleIdList)) {
+                log.error("事前提醒未配置对应的提醒规则");
+                return Result.ok();
+            }
+            for (Integer medicalRuleInsInfoId : advanceWaringRuleIdList) {
+                MedicalInsRuleInfo medicalInsRuleInfo = medicalInsRuleInfoService.getById(medicalRuleInsInfoId);
+                paramMap.put(SystemEventAttrConstant.PRE_ADVANCEWARNINGAUDIT_ID_KEY, advanceWarningAudit.getId());
+                runAdvanceWaringEngine(paramMap, medicalInsRuleInfo, advanceWarningAudit);
+            }
+            JSONObject sendJson = new JSONObject();
+            sendJson.put("id", advanceWarningAudit.getId());
+            sendJson.put("type", "before");
+            webSocket.pushMessage(ipStr, sendJson.toJSONString());
+        } catch (Exception e) {
+            log.error(e.getMessage(), e);
+        }
+
+        return Result.ok();
+    }
+
+
+    public Result dealMidInterfaceEngin(String intefName, MidIncidentWarningVO midIncidentWarningVO, String ipStr) {
+        midIncidentWarningVOThreadLocal.set(midIncidentWarningVO);
+        JSONObject sendJson = new JSONObject();
+        try {
+            List<RuleAttr> ruleAttrList = interfRuleAttrList.get(intefName);
+            if (null == ruleAttrList) {
+                return Result.error("接口：" + intefName + " 未配置 对应的规则属性");
+            }
+            dictUtil.transferMidIncidentWarningVO(midIncidentWarningVO);
+            String jsonStr = JSON.toJSONString(midIncidentWarningVO);
+            log.info("事中提醒接收报文:{}", jsonStr);
+            JSONObject paramMap = JSON.parseObject(jsonStr);
+            List<Map<String, Object>> itemList = interfItemListPlugin.findProIntersection(paramMap, ruleAttrList);
+            MidIncidentAudit midIncidentAudit = insertMidWarning(midIncidentWarningVO);
+            insertLog(midIncidentWarningVO);
+            midIncidentAudit.setInterfName(intefName);
+            Set<String> auditDetailSet = new HashSet<>();
+            boolean sendFlag = false;
+            for (Map<String, Object> itemMap : itemList) {
+                Set<Integer> medicalInsRuleInfoIdList = itemCodeAndRuleIdMap.get(itemMap.get(Constant.MEDICAL_PROJECT_CODE_KEY));
+                if (CollectionUtil.isEmpty(medicalInsRuleInfoIdList)) {
+                    log.error("项目编码未匹配到对应的医保规则:{}", itemMap.get(Constant.MEDICAL_PROJECT_CODE_KEY));
+                    continue;
+                }
+                Object diagnose = itemMap.get(Constant.MEDICAL_DIAGNOSE_CODE_KEY);
+                if (null != diagnose) {
+                    List<Object> diagnoseList = (List<Object>) diagnose;
+                    //获取诊断编码配置的规则ID，加入需要执行的规则
+                    for (Object diagnoseObject : diagnoseList) {
+                        Set<Integer> diagnoseMedicalInsRuleInfoIdList = itemCodeAndRuleIdMap.get(diagnoseObject.toString());
+                        if (CollectionUtil.isNotEmpty(diagnoseMedicalInsRuleInfoIdList)) {
+                            medicalInsRuleInfoIdList.addAll(diagnoseMedicalInsRuleInfoIdList);
+                        }
+                    }
+                }
+                paramMap.put(SystemEventAttrConstant.ADVICE_DETAILS_LIST_KEY, itemList);
+                sendFlag = runMidEngine(auditDetailSet, itemMap, medicalInsRuleInfoIdList, midIncidentAudit, itemList);
+            }
+            sendJson.put("id", midIncidentAudit.getId());
+            sendJson.put("violationFlag", sendFlag);
+            if (!sendFlag) {
+                log.error("无违规，事中审核无需提醒 门诊/住院号：{}", midIncidentWarningVO.getVisit_no());
+            }
+        } catch (Exception e) {
+            log.error(e.getMessage(), e);
+        } finally {
+            midIncidentWarningVOThreadLocal.remove();
+        }
+
+        return Result.ok(sendJson);
+    }
+
+
+    public Result dealMidInterfaceEnginSocket(String intefName, MidIncidentWarningVO midIncidentWarningVO, String ipStr) {
+        midIncidentWarningVOThreadLocal.set(midIncidentWarningVO);
+        try {
+            List<RuleAttr> ruleAttrList = interfRuleAttrList.get(intefName);
+            if (null == ruleAttrList) {
+                return Result.error("接口：" + intefName + " 未配置 对应的规则属性");
+            }
+            dictUtil.transferMidIncidentWarningVO(midIncidentWarningVO);
+            String jsonStr = JSON.toJSONString(midIncidentWarningVO);
+            log.info("事中提醒接收报文:{}", jsonStr);
+            JSONObject paramMap = JSON.parseObject(jsonStr);
+            List<Map<String, Object>> itemList = interfItemListPlugin.findProIntersection(paramMap, ruleAttrList);
+            MidIncidentAudit midIncidentAudit = insertMidWarning(midIncidentWarningVO);
+            insertLog(midIncidentWarningVO);
+            midIncidentAudit.setInterfName(intefName);
+            Set<String> auditDetailSet = new HashSet<>();
+            boolean sendFlag = false;
+            for (Map<String, Object> itemMap : itemList) {
+                Set<Integer> medicalInsRuleInfoIdList = itemCodeAndRuleIdMap.get(itemMap.get(Constant.MEDICAL_PROJECT_CODE_KEY));
+                if (CollectionUtil.isEmpty(medicalInsRuleInfoIdList)) {
+                    log.error("项目编码未匹配到对应的医保规则:{}", itemMap.get(Constant.MEDICAL_PROJECT_CODE_KEY));
+                    continue;
+                }
+                Object diagnose = itemMap.get(Constant.MEDICAL_DIAGNOSE_CODE_KEY);
+                if (null != diagnose) {
+                    List<Object> diagnoseList = (List<Object>) diagnose;
+                    //获取诊断编码配置的规则ID，加入需要执行的规则
+                    for (Object diagnoseObject : diagnoseList) {
+                        Set<Integer> diagnoseMedicalInsRuleInfoIdList = itemCodeAndRuleIdMap.get(diagnoseObject.toString());
+                        if (CollectionUtil.isNotEmpty(diagnoseMedicalInsRuleInfoIdList)) {
+                            medicalInsRuleInfoIdList.addAll(diagnoseMedicalInsRuleInfoIdList);
+                        }
+                    }
+                }
+                paramMap.put(SystemEventAttrConstant.ADVICE_DETAILS_LIST_KEY, itemList);
+                sendFlag = runMidEngine(auditDetailSet, itemMap, medicalInsRuleInfoIdList, midIncidentAudit, itemList);
+            }
+
+            if (sendFlag) {
+                JSONObject sendJson = new JSONObject();
+                sendJson.put("id", midIncidentAudit.getId());
+                sendJson.put("type", "during");
+                webSocket.pushMessage(ipStr, sendJson.toJSONString());
+            } else {
+                log.error("无违规，事中审核无需提醒 门诊/住院号：{}", midIncidentWarningVO.getVisit_no());
+            }
+        } catch (Exception e) {
+            log.error(e.getMessage(), e);
+        } finally {
+            midIncidentWarningVOThreadLocal.remove();
+        }
+
+        return Result.ok();
+    }
+
+
+    /**
+     * 事后明细
+     *
+     * @param afterwardsAudit
+     * @param afterIncidentDetailLog
+     */
+    public void dealAfterInterfaceEngin(AfterwardsAudit afterwardsAudit, AfterIncidentDetailLog afterIncidentDetailLog, List<Map<String, Object>> itemList) {
+
+        try {
+            dictUtil.transferAfterIncidentWarning(afterIncidentDetailLog);
+            String jsonStr = JSON.toJSONString(afterIncidentDetailLog);
+            log.info("事后处理日志:{}", jsonStr);
+            JSONObject itemMap = JSON.parseObject(jsonStr);
+
+            Set<String> auditDetailSet = new HashSet<>();
+            Set<Integer> medicalInsRuleInfoIdList = itemCodeAndRuleIdMap.get(itemMap.get(Constant.MEDICAL_PROJECT_CODE_KEY));
+            if (CollectionUtil.isEmpty(medicalInsRuleInfoIdList)) {
+                log.error("项目编码未匹配到对应的医保规则:{}", itemMap.get(Constant.MEDICAL_PROJECT_CODE_KEY));
+                return;
+            }
+            Object diagnose = itemMap.get(Constant.MEDICAL_DIAGNOSE_CODE_KEY);
+            if (null != diagnose) {
+                //获取诊断编码配置的规则ID，加入需要执行的规则
+                Set<Integer> diagnoseMedicalInsRuleInfoIdList = itemCodeAndRuleIdMap.get(diagnose.toString());
+                if (CollectionUtil.isNotEmpty(diagnoseMedicalInsRuleInfoIdList)) {
+                    medicalInsRuleInfoIdList.addAll(diagnoseMedicalInsRuleInfoIdList);
+                }
+            }
+            runAfterEngine(auditDetailSet, itemMap, medicalInsRuleInfoIdList, afterwardsAudit, itemList);
+        } catch (Exception e) {
+            log.error(e.getMessage(), e);
+        }
+
+    }
+
+
+    public void insertLog(MidIncidentWarningVO midIncidentWarningVO) {
+        MidIncidentVisitLog midIncidentVisitLog = new MidIncidentVisitLog();
+        midIncidentVisitLog.setDoctorId(midIncidentWarningVO.getDoctor_code());
+        midIncidentVisitLog.setDoctorName(midIncidentWarningVO.getDoctor_name());
+        midIncidentVisitLog.setVisitNo(midIncidentWarningVO.getVisit_no());
+        midIncidentVisitLog.setPatientId(midIncidentWarningVO.getPatient_id());
+        midIncidentVisitLog.setPatientName(midIncidentWarningVO.getPatient_name());
+        midIncidentVisitLog.setDoctorLevel(midIncidentWarningVO.getDoctor_level());
+        midIncidentVisitLog.setPatientAge(midIncidentWarningVO.getPatient_age().toString());
+        midIncidentVisitLog.setPatientGender(midIncidentWarningVO.getPatient_gender());
+        midIncidentVisitLog.setDischargeStatus(midIncidentWarningVO.getDischarge_status());
+        midIncidentVisitLog.setTotoalAmount(midIncidentWarningVO.getTotoal_amount());
+        midIncidentVisitLog.setInsuranceType(midIncidentWarningVO.getInsurance_type());
+        if (CollectionUtil.isNotEmpty(midIncidentWarningVO.getDiagnoses())) {
+            midIncidentVisitLog.setDiagnoses(JSON.toJSONString(midIncidentWarningVO.getDiagnoses()));
+        }
+        midIncidentVisitLog.setDoctorAdviceNo(midIncidentWarningVO.getDoctor_advice_no());
+        try {
+            if (StringUtils.isNotBlank(midIncidentWarningVO.getIn_hosp_date())) {
+                Date inHospDate = DateUtils.parseDate(midIncidentWarningVO.getIn_hosp_date(), "yyyy-MM-dd HH:mm:ss");
+                midIncidentVisitLog.setInHospDate(inHospDate);
+            }
+        } catch (ParseException e) {
+            log.error(e.getMessage(), e);
+        }
+        try {
+            if (StringUtils.isNotBlank(midIncidentWarningVO.getVisit_time())) {
+                Date visitTime = DateUtils.parseDate(midIncidentWarningVO.getVisit_time(), "yyyy-MM-dd HH:mm:ss");
+                midIncidentVisitLog.setVisitTime(visitTime);
+            }
+        } catch (ParseException e) {
+            log.error(e.getMessage(), e);
+        }
+        Date now = new Date(System.currentTimeMillis());
+        midIncidentVisitLog.setCreateTime(now);
+        midIncidentVisitLog.setMedicalDeptCode(midIncidentWarningVO.getMedical_dept_code());
+        midIncidentVisitLog.setMedicalDeptName(midIncidentWarningVO.getMedical_dept_name());
+        midIncidentVisitLog.setVisitType(midIncidentWarningVO.getVisit_type());
+        midIncidentVisitLog.setAllergies(midIncidentWarningVO.getAllergies());
+        midIncidentVisitLog.setInpatientArea(midIncidentWarningVO.getInpatient_area());
+        midIncidentVisitLog.setNumberBeds(midIncidentWarningVO.getNumber_beds());
+        midIncidentVisitLogService.save(midIncidentVisitLog);
+        if (CollectionUtil.isNotEmpty(midIncidentWarningVO.getAdvice_details())) {
+            List<MidIncidentVisitDetailLog> midIncidentVisitDetailLogList = new ArrayList<>();
+            MidIncidentVisitDetailLog midIncidentVisitDetailLog = null;
+            for (AdviceDetailsVO adviceDetailsVO : midIncidentWarningVO.getAdvice_details()) {
+                midIncidentVisitDetailLog = new MidIncidentVisitDetailLog();
+                midIncidentVisitDetailLog.setAmount(new BigDecimal(adviceDetailsVO.getAmount()));
+                midIncidentVisitDetailLog.setCreateTime(now);
+                midIncidentVisitDetailLog.setMidIncidentVisitLogId(midIncidentVisitLog.getId());
+                midIncidentVisitDetailLog.setDoctorId(midIncidentVisitLog.getDoctorId());
+                midIncidentVisitDetailLog.setDoctorName(midIncidentVisitLog.getDoctorName());
+                midIncidentVisitDetailLog.setDoseDay(adviceDetailsVO.getDose_day());
+                midIncidentVisitDetailLog.setDoseForm(adviceDetailsVO.getDose_form());
+                midIncidentVisitDetailLog.setDoseUnit(adviceDetailsVO.getDose_unit());
+                midIncidentVisitDetailLog.setExpenseCategory(adviceDetailsVO.getExpense_category());
+                midIncidentVisitDetailLog.setVisitNo(midIncidentVisitLog.getVisitNo());
+                midIncidentVisitDetailLog.setVisitType(midIncidentVisitLog.getVisitType());
+                midIncidentVisitDetailLog.setInspectionSite(adviceDetailsVO.getInspection_site());
+                midIncidentVisitDetailLog.setInvoiceProject(adviceDetailsVO.getInvoice_project());
+                midIncidentVisitDetailLog.setMedicalInsuranceMark(adviceDetailsVO.getMedical_insurance_mark());
+                midIncidentVisitDetailLog.setMedicalNumber(adviceDetailsVO.getQuantity());
+                midIncidentVisitDetailLog.setOrderType(adviceDetailsVO.getOrder_type());
+                midIncidentVisitDetailLog.setOrderCatalog(adviceDetailsVO.getOrder_catalog());
+                midIncidentVisitDetailLog.setSingleDoseNumber(adviceDetailsVO.getSingle_dose_number());
+                midIncidentVisitDetailLog.setSingleDoseUnit(adviceDetailsVO.getSingle_dose_unit());
+                midIncidentVisitDetailLog.setMedicalDeptCode(midIncidentWarningVO.getMedical_dept_code());
+                midIncidentVisitDetailLog.setMedicalDeptName(midIncidentWarningVO.getMedical_dept_name());
+                midIncidentVisitDetailLog.setMedicalProjectName(adviceDetailsVO.getMedical_project_name());
+                midIncidentVisitDetailLog.setTakeFrequence(adviceDetailsVO.getTake_frequence());
+                midIncidentVisitDetailLog.setMedicalSpecification(adviceDetailsVO.getMedical_specification());
+                midIncidentVisitDetailLog.setPrice(new BigDecimal(adviceDetailsVO.getPrice()));
+                midIncidentVisitDetailLog.setRecipeNo(adviceDetailsVO.getRecipe_no());
+                midIncidentVisitDetailLog.setUseDay(adviceDetailsVO.getUse_day());
+                midIncidentVisitDetailLog.setProjectType(adviceDetailsVO.getProject_type());
+                midIncidentVisitDetailLog.setProejctCode(adviceDetailsVO.getProject_code());
+                midIncidentVisitDetailLog.setProejctName(adviceDetailsVO.getProject_name());
+                midIncidentVisitDetailLog.setPatientId(midIncidentWarningVO.getPatient_id());
+                midIncidentVisitDetailLog.setPatientId(midIncidentWarningVO.getPatient_name());
+                midIncidentVisitDetailLogList.add(midIncidentVisitDetailLog);
+            }
+            midIncidentVisitDetailLogService.saveBatch(midIncidentVisitDetailLogList);
+        }
+    }
+
+    public AdvanceWarningAudit insertAdvanceWarning(AdvanceWarningVO advanceWarningVO) {
+        AdvanceWarningAudit advanceWarningAudit = new AdvanceWarningAudit();
+        Date date = new Date(System.currentTimeMillis());
+        advanceWarningAudit.setCreateTime(date);
+        advanceWarningAudit.setDoctorId(advanceWarningVO.getDoctor_code());
+        advanceWarningAudit.setDoctorName(advanceWarningVO.getDoctor_name());
+        advanceWarningAudit.setMedicalDeptCode(advanceWarningVO.getMedical_dept_code());
+        advanceWarningAudit.setMedicalDeptName(advanceWarningVO.getMedical_dept_name());
+        advanceWarningAudit.setPatientId(advanceWarningVO.getPatient_id());
+        advanceWarningAudit.setPatientName(advanceWarningVO.getPatient_name());
+        advanceWarningAudit.setNoticeType("事前提醒");
+        advanceWarningAudit.setTreatmentType(advanceWarningVO.getVisit_type());
+
+        advanceWarningAuditService.save(advanceWarningAudit);
+
+
+        return advanceWarningAudit;
+    }
+
+    public MidIncidentAudit insertMidWarning(MidIncidentWarningVO midIncidentWarningVO) {
+        MidIncidentAudit midIncidentAudit = new MidIncidentAudit();
+        midIncidentAudit.setMedicalDeptCode(midIncidentWarningVO.getMedical_dept_code());
+        midIncidentAudit.setMedicalDeptName(midIncidentWarningVO.getMedical_dept_name());
+        Date date = new Date(System.currentTimeMillis());
+        midIncidentAudit.setCreateTime(date);
+        midIncidentAudit.setDoctorName(midIncidentWarningVO.getDoctor_name());
+        midIncidentAudit.setDoctorId(midIncidentWarningVO.getDoctor_code());
+        midIncidentAudit.setPatientId(midIncidentWarningVO.getPatient_id());
+        midIncidentAudit.setPatientName(midIncidentWarningVO.getPatient_name());
+        midIncidentAudit.setTreatmentType(midIncidentWarningVO.getVisit_type());
+        midIncidentAudit.setPrescriptionNumber(midIncidentWarningVO.getDoctor_advice_no());
+        midIncidentAudit.setNoticeType("事中预警");
+        midIncidentAudit.setAmount((double) 0);
+        midIncidentAudit.setDoctorLevel(midIncidentWarningVO.getDoctor_level());
+        midIncidentAudit.setPatientAge(midIncidentWarningVO.getPatient_age().toString());
+        midIncidentAudit.setPatientGender(midIncidentWarningVO.getPatient_gender());
+        midIncidentAudit.setDischargeStatus(midIncidentWarningVO.getDischarge_status());
+        midIncidentAudit.setAllergies(midIncidentWarningVO.getAllergies());
+        midIncidentAudit.setInpatientArea(midIncidentWarningVO.getInpatient_area());
+        midIncidentAudit.setNumberBeds(midIncidentWarningVO.getNumber_beds());
+        midIncidentAudit.setInsuranceType(midIncidentWarningVO.getInsurance_type());
+        try {
+            if (StringUtils.isNotBlank(midIncidentWarningVO.getIn_hosp_date())) {
+                Date inHospDate = DateUtils.parseDate(midIncidentWarningVO.getIn_hosp_date(), "yyyy-MM-dd HH:mm:ss");
+                midIncidentAudit.setInHospDate(inHospDate);
+            }
+        } catch (ParseException e) {
+            log.error(e.getMessage(), e);
+        }
+        try {
+            if (StringUtils.isNotBlank(midIncidentWarningVO.getVisit_time())) {
+                Date visitTime = DateUtils.parseDate(midIncidentWarningVO.getVisit_time(), "yyyy-MM-dd HH:mm:ss");
+                midIncidentAudit.setVisitTime(visitTime);
+            }
+        } catch (ParseException e) {
+            log.error(e.getMessage(), e);
+        }
+        midIncidentAuditService.save(midIncidentAudit);
+        double allAmount = 0;
+        if (null != midIncidentWarningVO.getTotoal_amount() && midIncidentWarningVO.getTotoal_amount() > 0) {
+            allAmount = midIncidentWarningVO.getTotoal_amount();
+        } else {
+            if (CollectionUtil.isNotEmpty(midIncidentWarningVO.getAdvice_details())) {
+                for (AdviceDetailsVO adviceDetailsVO : midIncidentWarningVO.getAdvice_details()) {
+                    allAmount = allAmount + adviceDetailsVO.getAmount();
+                }
+            }
+        }
+        midIncidentAudit.setAmount(allAmount);
+        if (CollectionUtil.isNotEmpty(midIncidentWarningVO.getDiagnoses())) {
+            List<MidIncidentAuditDiagnose> midIncidentAuditDiagnoseList = new ArrayList<>();
+            for (DiagnosesVO diagnosesVO : midIncidentWarningVO.getDiagnoses()) {
+                MidIncidentAuditDiagnose midIncidentAuditDiagnose = new MidIncidentAuditDiagnose();
+                midIncidentAuditDiagnose.setMidIncidentAuditId(midIncidentAudit.getId());
+                midIncidentAuditDiagnose.setDiagnoseCode(diagnosesVO.getDiagnose_code());
+                midIncidentAuditDiagnose.setDiagnoseDesc(diagnosesVO.getDiagnose_desc());
+                midIncidentAuditDiagnose.setMedDiagnoseCode(diagnosesVO.getMedical_diagnose_code());
+                midIncidentAuditDiagnose.setMedDiagnoseDesc(diagnosesVO.getMedical_diagnose_name());
+                midIncidentAuditDiagnose.setCreateTime(date);
+                midIncidentAuditDiagnose.setOutpatientNumber(midIncidentWarningVO.getVisit_no());
+                midIncidentAuditDiagnose.setPrescriptionNumber(midIncidentWarningVO.getDoctor_advice_no());
+                midIncidentAuditDiagnoseList.add(midIncidentAuditDiagnose);
+            }
+            midIncidentAuditDiagnoseService.saveBatch(midIncidentAuditDiagnoseList);
+        }
+
+
+        return midIncidentAudit;
+    }
+
+
+    public AfterwardsAudit insertAfterWarning(AfterIncidentLog afterIncidentLog) {
+        AfterwardsAudit afterwardsAudit = new AfterwardsAudit();
+        afterwardsAudit.setMedicalDeptCode(afterIncidentLog.getMedicalDeptCode());
+        afterwardsAudit.setMedicalDeptName(afterIncidentLog.getMedicalDeptName());
+        Date date = new Date(System.currentTimeMillis());
+        afterwardsAudit.setCreateTime(date);
+        afterwardsAudit.setDoctorName(afterIncidentLog.getDoctorName());
+        afterwardsAudit.setDoctorId(afterIncidentLog.getDoctorId());
+        afterwardsAudit.setPatientId(afterIncidentLog.getPatientId());
+        afterwardsAudit.setPatientName(afterIncidentLog.getPatientName());
+        afterwardsAudit.setTreatmentType(afterIncidentLog.getVisitType());
+        afterwardsAudit.setPrescriptionNumber(afterIncidentLog.getDoctorAdviceNo());
+        afterwardsAudit.setOutpatientNumber(afterIncidentLog.getVisitNo());
+        afterwardsAudit.setNoticeType("事后预警");
+        afterwardsAudit.setAmount((double) 0);
+        afterwardsAudit.setVisitTime(afterIncidentLog.getInHospDate());
+        afterwardsAudit.setMedicalInsurance(afterIncidentLog.getMedicalInsurance());
+        afterwardsAuditService.save(afterwardsAudit);
+        if (StringUtils.isNotBlank(afterIncidentLog.getDiagnoses())) {
+            List<String> diagonseCodeList = Arrays.asList(afterIncidentLog.getDiagnoses().split(","));
+//            List<String> diagonseNameList = Arrays.asList(afterIncidentDetailLog.getDiagnose_desc().split(","));
+            List<AfterwardsIncidentAuditDiagnose> afterIncidentAuditDiagnoseList = new ArrayList<>();
+            for (int i = 0; i < diagonseCodeList.size(); i++) {
+                String diagonseCode = diagonseCodeList.get(i);
+//                String diagonseName = diagonseNameList.get(i);
+//                Object value = redisTemplate.opsForHash().get(Constant.HIS_MEDICAL_DICT_KEY, afterIncidentDetailLog.getDiagnose_code());
+                String medicalDiagonseCode = dictUtil.getMedicalDiagnoseCode(diagonseCode);
+                String medicalDiagnoseName = dictUtil.getMedicalDiagnoseName(medicalDiagonseCode);
+                AfterwardsIncidentAuditDiagnose afterIncidentAuditDiagnose = new AfterwardsIncidentAuditDiagnose();
+                afterIncidentAuditDiagnose.setAfterwardsAuditId(afterwardsAudit.getId());
+                afterIncidentAuditDiagnose.setDiagnoseCode(diagonseCode);
+//                afterIncidentAuditDiagnose.setDiagnoseDesc(diagonseName);
+                afterIncidentAuditDiagnose.setMedDiagnoseCode(medicalDiagonseCode);
+                afterIncidentAuditDiagnose.setMedDiagnoseDesc(medicalDiagnoseName);
+                afterIncidentAuditDiagnose.setCreateTime(date);
+                afterIncidentAuditDiagnose.setOutpatientNumber(afterwardsAudit.getOutpatientNumber());
+                afterIncidentAuditDiagnose.setPrescriptionNumber(afterwardsAudit.getPrescriptionNumber());
+                afterIncidentAuditDiagnoseList.add(afterIncidentAuditDiagnose);
+            }
+
+
+            afterwardsIncidentAuditDiagnoseService.saveBatch(afterIncidentAuditDiagnoseList);
+        }
+
+
+        return afterwardsAudit;
+    }
+
+    /**
+     * 事前提醒引擎
+     *
+     * @param paramMap
+     */
+    public void runAdvanceWaringEngine(Map<String, Object> paramMap, MedicalInsRuleInfo medicalInsRuleInfo, Object audit) {
+        if (null == medicalInsRuleInfo) {
+            log.error("未有对应的规则，接口数据:{}", paramMap);
+            return;
+        }
+        LambdaQueryWrapper<RuleFactorRela> query = new LambdaQueryWrapper<RuleFactorRela>();
+        query.eq(RuleFactorRela::getDelFlag, CommonConstant.DEL_FLAG_0);
+        query.eq(RuleFactorRela::getMedicalInsRuleInfoId, medicalInsRuleInfo.getId());
+        query.orderByAsc(RuleFactorRela::getSeqNum);
+        List<RuleFactorRela> ruleFactorRelaList = ruleFactorRelaService.list(query);
+
+        if (CollectionUtil.isNotEmpty(ruleFactorRelaList)) {
+            Set<Integer> factorEnchangeIdList = ruleFactorRelaList.stream().map(RuleFactorRela::getFactorEnhanceId).collect(Collectors.toSet());
+            List<FactorEnchance> factorEnchanceList = factorEnchanceService.listByIds(factorEnchangeIdList);
+            Map<Integer, List<FactorEnchance>> enchanceTypeMap = factorEnchanceList.stream().collect(Collectors.groupingBy(FactorEnchance::getFactorCatalog));
+            for (Integer medicalRuleInsInfoId : enchanceTypeMap.keySet()) {
+
+                List<FactorEnchance> factorEnchanceListTemp = enchanceTypeMap.get(medicalRuleInsInfoId);
+                paramMap.put(SystemEventAttrConstant.MEDICAL_INS_RULE_INFO_ID, medicalRuleInsInfoId);
+                paramMap.put(SystemEventAttrConstant.MEDICAL_INS_RULE_INFO_CODE, medicalInsRuleInfo.getRuleCode());
+                paramMap.put(SystemEventAttrConstant.MEDICAL_INS_RULE_INFO_NAME, medicalInsRuleInfo.getRuleName());
+                paramMap.put(SystemEventAttrConstant.MEDICAL_INS_RULE_INFO_DESC, medicalInsRuleInfo.getDescription());
+                factorEnchangeFactory.runFactorEnchange(medicalRuleInsInfoId, medicalInsRuleInfo, audit, paramMap, ruleFactorRelaList, factorEnchanceListTemp, null);
+            }
+        }
+    }
+
+    /**
+     * 事后跑统计类规则引擎
+     *
+     * @param paramMap
+     */
+    public void runStatictisEngine(Map<String, Object> paramMap, MedicalInsRuleInfo medicalInsRuleInfo) {
+        if (null == medicalInsRuleInfo) {
+            log.error("未有对应的规则，接口数据:{}", paramMap);
+            return;
+        }
+        LambdaQueryWrapper<RuleFactorRela> query = new LambdaQueryWrapper<RuleFactorRela>();
+        query.eq(RuleFactorRela::getDelFlag, CommonConstant.DEL_FLAG_0);
+        query.eq(RuleFactorRela::getMedicalInsRuleInfoId, medicalInsRuleInfo.getId());
+        query.orderByAsc(RuleFactorRela::getSeqNum);
+        List<RuleFactorRela> ruleFactorRelaList = ruleFactorRelaService.list(query);
+
+        if (CollectionUtil.isNotEmpty(ruleFactorRelaList)) {
+            Set<Integer> factorEnchangeIdList = ruleFactorRelaList.stream().map(RuleFactorRela::getFactorEnhanceId).collect(Collectors.toSet());
+            List<FactorEnchance> factorEnchanceList = factorEnchanceService.listByIds(factorEnchangeIdList);
+            Map<Integer, List<FactorEnchance>> enchanceTypeMap = factorEnchanceList.stream().collect(Collectors.groupingBy(FactorEnchance::getFactorCatalog));
+            for (Integer medicalRuleInsInfoId : enchanceTypeMap.keySet()) {
+
+                List<FactorEnchance> factorEnchanceListTemp = enchanceTypeMap.get(medicalRuleInsInfoId);
+                paramMap.put(SystemEventAttrConstant.MEDICAL_INS_RULE_INFO_ID, medicalRuleInsInfoId);
+                paramMap.put(SystemEventAttrConstant.MEDICAL_INS_RULE_INFO_CODE, medicalInsRuleInfo.getRuleCode());
+                paramMap.put(SystemEventAttrConstant.MEDICAL_INS_RULE_INFO_NAME, medicalInsRuleInfo.getRuleName());
+                boolean auditFlag = factorEnchangeFactory.runFactorEnchange(medicalRuleInsInfoId, medicalInsRuleInfo, null, paramMap, ruleFactorRelaList, factorEnchanceListTemp, null);
+                if (Constant.VALIDATION_HANDER_METHOD_RETURN.equals(medicalInsRuleInfo.getViolationHandingMethod()) && auditFlag) {
+                    log.error("事后统计数据：{} 规则名：{} 触发诊断类规则，直接全金额，后续规则无需再跑", paramMap, medicalInsRuleInfo);
+                    return;
+                }
+            }
+        }
+    }
+
+
+    /**
+     * 事中跑批规则引擎
+     *
+     * @param paramMap
+     */
+    public void runAfterEngine(Set<String> auditDetailSet, Map<String, Object> paramMap, Set<Integer> medicalInsRuleInfoIdList, AfterwardsAudit afterIncidentAudit, List<Map<String, Object>> itemList) {
+        if (CollectionUtil.isEmpty(medicalInsRuleInfoIdList)) {
+            log.error("未有对应的规则，接口数据:{}", paramMap);
+            return;
+        }
+        LambdaQueryWrapper<RuleFactorRela> query = new LambdaQueryWrapper<RuleFactorRela>();
+        query.eq(RuleFactorRela::getDelFlag, CommonConstant.DEL_FLAG_0);
+        query.in(RuleFactorRela::getMedicalInsRuleInfoId, medicalInsRuleInfoIdList);
+        query.orderByAsc(RuleFactorRela::getSeqNum);
+        List<RuleFactorRela> ruleFactorRelaList = ruleFactorRelaService.list(query);
+
+        if (CollectionUtil.isNotEmpty(ruleFactorRelaList)) {
+            Map<Integer, List<RuleFactorRela>> ruleIdAndFatorEnchanceIdMap = ruleFactorRelaList.stream().collect(Collectors.groupingBy(RuleFactorRela::getMedicalInsRuleInfoId));
+            Set<Integer> factorEnchangeIdList = ruleFactorRelaList.stream().map(RuleFactorRela::getFactorEnhanceId).collect(Collectors.toSet());
+            List<FactorEnchance> factorEnchanceList = factorEnchanceService.listByIds(factorEnchangeIdList);
+            Map<Integer, List<FactorEnchance>> enchanceTypeMap = factorEnchanceList.stream().collect(Collectors.groupingBy(FactorEnchance::getFactorCatalog));
+            for (Integer medicalRuleInsInfoId : enchanceTypeMap.keySet()) {
+                String auditDetailKeyStr = paramMap.get(Constant.MEDICAL_PROJECT_NAME_KEY) + "_" + medicalRuleInsInfoId;
+                if (auditDetailSet.contains(auditDetailKeyStr)) {
+                    log.error("项目编码:{} 规则ID:{} 已经执行过规则引擎，此次忽略", paramMap.get(Constant.MEDICAL_PROJECT_NAME_KEY), medicalRuleInsInfoId);
+                    continue;
+                }
+                auditDetailSet.add(auditDetailKeyStr);
+                MedicalInsRuleInfo medicalInsRuleInfo = medicalInsRuleInfoService.getById(medicalRuleInsInfoId);
+                List<FactorEnchance> factorEnchanceListTemp = enchanceTypeMap.get(medicalRuleInsInfoId);
+                paramMap.put(SystemEventAttrConstant.MEDICAL_INS_RULE_INFO_ID, medicalRuleInsInfoId);
+                paramMap.put(SystemEventAttrConstant.MEDICAL_INS_RULE_INFO_CODE, medicalInsRuleInfo.getRuleCode());
+                paramMap.put(SystemEventAttrConstant.MEDICAL_INS_RULE_INFO_NAME, medicalInsRuleInfo.getRuleName());
+                List<RuleFactorRela> ruleFactorRelaSortList = ruleIdAndFatorEnchanceIdMap.get(medicalRuleInsInfoId);
+                getRuleProjectIntoMap(medicalInsRuleInfo, paramMap);
+                paramMap.put(SystemEventAttrConstant.ADVICE_DETAILS_LIST_KEY, itemList);
+                boolean auditFlag = factorEnchangeFactory.runFactorEnchange(medicalRuleInsInfoId, medicalInsRuleInfo, afterIncidentAudit, paramMap, ruleFactorRelaSortList, factorEnchanceListTemp, itemList);
+                if (Constant.VALIDATION_HANDER_METHOD_RETURN.equals(medicalInsRuleInfo.getViolationHandingMethod()) && auditFlag) {
+                    log.error("事后提醒数据：{} 规则名：{} 触发诊断类规则，直接全金额，后续规则无需再跑", paramMap, medicalInsRuleInfo);
+                    return;
+                }
+            }
+        }
+    }
+
+    /**
+     * 事中跑批规则引擎
+     *
+     * @param paramMap
+     */
+    public boolean runMidEngine(Set<String> auditDetailSet, Map<String, Object> paramMap, Set<Integer> medicalInsRuleInfoIdList, MidIncidentAudit midIncidentAudit, List<Map<String, Object>> itemList) {
+        if (CollectionUtil.isEmpty(medicalInsRuleInfoIdList)) {
+            log.error("未有对应的规则，接口数据:{}", paramMap);
+            return false;
+        }
+        LambdaQueryWrapper<RuleFactorRela> query = new LambdaQueryWrapper<RuleFactorRela>();
+        query.eq(RuleFactorRela::getDelFlag, CommonConstant.DEL_FLAG_0);
+        query.in(RuleFactorRela::getMedicalInsRuleInfoId, medicalInsRuleInfoIdList);
+        query.orderByAsc(RuleFactorRela::getSeqNum);
+        List<RuleFactorRela> ruleFactorRelaList = ruleFactorRelaService.list(query);
+        boolean auditFlag = false;
+        if (CollectionUtil.isNotEmpty(ruleFactorRelaList)) {
+            Map<Integer, List<RuleFactorRela>> ruleIdAndFatorEnchanceIdMap = ruleFactorRelaList.stream().collect(Collectors.groupingBy(RuleFactorRela::getMedicalInsRuleInfoId));
+            Set<Integer> factorEnchangeIdList = ruleFactorRelaList.stream().map(RuleFactorRela::getFactorEnhanceId).collect(Collectors.toSet());
+            List<FactorEnchance> factorEnchanceList = factorEnchanceService.listByIds(factorEnchangeIdList);
+            Map<Integer, List<FactorEnchance>> enchanceTypeMap = factorEnchanceList.stream().collect(Collectors.groupingBy(FactorEnchance::getFactorCatalog));
+            for (Integer medicalRuleInsInfoId : enchanceTypeMap.keySet()) {
+                String auditDetailKeyStr = paramMap.get(Constant.MEDICAL_PROJECT_NAME_KEY) + "_" + medicalRuleInsInfoId;
+                if (auditDetailSet.contains(auditDetailKeyStr)) {
+                    log.error("项目编码:{} 规则ID:{} 已经执行过规则引擎，此次忽略", paramMap.get(Constant.MEDICAL_PROJECT_NAME_KEY), medicalRuleInsInfoId);
+                    continue;
+                }
+                auditDetailSet.add(auditDetailKeyStr);
+                MedicalInsRuleInfo medicalInsRuleInfo = medicalInsRuleInfoService.getById(medicalRuleInsInfoId);
+                List<FactorEnchance> factorEnchanceListTemp = enchanceTypeMap.get(medicalRuleInsInfoId);
+                paramMap.put(SystemEventAttrConstant.MEDICAL_INS_RULE_INFO_ID, medicalRuleInsInfoId);
+                paramMap.put(SystemEventAttrConstant.MEDICAL_INS_RULE_INFO_CODE, medicalInsRuleInfo.getRuleCode());
+                paramMap.put(SystemEventAttrConstant.MEDICAL_INS_RULE_INFO_NAME, medicalInsRuleInfo.getRuleName());
+                List<RuleFactorRela> ruleFactorRelaSortList = ruleIdAndFatorEnchanceIdMap.get(medicalRuleInsInfoId);
+                getRuleProjectIntoMap(medicalInsRuleInfo, paramMap);
+                auditFlag = factorEnchangeFactory.runFactorEnchange(medicalRuleInsInfoId, medicalInsRuleInfo, midIncidentAudit, paramMap, ruleFactorRelaSortList, factorEnchanceListTemp, itemList);
+                if (Constant.VALIDATION_HANDER_METHOD_RETURN.equals(medicalInsRuleInfo.getViolationHandingMethod()) && auditFlag) {
+                    log.error("事中提醒数据：{} 规则名：{} 触发诊断类规则，直接全金额，后续规则无需再跑", paramMap, medicalInsRuleInfo);
+                    return auditFlag;
+                }
+            }
+        }
+        return auditFlag;
+    }
+
+    public void getRuleProjectIntoMap(MedicalInsRuleInfo medicalInsRuleInfo, Map<String, Object> itemMap) {
+        String selectedRoles = medicalInsRuleInfo.getSelectedRoles();
+        if (StringUtils.isNotBlank(selectedRoles)) {
+            String[] selectedRolesArr = selectedRoles.split(",");
+            boolean diagnoseFlag = Arrays.stream(selectedRolesArr).anyMatch(attr -> attr.equals("medicalDiagnoseCode"));
+            boolean correlationDiagnoseFlag = Arrays.stream(selectedRolesArr).anyMatch(attr -> attr.equals("correlationMedicalDiagnoseCode"));
+            boolean projectCodeFlag = Arrays.stream(selectedRolesArr).anyMatch(attr -> attr.equals("projectCode"));
+            String projectCode = null;
+            if (projectCodeFlag && null != itemMap.get(Constant.PROJECT_CODE_KEY)) {
+                projectCode = itemMap.get(Constant.PROJECT_CODE_KEY).toString();
+            } else {
+                return;
+            }
+            List<MedicalInsRuleProject> medicalInsRuleProjectList = medicalInsRuleProjectService.lambdaQuery().eq(MedicalInsRuleProject::getMedicalInsRuleInfoId, medicalInsRuleInfo.getId())
+                    .eq(projectCodeFlag, MedicalInsRuleProject::getProjectCode, projectCode).eq(MedicalInsRuleProject::getState, Constant.EFF_STATE).list();
+            List<String> correlationProjectCodeList = new ArrayList<>();
+            String collectionProjectCode = null;
+            if (CollectionUtil.isNotEmpty(medicalInsRuleProjectList)) {
+                if (medicalInsRuleProjectList.size() == 1) {
+                    String jsonStr = JSON.toJSONString(medicalInsRuleProjectList.get(0));
+                    collectionProjectCode = medicalInsRuleProjectList.get(0).getCorrelationProjectCode();
+                    JSONObject ruleProjectJSONObject = JSON.parseObject(jsonStr);
+                    Map<String, Object> filterMap = filterMap(ruleProjectJSONObject);
+                    itemMap.putAll(filterMap);
+                } else {
+                    correlationProjectCodeList = medicalInsRuleProjectList.stream().map(MedicalInsRuleProject::getProjectCode).collect(Collectors.toList());
+                    itemMap.put(SystemEventAttrConstant.MEDICAL_INS_CORRELATIONPROJECTCODELIST, correlationProjectCodeList);
+                }
+
+            }
+            if (diagnoseFlag) {
+                List<MedicalInsRuleProjectDiagnose> medicalInsRuleProjectDiagnoseList = null;
+                boolean conditionFlag = false;
+                if (StringUtils.isNotBlank(projectCode)) {
+                    conditionFlag = true;
+                }
+                medicalInsRuleProjectDiagnoseList = medicalInsRuleProjectDiagnoseService.lambdaQuery().eq(conditionFlag, MedicalInsRuleProjectDiagnose::getMedicalInsProjectCode, projectCode).eq(MedicalInsRuleProjectDiagnose::getMedicalInsRuleInfoId, medicalInsRuleInfo.getId())
+                        .eq(MedicalInsRuleProjectDiagnose::getProjectCodeType, 1).list();
+                if (CollectionUtil.isNotEmpty(medicalInsRuleProjectDiagnoseList)) {
+                    List<String> medicalDiagnoseStrList = medicalInsRuleProjectDiagnoseList.stream().map(MedicalInsRuleProjectDiagnose::getMedicalDiagnoseCode).collect(Collectors.toList());
+                    itemMap.put(SystemEventAttrConstant.MEDICAL_INS_MEDICALDIAGNOSECODELIST, medicalDiagnoseStrList);
+                }
+            }
+
+            if (correlationDiagnoseFlag) {
+                List<MedicalInsRuleProjectDiagnose> medicalInsRuleProjectDiagnoseList = null;
+                boolean conditionFlag = false;
+                if (StringUtils.isNotBlank(collectionProjectCode)) {
+                    conditionFlag = true;
+                }
+                medicalInsRuleProjectDiagnoseList = medicalInsRuleProjectDiagnoseService.lambdaQuery().eq(conditionFlag, MedicalInsRuleProjectDiagnose::getMedicalInsProjectCode, collectionProjectCode).eq(MedicalInsRuleProjectDiagnose::getMedicalInsRuleInfoId, medicalInsRuleInfo.getId())
+                        .eq(MedicalInsRuleProjectDiagnose::getProjectCodeType, 2).list();
+                if (CollectionUtil.isNotEmpty(medicalInsRuleProjectDiagnoseList)) {
+                    List<String> medicalDiagnoseStrList = medicalInsRuleProjectDiagnoseList.stream().map(MedicalInsRuleProjectDiagnose::getMedicalDiagnoseCode).collect(Collectors.toList());
+                    itemMap.put(SystemEventAttrConstant.MEDICAL_INS_CORRELATIONMEDICALDIAGNOSECODE, medicalDiagnoseStrList);
+                }
+            }
+
+        }
+    }
+
+
+    public Map<String, Object> filterMap(JSONObject ruleProjectJSONObject) {
+        Map<String, Object> filterMap = new HashMap<>();
+        if (CollectionUtil.isNotEmpty(ruleProjectJSONObject)) {
+            for (Map.Entry<String, Object> entry : ruleProjectJSONObject.entrySet()) {
+                if (null != entry.getValue()) {
+                    filterMap.put(Constant.MEDICAL_INS_KEY + entry.getKey(), entry.getValue());
+                }
+            }
+        }
+        return filterMap;
+    }
 }

jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/medical/service/impl/AfterwardsAuditServiceImpl.java

@@ -61,7 +61,6 @@ public class AfterwardsAuditServiceImpl extends ServiceImpl<AfterwardsAuditMappe
     /** 科室/医生复核服务 */
     private final IMedicalDoctorAppealRecordService appealRecordService;
     private final ISysUserService sysUserService;
-    private final HisMedicalProjectCache hisMedicalProjectCache;
     private final ISysUserDepartService sysUserDepartService;
     private final ISysDepartService departService;
 
@@ -418,7 +417,7 @@ public class AfterwardsAuditServiceImpl extends ServiceImpl<AfterwardsAuditMappe
         for (MedicalOrderInfoResponse medicalOrderInfoRespons : medicalOrderInfoResponses) {
             String itemId = medicalOrderInfoRespons.getItemId();
             if (StringUtils.hasText(itemId)) {
-                String medicalInsuranceNumber = hisMedicalProjectCache.loadHisMedicalMapping(itemId);
+//                String medicalInsuranceNumber = hisMedicalProjectCache.loadHisMedicalMapping(itemId);
             }
 
         }