代码提交

liusheng

2026-05-14 0223d776e744e346af5f0bbdfb497b5e30b2a5aa

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

@@ -308,255 +308,25 @@
        }

        //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);
        String generationRule = iSysConfigService.selectConfigByKey("multitask.generation.rule");
        //generationRule    0:所有服务都生成;    1:专病任务优先
        if ("0".equals(generationRule)) {
            //科室任务新增
            addDeptSubTask(config, generationRule);
            //根据患者所在病区，获取该病区的长期任务,新华医院可以先不用根据病区和疾病来做
            if (!active.equals("xh")) {
                addWardSubTask(config, generationRule);
                addIcd10SubTask(config, generationRule);
                addOperationSubTask(config, generationRule);
            }
        }

        //根据患者所在病区，获取该病区的长期任务,新华医院可以先不用根据病区和疾病来做
        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 {
                        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);
                }
            }
//            手术随访
            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);
                }
            }
        //丽水的特殊要求（需要先执行疾病，如果疾病为空，则执行科室和病区）
        if ("1".equals(generationRule)) {
            addIcd10SubTask(config, generationRule);
            //科室任务新增
            addDeptSubTask(config, generationRule);
            addWardSubTask(config, generationRule);
        }

        //获取未处理在院的数据(如果刚刚出院的患者数据的出院时间,在下面查询出的入院时间之前,那之前的出院患者的数据,也得停掉,因为又入院了)
@@ -707,108 +477,6 @@
        return Collections.emptyList();
    }


//
//    @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;
//    }

    /**
     * 获取出院，住院，门诊服务人次
@@ -1510,4 +1178,270 @@
        }
    }

    private void addOperationSubTask(String config, String generationRule) {
        //            手术随访
        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, String generationRule) {
        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, String generationRule) {
        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, String generationRule) {
        //获取需要出院部门随访，未处理的数据
        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);
            }
        }
    }


}