新增sendstateView（1：待随访（2 待发送）；2：随访中（1 被领取、3 已发送）、3：未完成（5 发送失败、7、超时）、4：已完成（ 6...

liusheng

3 天以前 2ad7a1b9035321fc16b253ad2cdd73c6d5e15d64

 smartor/src/main/java/com/smartor/service/impl/PatMedInhospServiceImpl.java

@@ -57,6 +57,8 @@
    private PatMedOperationMapper patMedOperationMapper;
    @Autowired
    private PatMedOperationItemMapper patMedOperationItemMapper;
    @Autowired
    private ServiceTaskRuleMapper serviceTaskRuleMapper;

    @Value("${spring.profiles.active}")
    private String active;
@@ -307,246 +309,16 @@
            }
        }

        //2.出院随访
        PatMedInhosp pmks = new PatMedInhosp();
        //获取需要出院部门随访，未处理的数据
        pmks.setDeptcheckFlag("0");
        pmks.setInhospstate("1");
        pmks.setFuflag("1");
        List<PatMedInhosp> patMedInhosps = patMedInhospMapper.selectPatMedInhospList(pmks);
        log.info("dealOutHospInfo需要处理的出院部门患者信息：{}", CollectionUtils.isNotEmpty(patMedInhosps) ? patMedInhosps.size() : null);
        for (PatMedInhosp patMedInhosp1 : patMedInhosps) {
            String tagname = patMedInhospMapper.getTagnameBypatid(patMedInhosp1.getPatid());
            patMedInhosp1.setTagname(tagname);
        }

        //科室
        for (PatMedInhosp patMedInhosp1 : patMedInhosps) {
            //获取患者信息
            PatArchive patArchive = patArchiveMapper.selectPatArchiveByPatid(patMedInhosp1.getPatid());
            if (Objects.isNull(patArchive)) {
                patMedInhosp1.setDeptcheckFlag("2");
                patMedInhosp1.setLongTaskReason("患者基本信息为空");
                patMedInhospMapper.updatePatMedInhosp(patMedInhosp1);
                continue;
            }
            try {
                //根据患者所在科室，获取该科室的长期任务
                ServiceTaskdept serviceTaskdept = new ServiceTaskdept();
                serviceTaskdept.setLongtask(1L);
                serviceTaskdept.setDeptCode(patMedInhosp1.getLeaveldeptcode());
                serviceTaskdept.setDeptType("1");
                serviceTaskdept.setServiceType("2");
                serviceTaskdept.setOrgid(patMedInhosp1.getOrgid());
                List<ServiceTaskdept> serviceTaskdepts = serviceTaskdeptMapper.selectServiceTaskdeptList(serviceTaskdept);
                //如果部门模板为空（将deptIsNull设置为true）
                if (CollectionUtils.isEmpty(serviceTaskdepts) || serviceTaskdepts.size() == 0) {
                    PatMedInhosp patMedInhosp = patMedInhospMapper.selectPatMedInhospByInhospid(patMedInhosp1.getInhospid());
                    patMedInhosp1.setDeptcheckFlag("2");
                    patMedInhosp1.setLongTaskReason(patMedInhosp.getLongTaskReason() + "该患者所在科室未配置离院长期任务;");
                    patMedInhospMapper.updatePatMedInhosp(patMedInhosp1);
                } else {
                    for (ServiceTaskdept serviceTaskdept1 : serviceTaskdepts) {
                        writeInSubTask(serviceTaskdept1.getTaskId(), true, patMedInhosp1, patArchive, 1, config);
                    }
//                    patMedInhosp1.setDeptcheckFlag("1");
//                    patMedInhospMapper.updatePatMedInhosp(patMedInhosp1);
                }

            } catch (Exception e) {
                e.printStackTrace();
                log.error("人员科室处理出异常了：{}", e.getMessage());
                patMedInhosp1.setDeptcheckFlag("2");
                patMedInhosp1.setLongTaskReason("人员科室处理异常：" + e.getMessage());
                patMedInhospMapper.updatePatMedInhosp(patMedInhosp1);
            }
        }

        //2.出院随访 - 基于规则的任务生成
        addSubTaskByRule(config);
        //根据患者所在病区，获取该病区的长期任务,新华医院可以先不用根据病区和疾病来做
        if (!active.equals("xh")) {
            PatMedInhosp pmbq = new PatMedInhosp();
            //获取需要出院部门随访，未处理的数据
            pmbq.setWardcheckFlag("0");
            pmbq.setInhospstate("1");
            pmbq.setFuflag("1");
            List<PatMedInhosp> patMedInhospBQs = patMedInhospMapper.selectPatMedInhospList(pmbq);
            log.info("dealOutHospInfo需要处理的出院病区患者信息：{}", CollectionUtils.isNotEmpty(patMedInhospBQs) ? patMedInhospBQs.size() : null);
            for (PatMedInhosp patMedInhosp1 : patMedInhospBQs) {
                String tagname = patMedInhospMapper.getTagnameBypatid(patMedInhosp1.getPatid());
                patMedInhosp1.setTagname(tagname);
            }

            //病区数据处理
            for (PatMedInhosp pmiBQ1 : patMedInhospBQs) {
                //获取患者信息
                PatArchive patArchive = patArchiveMapper.selectPatArchiveByPatid(pmiBQ1.getPatid());
                if (Objects.isNull(patArchive)) {
                    pmiBQ1.setWardcheckFlag("2");
                    pmiBQ1.setLongTaskReason("患者基本信息为空");
                    patMedInhospMapper.updatePatMedInhosp(pmiBQ1);
                    continue;
                }
                try {
                    String errorreason = null;
                    List<ServiceTaskdept> serviceTaskdeptList = null;
                    if (!StringUtils.isEmpty(pmiBQ1.getLeavehospitaldistrictcode())) {
                        ServiceTaskdept serviceTaskdept = new ServiceTaskdept();
                        serviceTaskdept.setLongtask(1L);
                        serviceTaskdept.setDeptCode(pmiBQ1.getLeavehospitaldistrictcode());
                        serviceTaskdept.setDeptType("2");
                        serviceTaskdept.setServiceType("2");
                        serviceTaskdept.setOrgid(pmiBQ1.getOrgid());
                        serviceTaskdeptList = serviceTaskdeptMapper.selectServiceTaskdeptList(serviceTaskdept);
                        if (CollectionUtils.isEmpty(serviceTaskdeptList)) {
                            errorreason = "该患者所在病区未配置长期任务;";
                        }
                    } else {
                        errorreason = "离院病区为空;";
                    }
                    //如果部门模板为空（将deptIsNull设置为true）
                    if (StringUtils.isNotEmpty(errorreason)) {
                        PatMedInhosp patMedInhosp = patMedInhospMapper.selectPatMedInhospByInhospid(pmiBQ1.getInhospid());
                        pmiBQ1.setWardcheckFlag("2");
                        pmiBQ1.setLongTaskReason(StringUtils.isNotEmpty(patMedInhosp.getLongTaskReason()) ? patMedInhosp.getLongTaskReason() + errorreason : errorreason);
                        patMedInhospMapper.updatePatMedInhosp(pmiBQ1);
                    } else {
                        for (ServiceTaskdept serviceTaskdept1 : serviceTaskdeptList) {
                            writeInSubTask(serviceTaskdept1.getTaskId(), true, pmiBQ1, patArchive, 2, config);
                        }
//                        pmiBQ1.setWardcheckFlag("1");
//                        patMedInhospMapper.updatePatMedInhosp(pmiBQ1);
                    }


                } catch (Exception e) {
                    e.printStackTrace();
                    log.error("人员病区处理出异常了：{}", e.getMessage());
                    pmiBQ1.setWardcheckFlag("2");
                    pmiBQ1.setLongTaskReason("人员病区处理异常：" + e.getMessage());
                    patMedInhospMapper.updatePatMedInhosp(pmiBQ1);
                }
            }

            PatMedInhosp pmjb = new PatMedInhosp();
            //获取需要出院疾病随访，未处理的数据
            pmjb.setDiagcheckFlag("0");
            pmjb.setInhospstate("1");
            pmjb.setFuflag("1");
            List<PatMedInhosp> patMedInhospJBs = patMedInhospMapper.selectPatMedInhospList(pmjb);
            log.info("dealOutHospInfo需要处理的出院疾病患者信息：{}", CollectionUtils.isNotEmpty(patMedInhospJBs) ? patMedInhospJBs.size() : null);
            for (PatMedInhosp patMedInhosp1 : patMedInhospJBs) {
                String tagname = patMedInhospMapper.getTagnameBypatid(patMedInhosp1.getPatid());
                patMedInhosp1.setTagname(tagname);
            }

            for (PatMedInhosp pmiJB : patMedInhospJBs) {
                //获取患者信息
                PatArchive patArchive = patArchiveMapper.selectPatArchiveByPatid(pmiJB.getPatid());
                if (Objects.isNull(patArchive)) {
                    pmiJB.setDiagcheckFlag("2");
                    pmiJB.setLongTaskReason("患者基本信息为空");
                    patMedInhospMapper.updatePatMedInhosp(pmiJB);
                    continue;
                }
                try {
                    String errorIcd = null;
                    if (StringUtils.isEmpty(pmiJB.getLeaveicd10code())) {
                        continue;
                    }
                    // 根据患者的疾病，获取该疾病的长期任务
                    ServiceTaskdiag serviceTaskdiag = new ServiceTaskdiag();
                    serviceTaskdiag.setLongtask(1L);
                    serviceTaskdiag.setServiceType("2");
                    if (active.equals("nhfy")) {
                        //南华附一的icd10code有重复，所以用主诊断名称去查询
                        serviceTaskdiag.setIcd10name(pmiJB.getLeavediagname());
                        if (StringUtils.isEmpty(pmiJB.getLeavediagname())) {
                            errorIcd = "该患者主诊断名称为空;";
                        }
                    } else {
                        serviceTaskdiag.setIcd10code(pmiJB.getLeaveicd10code());
                        if (StringUtils.isEmpty(pmiJB.getLeaveicd10code())) {
                            errorIcd = "该患者主诊断ICD10码为空;";
                        }
                    }
                    serviceTaskdiag.setOrgid(pmiJB.getOrgid());
                    List<ServiceTaskdiag> serviceTaskdiags = serviceTaskdiagMapper.selectServiceTaskdiagList(serviceTaskdiag);

                    //如果部门模板为空（将deptIsNull设置为true）
                    if (StringUtils.isNotEmpty(errorIcd)) {
                        PatMedInhosp patMedInhosp = patMedInhospMapper.selectPatMedInhospByInhospid(pmiJB.getInhospid());
                        pmiJB.setDiagcheckFlag("2");
                        pmiJB.setLongTaskReason(StringUtils.isNotEmpty(patMedInhosp.getLongTaskReason()) ? patMedInhosp.getLongTaskReason() + errorIcd : errorIcd);
                        patMedInhospMapper.updatePatMedInhosp(pmiJB);
                    } else if (CollectionUtils.isEmpty(serviceTaskdiags)) {
                        errorIcd = "该患者所在病区未配置长期任务;";
                        PatMedInhosp patMedInhosp = patMedInhospMapper.selectPatMedInhospByInhospid(pmiJB.getInhospid());
                        pmiJB.setDiagcheckFlag("2");
                        pmiJB.setLongTaskReason(StringUtils.isNotEmpty(patMedInhosp.getLongTaskReason()) ? patMedInhosp.getLongTaskReason() + errorIcd : errorIcd);
                        patMedInhospMapper.updatePatMedInhosp(pmiJB);
                    } else {
                        for (ServiceTaskdiag serviceTaskdept1 : serviceTaskdiags) {
                            writeInSubTask(serviceTaskdept1.getTaskId(), true, pmiJB, patArchive, 3, config);
                        }
//                        pmiJB.setDiagcheckFlag("1");
//                        patMedInhospMapper.updatePatMedInhosp(pmiJB);
                    }

                } catch (Exception e) {
                    e.printStackTrace();
                    log.error("人员疾病处理出异常了：{}", e.getMessage());
                    pmiJB.setDiagcheckFlag("2");
                    pmiJB.setLongTaskReason("人员疾病处理异常：" + e.getMessage());
                    patMedInhospMapper.updatePatMedInhosp(pmiJB);
                }
            }
//            手术随访
            PatMedOperationItem pmoi = new PatMedOperationItem();
            //获取需要出院疾病随访，未处理的数据
            pmoi.setOpercheckFlag("0");
            pmoi.setMainFlag("1");

            List<PatMedOperationItem> patMedOperationItems = patMedOperationItemMapper.selectPatMedOperationItemList(pmoi);
            log.info("dealOutHospInfo需要处理的出院手术患者信息：{}", CollectionUtils.isNotEmpty(patMedOperationItems) ? patMedOperationItems.size() : null);

            for (PatMedOperationItem opItem : patMedOperationItems) {

                try {
                    if (StringUtils.isEmpty(opItem.getOplevelcode())) {
                        continue;
                    }
                    // 根据患者的疾病，获取该疾病的长期任务
                    ServiceTaskoper serviceTaskoper = new ServiceTaskoper();
                    serviceTaskoper.setLongtask(1L);
                    serviceTaskoper.setOrgid(opItem.getOrgid());
                    serviceTaskoper.setOplevelcode(opItem.getOplevelcode());

                    List<ServiceTaskoper> serviceTaskopers = serviceTaskoperMapper.selectServiceTaskoperList(serviceTaskoper);
                    //如果部门模板为空（将deptIsNull设置为true）
                    if (CollectionUtils.isEmpty(serviceTaskopers) || serviceTaskopers.size() == 0) {
                        PatMedOperationItem patMedOperationItem = patMedOperationItemMapper.selectPatMedOperationItemById(opItem.getId());
                        patMedOperationItem.setOpercheckFlag("2");
                        patMedOperationItem.setLongTaskReason(patMedOperationItem.getLongTaskReason() + "所患的手术未配置长期任务;");
                        patMedOperationItemMapper.updatePatMedOperationItem(patMedOperationItem);
                    } else {
                        for (ServiceTaskoper serviceTaskoper1 : serviceTaskopers) {
                            writeInSubTaskForOp(serviceTaskoper1.getTaskId(), true, opItem, config);
                        }
                    }

                } catch (Exception e) {
                    e.printStackTrace();
                    log.error("人员手术处理出异常了：{}", e.getMessage());
                    opItem.setOpercheckFlag("2");
                    opItem.setLongTaskReason("人员手术处理异常：" + e.getMessage());
                    patMedOperationItemMapper.updatePatMedOperationItem(opItem);
                }
            }
            addOperationSubTask(config);
        }


        //获取未处理在院的数据(如果刚刚出院的患者数据的出院时间,在下面查询出的入院时间之前,那之前的出院患者的数据,也得停掉,因为又入院了)
        PatMedInhosp patMedInhosp = new PatMedInhosp();
        //获取需要出院部门随访，未处理的数据
        patMedInhosp.setDeptcheckFlag("0");
        patMedInhosp.setInhospstate("0");
        List<PatMedInhosp> patMedInhospList = patMedInhospMapper.selectPatMedInhospList(patMedInhosp);
@@ -693,108 +465,6 @@
    }


//
//    @Override
//    public int dealOutHospInfo() {
//        PatMedInhosp patMedInhosp = new PatMedInhosp();
//        //获取需要出院部门随访，未处理的数据
//        patMedInhosp.setDeptcheckFlag("0");
//        patMedInhosp.setInhospstate("1");
//        patMedInhosp.setFuflag("1");
//        List<PatMedInhosp> patMedInhosps = patMedInhospMapper.selectPatMedInhospList(patMedInhosp);
//        log.error("dealOutHospInfo需要处理的出院患者信息：{}", patMedInhosps);
//        for (PatMedInhosp patMedInhosp1 : patMedInhosps) {
//            String tagname = patMedInhospMapper.getTagnameBypatid(patMedInhosp1.getPatid());
//            patMedInhosp1.setTagname(tagname);
//        }
//
//        for (PatMedInhosp patMedInhosp1 : patMedInhosps) {
//            //先根据科室去service_check查询check_visit_flag是根据“科室”随访，还是根据“第一诊断”随访
//            ServiceCheck serviceCheck = new ServiceCheck();
//            serviceCheck.setDeptCode(patMedInhosp1.getDeptcode());
//            serviceCheck.setOrgid(patMedInhosp1.getOrgid());
//            List<ServiceCheck> serviceChecks = serviceCheckMapper.selectServiceCheckList(serviceCheck);
//            //获取患者信息
//            PatArchive patArchive = patArchiveMapper.selectPatArchiveByPatid(patMedInhosp1.getPatid());
//            if (Objects.isNull(patArchive)) {
//                patMedInhosp1.setDeptcheckFlag("2");
//                patMedInhosp1.setLongTaskReason("患者基本信息为空");
//                patMedInhospMapper.updatePatMedInhosp(patMedInhosp1);
//                continue;
//            }
//            try {
//                if (CollectionUtils.isEmpty(serviceChecks) || serviceChecks != null && serviceChecks.get(0).getCheckVisitFlag() == 1 || serviceChecks != null && serviceChecks.get(0).getCheckVisitFlag() == 3) {
//                    //根据患者所在科室，获取该科室的长期任务
//                    ServiceTaskdept serviceTaskdept = new ServiceTaskdept();
//                    serviceTaskdept.setLongtask(1L);
//                    serviceTaskdept.setDeptCode(patMedInhosp1.getLeaveldeptcode());
//                    serviceTaskdept.setServiceType("2");
//                    List<ServiceTaskdept> serviceTaskdepts = serviceTaskdeptMapper.selectServiceTaskdeptList(serviceTaskdept);
//                    //如果部门模板为空（暂定，将出入院表的check_flag设置为2  ，long_task_reason 记录原因）
//                    if (CollectionUtils.isEmpty(serviceTaskdepts) || serviceTaskdepts.size() == 0) {
//                        patMedInhosp1.setDeptcheckFlag("2");
//                        patMedInhosp1.setLongTaskReason("该患者所在科室，未配置长期任务;");
//                        patMedInhospMapper.updatePatMedInhosp(patMedInhosp1);
//                        continue;
//                    } else if (serviceTaskdepts.size() > 1) {
//                        //如果查询出多个任务，那就取第一个，并在患者备注一下
//                        List<Long> tempList = serviceTaskdepts.stream().map(ServiceTaskdept::getTaskId).collect(Collectors.toList());
//                        patMedInhosp1.setLongTaskReason("该患者所在科室，有多个出院随访长期任务:" + tempList);
//                        patMedInhospMapper.updatePatMedInhosp(patMedInhosp1);
//                        ServiceTaskdept serviceTaskdept1 = serviceTaskdepts.get(0);
//                        serviceTaskdepts = new ArrayList<>();
//                        serviceTaskdepts.add(serviceTaskdept1);
//                    }
//
//                    writeInSubTask(serviceTaskdepts.get(0).getTaskId(), true, patMedInhosp1, patArchive);
//                }
//                if (serviceChecks != null && serviceChecks.get(0).getCheckVisitFlag() == 2 || serviceChecks != null && serviceChecks.get(0).getCheckVisitFlag() == 3) {
//                    //丽水需要根据离院疾病对该病人生成一次随访
//                    String[] split = patMedInhosp1.getIcd10code().split(",");
//                    ServiceTaskdiag serviceTaskdiag = new ServiceTaskdiag();
//                    serviceTaskdiag.setLongtask(1L);
//                    serviceTaskdiag.setIcd10code(split[0]);
//                    serviceTaskdiag.setServiceType("2");
//                    List<ServiceTaskdiag> serviceTaskdiags = serviceTaskdiagMapper.selectServiceTaskdiagList(serviceTaskdiag);
//                    PatMedInhosp patMedInhosp2 = patMedInhospMapper.selectPatMedInhospByInhospid(patMedInhosp1.getInhospid());
//                    //如果疾病编码为空（暂定，将出入院表的check_flag设置为3  ，long_task_reason 记录原因）
//                    if (CollectionUtils.isEmpty(serviceTaskdiags) || serviceTaskdiags.size() == 0) {
//                        patMedInhosp1.setDeptcheckFlag("3");
//                        patMedInhosp1.setLongTaskReason(patMedInhosp2.getLongTaskReason() + "该患者的第一疾病编码，未配置长期任务;");
//                        patMedInhospMapper.updatePatMedInhosp(patMedInhosp1);
//                        continue;
//                    } else if (serviceTaskdiags.size() > 1) {
//                        //如果查询出多个任务，那就取第一个，并在患者备注一下
//                        List<Long> tempList = serviceTaskdiags.stream().map(ServiceTaskdiag::getTaskId).collect(Collectors.toList());
//                        patMedInhosp1.setLongTaskReason(patMedInhosp2.getLongTaskReason() + "该患者的第一疾病编码，有多个出院随访长期任务:" + tempList);
//                        patMedInhospMapper.updatePatMedInhosp(patMedInhosp1);
//                        ServiceTaskdiag serviceTaskdiag1 = serviceTaskdiags.get(0);
//                        serviceTaskdiags = new ArrayList<>();
//                        serviceTaskdiags.add(serviceTaskdiag1);
//                    }
//                    writeInSubTask(serviceTaskdiags.get(0).getTaskId(), false, patMedInhosp1, patArchive);
//                }
//
//            } catch (Exception e) {
//                e.printStackTrace();
//                log.error("人员处理出异常了：{}", e.getMessage());
//            }
//        }
//
//        //获取未处理在院的数据(如果刚刚出院的患者数据的出院时间,在下面查询出的入院时间之前,那之前的出院患者的数据,也得停掉,因为又入院了)
//        patMedInhosp.setDeptcheckFlag("0");
//        patMedInhosp.setInhospstate("0");
//        List<PatMedInhosp> patMedInhospList = patMedInhospMapper.selectPatMedInhospList(patMedInhosp);
//        for (PatMedInhosp patMedInhosp1 : patMedInhosps) {
//            String tagname = patMedInhospMapper.getTagnameBypatid(patMedInhosp1.getPatid());
//            patMedInhosp1.setTagname(tagname);
//        }
//        if (CollectionUtils.isNotEmpty(patMedInhospList) && patMedInhospList.size() > 0) {
//            dealInHospInfo(patMedInhospList);
//        }
//        return 1;
//    }

    /**
     * 获取出院，住院，门诊服务人次
     *
@@ -856,7 +526,7 @@
     * @param check         是否需要校验
     * @param patMedInhosp1 病人出入院信息
     * @param patArchive    病人信息
     * @param type          随访类型(1-科室，2-病区，3-疾病）
     * @param type          随访类型(1-科室，2-病区，3-疾病 4-入院科室 5-入院病区)
     * @param config        配置信息 visit.early.day
     */
    //将患者放到subtask中
@@ -886,22 +556,41 @@
                patMedInhosp1.setLongTaskReason(longTaskReason + " & 该患者疾病长期任务不存在,任务ID为:" + taskid);
                patMedInhospMapper.updatePatMedInhosp(patMedInhosp1);
                return;
            } else if (type == 4) {
                patMedInhosp1.setInDeptcheckFlag("2");
                patMedInhosp1.setLongTaskReason(longTaskReason + " & 该患者入院科室长期任务不存在,任务ID为:" + taskid);
                patMedInhospMapper.updatePatMedInhosp(patMedInhosp1);
                return;
            } else if (type == 5) {
                patMedInhosp1.setInWardcheckFlag("2");
                patMedInhosp1.setLongTaskReason(longTaskReason + " & 该患者入院病区长期任务不存在,任务ID为:" + taskid);
                patMedInhospMapper.updatePatMedInhosp(patMedInhosp1);
                return;
            }
        } else {
            serviceTask = serviceTasks.get(0);
        }
        if (Objects.isNull(patMedInhosp1.getEndtime())) {
        if (patMedInhosp1.getInhospstate().equals("1") && Objects.isNull(patMedInhosp1.getEndtime())) {
            return;
        }
        //封装serviceSubtask
        ServiceSubtask serviceSubtask = boxedServiceSubtask(serviceTask, patMedInhosp1, patArchive, config);
        ServiceSubtask serviceSubtask = boxedServiceSubtask(serviceTask, patMedInhosp1, patArchive, config, type);
        if (ObjectUtils.isEmpty(serviceSubtask)) {
            return;
        }
        if (type != 2) {
            //科室和疾病 都用 科室填充
            serviceSubtask.setVisitDeptCode(patMedInhosp1.getLeaveldeptcode());
            serviceSubtask.setVisitDeptName(patMedInhosp1.getLeaveldeptname());
            if (patMedInhosp1.getInhospstate().equals("1")) {
                serviceSubtask.setVisitDeptCode(patMedInhosp1.getLeaveldeptcode());
                serviceSubtask.setVisitDeptName(patMedInhosp1.getLeaveldeptname());
            } else if (patMedInhosp1.getInhospstate().equals("0")) {
                serviceSubtask.setVisitDeptCode(patMedInhosp1.getDeptcode());
                serviceSubtask.setVisitDeptName(patMedInhosp1.getDeptname());
                if (type == 5) {
                    serviceSubtask.setVisitDeptCode(patMedInhosp1.getHospitaldistrictcode());
                    serviceSubtask.setVisitDeptName(patMedInhosp1.getHospitaldistrictname());
                }
            }
        } else if (type == 2) {
            serviceSubtask.setVisitDeptCode(patMedInhosp1.getLeavehospitaldistrictcode());
            serviceSubtask.setVisitDeptName(patMedInhosp1.getLeavehospitaldistrictname());
@@ -1009,7 +698,7 @@
                    i = serviceSubtaskMapper.insertServiceSubtask(serviceSubtask);
                    addServiceSubtaskPreachform(serviceSubtask, null);
                }
            } else if (serviceSubtask.getTaskSituation() == 6) {
            } else if (serviceSubtask.getTaskSituation() != null && serviceSubtask.getTaskSituation() == 6) {
                //说明该患者是被过滤的，不用再执行了
                serviceSubtask.setCreateBy(serviceTask.getCreateBy());
                serviceSubtask.setCreateTime(new Date());
@@ -1035,6 +724,8 @@
                if (type == 1) patMedInhosp2.setDeptcheckFlag("1");
                if (type == 2) patMedInhosp2.setWardcheckFlag("1");
                if (type == 3) patMedInhosp2.setDiagcheckFlag("1");
                if (type == 4) patMedInhosp2.setInDeptcheckFlag("1");
                if (type == 5) patMedInhosp2.setInWardcheckFlag("1");
                patMedInhospMapper.updatePatMedInhosp(patMedInhosp2);
            } else {
                //生成子任务失败，
@@ -1044,6 +735,8 @@
                if (type == 1) patMedInhosp2.setDeptcheckFlag("2");
                if (type == 2) patMedInhosp2.setWardcheckFlag("2");
                if (type == 3) patMedInhosp2.setDiagcheckFlag("2");
                if (type == 4) patMedInhosp2.setInDeptcheckFlag("2");
                if (type == 5) patMedInhosp2.setInWardcheckFlag("2");
                patMedInhosp2.setRemark("生成子任务失败 " + type);
                patMedInhospMapper.updatePatMedInhosp(patMedInhosp2);
            }
@@ -1064,10 +757,10 @@

    /**
     *
     * @param taskid 任务id
     * @param check 是否需要校验
     * @param taskid              任务id
     * @param check               是否需要校验
     * @param patMedOperationItem 手术记录
     * @param config 配置信息 visit.early.day
     * @param config              配置信息 visit.early.day
     */
    //将患者放到subtask中 手术专用
    private void writeInSubTaskForOp(Long taskid, Boolean check, PatMedOperationItem patMedOperationItem, String config) {
@@ -1235,7 +928,7 @@


    //封装serviceSubtask
    private ServiceSubtask boxedServiceSubtask(ServiceTask serviceTask, PatMedInhosp patMedInhosp1, PatArchive patArchive, String config) {
    private ServiceSubtask boxedServiceSubtask(ServiceTask serviceTask, PatMedInhosp patMedInhosp1, PatArchive patArchive, String config, Integer type) {
        //增加serviceTask判空
//        if(Objects.isNull(serviceTask)){
//            return null;
@@ -1251,6 +944,15 @@
        serviceSubtask.setDrname(patMedInhosp1.getDrname());
        serviceSubtask.setDeptcode(patMedInhosp1.getLeaveldeptcode());
        serviceSubtask.setDeptname(patMedInhosp1.getLeaveldeptname());
        serviceSubtask.setLeavehospitaldistrictcode(patMedInhosp1.getLeavehospitaldistrictcode());
        serviceSubtask.setLeavehospitaldistrictname(patMedInhosp1.getLeavehospitaldistrictname());
        if (type == 4 || type == 5) {
            //设置入院的
            serviceSubtask.setDeptcode(patMedInhosp1.getDeptcode());
            serviceSubtask.setDeptname(patMedInhosp1.getDeptname());
            serviceSubtask.setLeavehospitaldistrictcode(patMedInhosp1.getHospitaldistrictcode());
            serviceSubtask.setLeavehospitaldistrictname(patMedInhosp1.getHospitaldistrictname());
        }
        serviceSubtask.setLeaveicd10code(patMedInhosp1.getLeaveicd10code());
        serviceSubtask.setLeavediagname(patMedInhosp1.getDiagname());
        serviceSubtask.setTemplateid(serviceTask.getTemplateid());
@@ -1270,6 +972,7 @@
        serviceSubtask.setServiceType(serviceTask.getServiceType());
        serviceSubtask.setPreachform(serviceTask.getPreachform());
        serviceSubtask.setHospType("2");
        if (type == 4 || type == 5) serviceSubtask.setHospType("6");
        serviceSubtask.setCreateTime(new Date());
        serviceSubtask.setUpdateTime(new Date());
        serviceSubtask.setCreateBy(patMedInhosp1.getNurseName());
@@ -1277,17 +980,24 @@
        serviceSubtask.setLeavehospitaldistrictname(patMedInhosp1.getLeavehospitaldistrictname());
        serviceSubtask.setUpdateBy(serviceTask.getUpdateBy());
        serviceSubtask.setUpdateTime(new Date());
        //如果是宣教就设置为7
        if (serviceTask.getServiceType().equals("17")) serviceSubtask.setTaskSituation(7);
        //设置发送时间
        if (serviceTask.getSendDay() == null) serviceTask.setSendDay(1L);
        Date newDate = null;
        if (!Objects.isNull(patMedInhosp1.getEndtime())) {
            newDate = addDays(patMedInhosp1.getEndtime(), serviceTask.getSendDay().intValue());
        } else {
            patMedInhosp1.setDeptcheckFlag("2");
            patMedInhosp1.setRemark(patMedInhosp1.getRemark() + "& 该患者疾病出院时间为空,出院记录ID为:" + patMedInhosp1.getInhospid());
            patMedInhospMapper.updatePatMedInhosp(patMedInhosp1);
            //如果出院时间为空，则返回一个新对象
            return new ServiceSubtask();
            //如果等于4,说明是入院宣教，入院不可能有endTime
            if (type != 4 && type != 5) {
                patMedInhosp1.setDeptcheckFlag("2");
                patMedInhosp1.setRemark(patMedInhosp1.getRemark() + "& 该患者疾病出院时间为空,出院记录ID为:" + patMedInhosp1.getInhospid());
                patMedInhospMapper.updatePatMedInhosp(patMedInhosp1);
                //如果出院时间为空，则返回一个新对象
                return new ServiceSubtask();
            }
            //入院宣教，基本当天或隔天就要发出
            newDate = addDays(new Date(), serviceTask.getSendDay().intValue());
        }
        serviceSubtask.setLongSendTime(newDate);
        serviceSubtask.setVisitTime(newDate);
@@ -1455,4 +1165,628 @@
        }
    }

    private void addOperationSubTask(String config) {
        //            手术随访
        PatMedOperationItem pmoi = new PatMedOperationItem();
        //获取需要出院疾病随访，未处理的数据
        pmoi.setOpercheckFlag("0");
        pmoi.setMainFlag("1");

        List<PatMedOperationItem> patMedOperationItems = patMedOperationItemMapper.selectPatMedOperationItemList(pmoi);
        log.info("dealOutHospInfo需要处理的出院手术患者信息：{}", CollectionUtils.isNotEmpty(patMedOperationItems) ? patMedOperationItems.size() : null);

        for (PatMedOperationItem opItem : patMedOperationItems) {

            try {
                if (StringUtils.isEmpty(opItem.getOplevelcode())) {
                    continue;
                }
                // 根据患者的疾病，获取该疾病的长期任务
                ServiceTaskoper serviceTaskoper = new ServiceTaskoper();
                serviceTaskoper.setLongtask(1L);
                serviceTaskoper.setOrgid(opItem.getOrgid());
                serviceTaskoper.setOplevelcode(opItem.getOplevelcode());

                List<ServiceTaskoper> serviceTaskopers = serviceTaskoperMapper.selectServiceTaskoperList(serviceTaskoper);
                //如果部门模板为空（将deptIsNull设置为true）
                if (CollectionUtils.isEmpty(serviceTaskopers) || serviceTaskopers.size() == 0) {
                    PatMedOperationItem patMedOperationItem = patMedOperationItemMapper.selectPatMedOperationItemById(opItem.getId());
                    patMedOperationItem.setOpercheckFlag("2");
                    patMedOperationItem.setLongTaskReason(patMedOperationItem.getLongTaskReason() + "所患的手术未配置长期任务;");
                    patMedOperationItemMapper.updatePatMedOperationItem(patMedOperationItem);
                } else {
                    for (ServiceTaskoper serviceTaskoper1 : serviceTaskopers) {
                        writeInSubTaskForOp(serviceTaskoper1.getTaskId(), true, opItem, config);
                    }
                }

            } catch (Exception e) {
                e.printStackTrace();
                log.error("人员手术处理出异常了：{}", e.getMessage());
                opItem.setOpercheckFlag("2");
                opItem.setLongTaskReason("人员手术处理异常：" + e.getMessage());
                patMedOperationItemMapper.updatePatMedOperationItem(opItem);
            }
        }
    }

    private void addIcd10SubTask(String config) {
        PatMedInhosp pmjb = new PatMedInhosp();
        //获取需要出院疾病随访，未处理的数据
        pmjb.setDiagcheckFlag("0");
        pmjb.setInhospstate("1");
        pmjb.setFuflag("1");
        List<PatMedInhosp> patMedInhospJBs = patMedInhospMapper.selectPatMedInhospList(pmjb);
        log.info("dealOutHospInfo需要处理的出院疾病患者信息：{}", CollectionUtils.isNotEmpty(patMedInhospJBs) ? patMedInhospJBs.size() : null);
        for (PatMedInhosp patMedInhosp1 : patMedInhospJBs) {
            String tagname = patMedInhospMapper.getTagnameBypatid(patMedInhosp1.getPatid());
            patMedInhosp1.setTagname(tagname);
        }

        for (PatMedInhosp pmiJB : patMedInhospJBs) {
            //获取患者信息
            PatArchive patArchive = patArchiveMapper.selectPatArchiveByPatid(pmiJB.getPatid());
            if (Objects.isNull(patArchive)) {
                pmiJB.setDiagcheckFlag("2");
                pmiJB.setLongTaskReason("患者基本信息为空");
                patMedInhospMapper.updatePatMedInhosp(pmiJB);
                continue;
            }
            try {
                String errorIcd = null;
                if (StringUtils.isEmpty(pmiJB.getLeaveicd10code())) {
                    continue;
                }
                // 根据患者的疾病，获取该疾病的长期任务
                ServiceTaskdiag serviceTaskdiag = new ServiceTaskdiag();
                serviceTaskdiag.setLongtask(1L);
                serviceTaskdiag.setServiceType("2");
                if (active.equals("nhfy")) {
                    //南华附一的icd10code有重复，所以用主诊断名称去查询
                    serviceTaskdiag.setIcd10name(pmiJB.getLeavediagname());
                    if (StringUtils.isEmpty(pmiJB.getLeavediagname())) {
                        errorIcd = "该患者主诊断名称为空;";
                    }
                } else {
                    serviceTaskdiag.setIcd10code(pmiJB.getLeaveicd10code());
                    if (StringUtils.isEmpty(pmiJB.getLeaveicd10code())) {
                        errorIcd = "该患者主诊断ICD10码为空;";
                    }
                }
                serviceTaskdiag.setOrgid(pmiJB.getOrgid());
                List<ServiceTaskdiag> serviceTaskdiags = serviceTaskdiagMapper.selectServiceTaskdiagListByIcdName(serviceTaskdiag);

                //如果部门模板为空（将deptIsNull设置为true）
                if (StringUtils.isNotEmpty(errorIcd)) {
                    PatMedInhosp patMedInhosp = patMedInhospMapper.selectPatMedInhospByInhospid(pmiJB.getInhospid());
                    pmiJB.setDiagcheckFlag("2");
                    pmiJB.setLongTaskReason(StringUtils.isNotEmpty(patMedInhosp.getLongTaskReason()) ? patMedInhosp.getLongTaskReason() + errorIcd : errorIcd);
                    patMedInhospMapper.updatePatMedInhosp(pmiJB);
                } else if (CollectionUtils.isEmpty(serviceTaskdiags)) {
                    errorIcd = "该患者所患疾病未配置长期任务;";
                    PatMedInhosp patMedInhosp = patMedInhospMapper.selectPatMedInhospByInhospid(pmiJB.getInhospid());
                    pmiJB.setDiagcheckFlag("2");
                    pmiJB.setLongTaskReason(StringUtils.isNotEmpty(patMedInhosp.getLongTaskReason()) ? patMedInhosp.getLongTaskReason() + errorIcd : errorIcd);
                    patMedInhospMapper.updatePatMedInhosp(pmiJB);
                } else {
                    int flag = 0;
                    for (ServiceTaskdiag serviceTaskdept1 : serviceTaskdiags) {
                        //必须科室或病区能匹配上,才可以用这个疾病创建子任务（主要处理一个疾病在多个病区或科室出现）
                        if (StringUtils.isNotEmpty(serviceTaskdept1.getDeptCode()) && serviceTaskdept1.getDeptCode().equals(pmiJB.getLeaveldeptcode())) {
                            writeInSubTask(serviceTaskdept1.getTaskId(), true, pmiJB, patArchive, 3, config);
                            flag = 1;
                        } else if (StringUtils.isNotEmpty(serviceTaskdept1.getWardCode()) && serviceTaskdept1.getWardCode().equals(pmiJB.getLeavehospitaldistrictcode())) {
                            writeInSubTask(serviceTaskdept1.getTaskId(), true, pmiJB, patArchive, 3, config);
                            flag = 1;
                        }
                    }
                    if (flag == 0) {
                        log.error("该科室或病区对于患者所患疾病未配置长期任务,患者：{}", pmiJB.getInhospid());
                        errorIcd = "该科室或病区对于患者所患疾病未配置长期任务;";
                        PatMedInhosp patMedInhosp = patMedInhospMapper.selectPatMedInhospByInhospid(pmiJB.getInhospid());
                        pmiJB.setDiagcheckFlag("2");
                        pmiJB.setLongTaskReason(StringUtils.isNotEmpty(patMedInhosp.getLongTaskReason()) ? patMedInhosp.getLongTaskReason() + errorIcd : errorIcd);
                        patMedInhospMapper.updatePatMedInhosp(pmiJB);
                    }

                }

            } catch (Exception e) {
                e.printStackTrace();
                log.error("人员疾病处理出异常了：{}", e.getMessage());
                pmiJB.setDiagcheckFlag("2");
                pmiJB.setLongTaskReason("人员疾病处理异常：" + e.getMessage());
                patMedInhospMapper.updatePatMedInhosp(pmiJB);
            }
        }
    }

    private void addWardSubTask(String config) {
        PatMedInhosp pmbq = new PatMedInhosp();
        //获取需要出院部门随访，未处理的数据
        pmbq.setWardcheckFlag("0");
        pmbq.setInhospstate("1");
        pmbq.setFuflag("1");
        List<PatMedInhosp> patMedInhospBQs = patMedInhospMapper.selectPatMedInhospList(pmbq);
        log.info("dealOutHospInfo需要处理的出院病区患者信息：{}", CollectionUtils.isNotEmpty(patMedInhospBQs) ? patMedInhospBQs.size() : null);
        for (PatMedInhosp patMedInhosp1 : patMedInhospBQs) {
            String tagname = patMedInhospMapper.getTagnameBypatid(patMedInhosp1.getPatid());
            patMedInhosp1.setTagname(tagname);
        }

        //病区数据处理
        for (PatMedInhosp pmiBQ1 : patMedInhospBQs) {
            if ("1".equals(pmiBQ1.getLeavehospitaldistrictcode()) && pmiBQ1.getDiagcheckFlag().equals("1")) {
                pmiBQ1.setWardcheckFlag("2");
                pmiBQ1.setLongTaskReason("根据交叉生成随访任务规则，病区任务可以不用生成");
                patMedInhospMapper.updatePatMedInhosp(pmiBQ1);
                continue;
            }

            //获取患者信息
            PatArchive patArchive = patArchiveMapper.selectPatArchiveByPatid(pmiBQ1.getPatid());
            if (Objects.isNull(patArchive)) {
                pmiBQ1.setWardcheckFlag("2");
                pmiBQ1.setLongTaskReason("患者基本信息为空");
                patMedInhospMapper.updatePatMedInhosp(pmiBQ1);
                continue;
            }
            try {
                String errorreason = null;
                List<ServiceTaskdept> serviceTaskdeptList = null;
                if (!StringUtils.isEmpty(pmiBQ1.getLeavehospitaldistrictcode())) {
                    ServiceTaskdept serviceTaskdept = new ServiceTaskdept();
                    serviceTaskdept.setLongtask(1L);
                    serviceTaskdept.setDeptCode(pmiBQ1.getLeavehospitaldistrictcode());
                    serviceTaskdept.setDeptType("2");
                    serviceTaskdept.setServiceType("2");
                    serviceTaskdept.setOrgid(pmiBQ1.getOrgid());
                    serviceTaskdeptList = serviceTaskdeptMapper.selectServiceTaskdeptList(serviceTaskdept);
                    if (CollectionUtils.isEmpty(serviceTaskdeptList)) {
                        errorreason = "该患者所在病区未配置长期任务;";
                    }
                } else {
                    errorreason = "离院病区为空;";
                }
                //如果部门模板为空（将deptIsNull设置为true）
                if (StringUtils.isNotEmpty(errorreason)) {
                    PatMedInhosp patMedInhosp = patMedInhospMapper.selectPatMedInhospByInhospid(pmiBQ1.getInhospid());
                    pmiBQ1.setWardcheckFlag("2");
                    pmiBQ1.setLongTaskReason(StringUtils.isNotEmpty(patMedInhosp.getLongTaskReason()) ? patMedInhosp.getLongTaskReason() + errorreason : errorreason);
                    patMedInhospMapper.updatePatMedInhosp(pmiBQ1);
                } else {
                    for (ServiceTaskdept serviceTaskdept1 : serviceTaskdeptList) {
                        writeInSubTask(serviceTaskdept1.getTaskId(), true, pmiBQ1, patArchive, 2, config);
                    }
                }

            } catch (Exception e) {
                e.printStackTrace();
                log.error("人员病区处理出异常了：{}", e.getMessage());
                pmiBQ1.setWardcheckFlag("2");
                pmiBQ1.setLongTaskReason("人员病区处理异常：" + e.getMessage());
                patMedInhospMapper.updatePatMedInhosp(pmiBQ1);
            }
        }
    }

    private void addDeptSubTask(String config) {
        //获取需要出院部门随访，未处理的数据
        PatMedInhosp pmks = new PatMedInhosp();
        pmks.setDeptcheckFlag("0");
        pmks.setInhospstate("1");
        pmks.setFuflag("1");
        List<PatMedInhosp> patMedInhosps = patMedInhospMapper.selectPatMedInhospList(pmks);
        log.info("dealOutHospInfo需要处理的出院部门患者信息：{}", CollectionUtils.isNotEmpty(patMedInhosps) ? patMedInhosps.size() : null);
        for (PatMedInhosp patMedInhosp1 : patMedInhosps) {
            String tagname = patMedInhospMapper.getTagnameBypatid(patMedInhosp1.getPatid());
            patMedInhosp1.setTagname(tagname);
        }

        //科室
        for (PatMedInhosp patMedInhosp1 : patMedInhosps) {
            if ("1".equals(patMedInhosp1.getLeavehospitaldistrictcode()) && patMedInhosp1.getDiagcheckFlag().equals("1")) {
                patMedInhosp1.setDeptcheckFlag("2");
                patMedInhosp1.setLongTaskReason("根据交叉生成随访任务规则，部门任务可以不用生成");
                patMedInhospMapper.updatePatMedInhosp(patMedInhosp1);
                continue;
            }
            //获取患者信息
            PatArchive patArchive = patArchiveMapper.selectPatArchiveByPatid(patMedInhosp1.getPatid());
            if (Objects.isNull(patArchive)) {
                patMedInhosp1.setDeptcheckFlag("2");
                patMedInhosp1.setLongTaskReason("患者基本信息为空");
                patMedInhospMapper.updatePatMedInhosp(patMedInhosp1);
                continue;
            }
            try {
                //根据患者所在科室，获取该科室的长期任务
                ServiceTaskdept serviceTaskdept = new ServiceTaskdept();
                serviceTaskdept.setLongtask(1L);
                serviceTaskdept.setDeptCode(patMedInhosp1.getLeaveldeptcode());
                serviceTaskdept.setDeptType("1");
                serviceTaskdept.setServiceType("2");
                serviceTaskdept.setOrgid(patMedInhosp1.getOrgid());
                List<ServiceTaskdept> serviceTaskdepts = serviceTaskdeptMapper.selectServiceTaskdeptList(serviceTaskdept);
                //如果部门模板为空（将deptIsNull设置为true）
                if (CollectionUtils.isEmpty(serviceTaskdepts) || serviceTaskdepts.size() == 0) {
                    PatMedInhosp patMedInhosp = patMedInhospMapper.selectPatMedInhospByInhospid(patMedInhosp1.getInhospid());
                    patMedInhosp1.setDeptcheckFlag("2");
                    patMedInhosp1.setLongTaskReason(patMedInhosp.getLongTaskReason() + "该患者所在科室未配置离院长期任务;");
                    patMedInhospMapper.updatePatMedInhosp(patMedInhosp1);
                } else {
                    for (ServiceTaskdept serviceTaskdept1 : serviceTaskdepts) {
                        writeInSubTask(serviceTaskdept1.getTaskId(), true, patMedInhosp1, patArchive, 1, config);
                    }
                }

            } catch (Exception e) {
                e.printStackTrace();
                log.error("人员科室处理出异常了：{}", e.getMessage());
                patMedInhosp1.setDeptcheckFlag("2");
                patMedInhosp1.setLongTaskReason("人员科室处理异常：" + e.getMessage());
                patMedInhospMapper.updatePatMedInhosp(patMedInhosp1);
            }
        }
    }

    /**
     * 统一更新pat_med_inhosp的check_flag
     *
     * @param patMedInhosp 患者住院记录
     * @param type         1=deptcheck_flag, 2=wardcheck_flag, 3=diagcheck_flag, 4=inDeptcheck_flag, 5=inWardcheck_flag
     * @param flagValue    要设置的值
     * @param remark       备注信息
     */
    private void updateCheckFlag(PatMedInhosp patMedInhosp, Integer type, String flagValue, String remark) {
        PatMedInhosp updateObj = new PatMedInhosp();
        updateObj.setInhospid(patMedInhosp.getInhospid());
        switch (type) {
            case 1:
                updateObj.setDeptcheckFlag(flagValue);
                break;
            case 2:
                updateObj.setWardcheckFlag(flagValue);
                break;
            case 3:
                updateObj.setDiagcheckFlag(flagValue);
                break;
            case 4:
                updateObj.setInDeptcheckFlag(flagValue);
                break;
            case 5:
                updateObj.setInWardcheckFlag(flagValue);
                break;
        }
        if (StringUtils.isNotEmpty(remark)) {
            updateObj.setRemark(remark + " (type=" + type + ")");
        }
        patMedInhospMapper.updatePatMedInhosp(updateObj);
    }

    /**
     * 基于规则的任务生成方法
     * 根据患者离院科室或病区查询service_task_rule，获取deptRule、wradRule、diagRule
     * 根据规则值决定调用哪个方法生成随访任务
     */
    private void addSubTaskByRule(String config) {
        // 获取所有需要处理的出院患者（科室维度未处理）
        PatMedInhosp pmks = new PatMedInhosp();
        pmks.setDeptcheckFlag("0");
        pmks.setInhospstate("1");
        pmks.setFuflag("1");
        List<PatMedInhosp> patMedInhosps = patMedInhospMapper.selectPatMedInhospList(pmks);
        log.info("【基于规则】需要处理的出院患者信息：{}", CollectionUtils.isNotEmpty(patMedInhosps) ? patMedInhosps.size() : null);

        for (PatMedInhosp patMedInhosp1 : patMedInhosps) {
            // 获取患者基本信息
            PatArchive patArchive = patArchiveMapper.selectPatArchiveByPatid(patMedInhosp1.getPatid());
            if (Objects.isNull(patArchive)) {
                patMedInhosp1.setDeptcheckFlag("2");
                patMedInhosp1.setLongTaskReason("患者基本信息为空");
                patMedInhospMapper.updatePatMedInhosp(patMedInhosp1);
                continue;
            }

            try {
                // 查询规则：根据离院科室或病区
                ServiceTaskRule ruleQuery = new ServiceTaskRule();
                ruleQuery.setDeptcode(patMedInhosp1.getLeaveldeptcode());
                ruleQuery.setWardcode(patMedInhosp1.getLeavehospitaldistrictcode());
                ServiceTaskRule rule = serviceTaskRuleMapper.selectServiceTaskRuleByDeptOrWard(ruleQuery);

                if (rule == null) {
                    // 规则为空，全部生成
                    log.info("【基于规则】患者{}未配置规则，执行全部生成逻辑", patMedInhosp1.getInhospid());
                    addDeptSubTaskForPatient(patMedInhosp1, patArchive, config);
                    if (!active.equals("xh")) {
                        addWardSubTaskForPatient(patMedInhosp1, patArchive, config);
                        addIcd10SubTaskForPatient(patMedInhosp1, patArchive, config);
                    }
                } else {
                    // 有规则，按规则执行
                    log.info("【基于规则】患者{}查询到规则：deptRule={}, wradRule={}, diagRule={}", patMedInhosp1.getInhospid(), rule.getDeptRule(), rule.getWradRule(), rule.getDiagRule());

                    boolean deptIsPrimary = "1".equals(rule.getDeptRule());
                    boolean wardIsPrimary = "1".equals(rule.getWradRule());
                    boolean diagIsPrimary = "1".equals(rule.getDiagRule());
                    boolean deptIsSecondary = "2".equals(rule.getDeptRule());
                    boolean wardIsSecondary = "2".equals(rule.getWradRule());
                    boolean diagIsSecondary = "2".equals(rule.getDiagRule());

                    boolean hasPrimaryRule = deptIsPrimary || wardIsPrimary || diagIsPrimary;

                    if (hasPrimaryRule) {
                        // 第一步：执行所有规则=1的方法，每个独立记录成功/失败
                        int deptGenCount = 0;
                        int wardGenCount = 0;
                        int diagGenCount = 0;

                        if (deptIsPrimary) {
                            log.info("【基于规则】执行科室首要规则");
                            deptGenCount = addDeptSubTaskForPatient(patMedInhosp1, patArchive, config);
                        }

                        if (!active.equals("xh")) {
                            if (wardIsPrimary) {
                                log.info("【基于规则】执行病区首要规则");
                                wardGenCount = addWardSubTaskForPatient(patMedInhosp1, patArchive, config);
                            }

                            if (diagIsPrimary) {
                                log.info("【基于规则】执行疾病首要规则");
                                diagGenCount = addIcd10SubTaskForPatient(patMedInhosp1, patArchive, config);
                            }
                        }

                        int primaryGeneratedCount = deptGenCount + wardGenCount + diagGenCount;
                        log.info("【基于规则】首要规则执行结果: deptGen={}, wardGen={}, diagGen={}, total={}", deptGenCount, wardGenCount, diagGenCount, primaryGeneratedCount);

                        // 第二步：判断首要规则是否有任意一个生成成功
                        if (primaryGeneratedCount > 0) {
                            // 至少有一个首要规则生成成功
                            // —— 将=2的次要规则对应flag设为"2"（跳过）
                            log.info("【基于规则】首要规则有成功(count={})，将次要规则对应flag设为2", primaryGeneratedCount);
                            if (deptIsSecondary) {
                                updateCheckFlag(patMedInhosp1, 1, "2", "首要规则已生成，次要规则跳过");
                            }
                            if (!active.equals("xh")) {
                                if (wardIsSecondary) {
                                    updateCheckFlag(patMedInhosp1, 2, "2", "首要规则已生成，次要规则跳过");
                                }
                                if (diagIsSecondary) {
                                    updateCheckFlag(patMedInhosp1, 3, "2", "首要规则已生成，次要规则跳过");
                                }
                            }
                            // —— 对于=1且生成成功的，将其对应flag设为"1"
                            if (deptIsPrimary && deptGenCount > 0) {
                                updateCheckFlag(patMedInhosp1, 1, "1", "科室首要规则生成成功");
                            }
                            if (!active.equals("xh")) {
                                if (wardIsPrimary && wardGenCount > 0) {
                                    updateCheckFlag(patMedInhosp1, 2, "1", "病区首要规则生成成功");
                                }
                                if (diagIsPrimary && diagGenCount > 0) {
                                    updateCheckFlag(patMedInhosp1, 3, "1", "疾病首要规则生成成功");
                                }
                            }
                            // —— 对于=1但生成失败的，将其对应flag设为"2"
                            if (deptIsPrimary && deptGenCount == 0) {
                                updateCheckFlag(patMedInhosp1, 1, "2", "科室首要规则生成失败");
                            }
                            if (!active.equals("xh")) {
                                if (wardIsPrimary && wardGenCount == 0) {
                                    updateCheckFlag(patMedInhosp1, 2, "2", "病区首要规则生成失败");
                                }
                                if (diagIsPrimary && diagGenCount == 0) {
                                    updateCheckFlag(patMedInhosp1, 3, "2", "疾病首要规则生成失败");
                                }
                            }
                        } else {
                            // 所有首要规则全部失败，将=1的flag设为"2"，然后执行=2的方法
                            log.info("【基于规则】首要规则全部失败，将=1的flag设为2，开始执行次要规则");
                            if (deptIsPrimary) {
                                updateCheckFlag(patMedInhosp1, 1, "2", "科室首要规则全部失败");
                            }
                            if (!active.equals("xh")) {
                                if (wardIsPrimary) {
                                    updateCheckFlag(patMedInhosp1, 2, "2", "病区首要规则全部失败");
                                }
                                if (diagIsPrimary) {
                                    updateCheckFlag(patMedInhosp1, 3, "2", "疾病首要规则全部失败");
                                }
                            }
                            // 执行次要规则(=2)的方法
                            if (deptIsSecondary) {
                                log.info("【基于规则】执行科室次要规则");
                                addDeptSubTaskForPatient(patMedInhosp1, patArchive, config);
                            }

                            if (!active.equals("xh")) {
                                if (wardIsSecondary) {
                                    log.info("【基于规则】执行病区次要规则");
                                    addWardSubTaskForPatient(patMedInhosp1, patArchive, config);
                                }

                                if (diagIsSecondary) {
                                    log.info("【基于规则】执行疾病次要规则");
                                    addIcd10SubTaskForPatient(patMedInhosp1, patArchive, config);
                                }
                            }
                        }
                    } else {
                        // 没有首要规则（都是"2"或其他），全部生成
                        log.info("【基于规则】无首要规则，执行全部生成逻辑");
                        addDeptSubTaskForPatient(patMedInhosp1, patArchive, config);
                        if (!active.equals("xh")) {
                            addWardSubTaskForPatient(patMedInhosp1, patArchive, config);
                            addIcd10SubTaskForPatient(patMedInhosp1, patArchive, config);
                        }
                    }
                }
            } catch (Exception e) {
                e.printStackTrace();
                log.error("【基于规则】患者{}处理异常：{}", patMedInhosp1.getInhospid(), e.getMessage());
                patMedInhosp1.setDeptcheckFlag("2");
                patMedInhosp1.setLongTaskReason("基于规则处理异常：" + e.getMessage());
                patMedInhospMapper.updatePatMedInhosp(patMedInhosp1);
            }
        }
    }

    /**
     * 为单个患者生成科室维度的子任务
     *
     * @return 生成的子任务数量
     */
    private int addDeptSubTaskForPatient(PatMedInhosp patMedInhosp1, PatArchive patArchive, String config) {
        int generatedCount = 0;
        try {
            //根据患者所在科室，获取该科室的长期任务
            ServiceTaskdept serviceTaskdept = new ServiceTaskdept();
            serviceTaskdept.setLongtask(1L);
            serviceTaskdept.setDeptCode(patMedInhosp1.getLeaveldeptcode());
            serviceTaskdept.setDeptType("1");
            serviceTaskdept.setServiceType("2");
            serviceTaskdept.setOrgid(patMedInhosp1.getOrgid());
            List<ServiceTaskdept> serviceTaskdepts = serviceTaskdeptMapper.selectServiceTaskdeptList(serviceTaskdept);

            if (CollectionUtils.isEmpty(serviceTaskdepts)) {
                PatMedInhosp patMedInhosp = patMedInhospMapper.selectPatMedInhospByInhospid(patMedInhosp1.getInhospid());
                patMedInhosp1.setDeptcheckFlag("2");
                patMedInhosp1.setWardcheckFlag(patMedInhosp.getWardcheckFlag());
                patMedInhosp1.setDiagcheckFlag(patMedInhosp.getDiagcheckFlag());
                patMedInhosp1.setLongTaskReason(patMedInhosp.getLongTaskReason() + "该患者所在科室未配置离院长期任务;");
                patMedInhospMapper.updatePatMedInhosp(patMedInhosp1);
            } else {
                for (ServiceTaskdept serviceTaskdept1 : serviceTaskdepts) {
                    writeInSubTask(serviceTaskdept1.getTaskId(), true, patMedInhosp1, patArchive, 1, config);
                    generatedCount++;
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
            log.error("【科室任务】患者{}处理异常：{}", patMedInhosp1.getInhospid(), e.getMessage());
            patMedInhosp1.setDeptcheckFlag("2");
            patMedInhosp1.setLongTaskReason("科室任务处理异常：" + e.getMessage());
            patMedInhospMapper.updatePatMedInhosp(patMedInhosp1);
        }
        return generatedCount;
    }

    /**
     * 为单个患者生成病区维度的子任务
     *
     * @return 生成的子任务数量
     */
    private int addWardSubTaskForPatient(PatMedInhosp patMedInhosp1, PatArchive patArchive, String config) {
        int generatedCount = 0;
        try {
            String errorreason = null;
            List<ServiceTaskdept> serviceTaskdeptList = null;
            if (!StringUtils.isEmpty(patMedInhosp1.getLeavehospitaldistrictcode())) {
                ServiceTaskdept serviceTaskdept = new ServiceTaskdept();
                serviceTaskdept.setLongtask(1L);
                serviceTaskdept.setDeptCode(patMedInhosp1.getLeavehospitaldistrictcode());
                serviceTaskdept.setDeptType("2");
                serviceTaskdept.setServiceType("2");
                serviceTaskdept.setOrgid(patMedInhosp1.getOrgid());
                serviceTaskdeptList = serviceTaskdeptMapper.selectServiceTaskdeptList(serviceTaskdept);
                if (CollectionUtils.isEmpty(serviceTaskdeptList)) {
                    errorreason = "该患者所在病区未配置长期任务;";
                }
            } else {
                errorreason = "离院病区为空;";
            }

            if (StringUtils.isNotEmpty(errorreason)) {
                PatMedInhosp patMedInhosp = patMedInhospMapper.selectPatMedInhospByInhospid(patMedInhosp1.getInhospid());
                patMedInhosp1.setWardcheckFlag("2");
                patMedInhosp1.setDeptcheckFlag(patMedInhosp.getDeptcheckFlag());
                patMedInhosp1.setDiagcheckFlag(patMedInhosp.getDiagcheckFlag());
                patMedInhosp1.setLongTaskReason(StringUtils.isNotEmpty(patMedInhosp.getLongTaskReason()) ? patMedInhosp.getLongTaskReason() + errorreason : errorreason);
                patMedInhospMapper.updatePatMedInhosp(patMedInhosp1);
            } else {
                for (ServiceTaskdept serviceTaskdept1 : serviceTaskdeptList) {
                    writeInSubTask(serviceTaskdept1.getTaskId(), true, patMedInhosp1, patArchive, 2, config);
                    generatedCount++;
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
            log.error("【病区任务】患者{}处理异常：{}", patMedInhosp1.getInhospid(), e.getMessage());
            patMedInhosp1.setWardcheckFlag("2");
            patMedInhosp1.setLongTaskReason("病区任务处理异常：" + e.getMessage());
            patMedInhospMapper.updatePatMedInhosp(patMedInhosp1);
        }
        return generatedCount;
    }

    /**
     * 为单个患者生成疾病维度的子任务
     *
     * @return 生成的子任务数量
     */
    private int addIcd10SubTaskForPatient(PatMedInhosp patMedInhosp1, PatArchive patArchive, String config) {
        int generatedCount = 0;
        try {
            if (StringUtils.isEmpty(patMedInhosp1.getLeaveicd10code())) {
                return 0;
            }

            ServiceTaskdiag serviceTaskdiag = new ServiceTaskdiag();
            serviceTaskdiag.setLongtask(1L);
            serviceTaskdiag.setServiceType("2");
            if (active.equals("nhfy")) {
                serviceTaskdiag.setIcd10name(patMedInhosp1.getLeavediagname());
                if (StringUtils.isEmpty(patMedInhosp1.getLeavediagname())) {
                    PatMedInhosp patMedInhosp = patMedInhospMapper.selectPatMedInhospByInhospid(patMedInhosp1.getInhospid());
                    patMedInhosp1.setDiagcheckFlag("2");
                    patMedInhosp1.setLongTaskReason("该患者主诊断名称为空;");
                    patMedInhospMapper.updatePatMedInhosp(patMedInhosp1);
                    return 0;
                }
            } else {
                serviceTaskdiag.setIcd10code(patMedInhosp1.getLeaveicd10code());
            }
            serviceTaskdiag.setOrgid(patMedInhosp1.getOrgid());
            List<ServiceTaskdiag> serviceTaskdiags = serviceTaskdiagMapper.selectServiceTaskdiagListByIcdName(serviceTaskdiag);

            if (CollectionUtils.isEmpty(serviceTaskdiags)) {
                PatMedInhosp patMedInhosp = patMedInhospMapper.selectPatMedInhospByInhospid(patMedInhosp1.getInhospid());
                patMedInhosp.setDiagcheckFlag("2");
                patMedInhosp.setLongTaskReason("该患者所患疾病未配置长期任务;");
                patMedInhospMapper.updatePatMedInhosp(patMedInhosp);
            } else {
                int flag = 0;
                for (ServiceTaskdiag serviceTaskdiag1 : serviceTaskdiags) {
                    if (StringUtils.isNotEmpty(serviceTaskdiag1.getDeptCode()) && serviceTaskdiag1.getDeptCode().equals(patMedInhosp1.getLeaveldeptcode())) {
                        writeInSubTask(serviceTaskdiag1.getTaskId(), true, patMedInhosp1, patArchive, 3, config);
                        generatedCount++;
                        flag = 1;
                    } else if (StringUtils.isNotEmpty(serviceTaskdiag1.getWardCode()) && serviceTaskdiag1.getWardCode().equals(patMedInhosp1.getLeavehospitaldistrictcode())) {
                        writeInSubTask(serviceTaskdiag1.getTaskId(), true, patMedInhosp1, patArchive, 3, config);
                        generatedCount++;
                        flag = 1;
                    }
                }
                if (flag == 0) {
                    log.error("该科室或病区对于患者所患疾病未配置长期任务,患者：{}", patMedInhosp1.getInhospid());
                    PatMedInhosp patMedInhosp = patMedInhospMapper.selectPatMedInhospByInhospid(patMedInhosp1.getInhospid());
                    patMedInhosp.setDiagcheckFlag("2");
                    patMedInhosp.setLongTaskReason("该科室或病区对于患者所患疾病未配置长期任务;");
                    patMedInhospMapper.updatePatMedInhosp(patMedInhosp);
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
            log.error("【疾病任务】患者{}处理异常：{}", patMedInhosp1.getInhospid(), e.getMessage());
            patMedInhosp1.setDiagcheckFlag("2");
            patMedInhosp1.setLongTaskReason("疾病任务处理异常：" + e.getMessage());
            patMedInhospMapper.updatePatMedInhosp(patMedInhosp1);
        }
        return generatedCount;
    }


}