代码提交

liusheng

8 天以前 9cc2f53b11205309754c2451be061ef5fc337f32

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

@@ -28,8 +28,6 @@
public class PatMedInhospServiceImpl implements IPatMedInhospService {
    @Autowired
    private PatMedInhospMapper patMedInhospMapper;
    @Autowired
    private ServiceCheckMapper serviceCheckMapper;

    @Autowired
    private ServiceTaskdeptMapper serviceTaskdeptMapper;
@@ -40,15 +38,7 @@
    @Autowired
    private PatArchiveMapper patArchiveMapper;
    @Autowired
    private TemplateDeptMapper templateDeptMapper;
    @Autowired
    private PatArchiveImportMapper patArchiveImportMapper;
    @Autowired
    private Icd10AssociationMapper icd10AssociationMapper;
    @Autowired
    private SvyTaskTemplateMapper svyTaskTemplateMapper;
    @Autowired
    private IvrTaskTemplateMapper ivrTaskTemplateMappte;
    @Autowired
    private ServiceTaskMapper serviceTaskMapper;
    @Autowired
@@ -56,13 +46,8 @@
    @Autowired
    private SysUserDeptMapper sysUserDeptMapper;

    @Value("${createTaskServiceType}")
    private List<String> createTaskServiceType;

    //记录长期任务基础信息
    List<IvrLibaTemplate> libaTemplates = new ArrayList<>();
    List<IvrTaskTemplate> ivrTaskTemplates = new ArrayList<>();
    List<ServiceTask> serviceTaskList = new ArrayList<>();
    @Value("${visitHosp}")
    private Integer visitHosp;

    /**
     * 查询患者住院记录
@@ -89,6 +74,19 @@
            patMedInhosp1.setTagname(tagname);
        }
        return patMedInhospList;
    }

    @Override
    public Map<String, Integer> queryPersonCount(PatServiceCount patServiceCount) {
        if (patServiceCount.getInterval() == 1) {
            //周
        } else if (patServiceCount.getInterval() == 2) {
            //月
        } else if (patServiceCount.getInterval() == 3) {
            //年
        }

        return null;
    }

    /**
@@ -202,86 +200,51 @@
        return patMedInhospMapper.deletePatMedInhospByInhospno(inhospno);
    }


    @Override
    public int dealOutHospInfo() {
        PatMedInhosp patMedInhosp = new PatMedInhosp();
        //获取需要出院随访，未处理的数据
        patMedInhosp.setCheckFlag("0");
        patMedInhosp.setInhospstate("1");
        patMedInhosp.setFuflag("1");
        List<PatMedInhosp> patMedInhosps = patMedInhospMapper.selectPatMedInhospList(patMedInhosp);
        log.error("dealOutHospInfo需要处理的出院患者信息：{}", patMedInhosps);

        PatMedInhosp pmks = new PatMedInhosp();
        //获取需要出院部门随访，未处理的数据
        pmks.setDeptcheckFlag("0");
        pmks.setInhospstate("1");
        pmks.setFuflag("1");
        List<PatMedInhosp> patMedInhosps = patMedInhospMapper.selectPatMedInhospList(pmks);
        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.setCheckFlag("2");
                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.setCheckFlag("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);
                //根据患者所在科室，获取该科室的长期任务
                ServiceTaskdept serviceTaskdept = new ServiceTaskdept();
                serviceTaskdept.setLongtask(1L);
                serviceTaskdept.setDeptCode(patMedInhosp1.getLeaveldeptcode());
                serviceTaskdept.setDeptType("1");
                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);
                    }

                    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.setCheckFlag("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);
                    patMedInhosp1.setDeptcheckFlag("1");
                    patMedInhospMapper.updatePatMedInhosp(patMedInhosp1);
                }

            } catch (Exception e) {
@@ -290,19 +253,225 @@
            }
        }

        //根据患者所在病区，获取该病区的长期任务,新华医院可以先不用根据病区和疾病来做
        if (visitHosp != 1) {

            PatMedInhosp pmbq = new PatMedInhosp();
            //获取需要出院部门随访，未处理的数据
            pmbq.setWardcheckFlag("0");
            pmbq.setInhospstate("1");
            pmbq.setFuflag("1");
            List<PatMedInhosp> patMedInhospBQs = patMedInhospMapper.selectPatMedInhospList(pmbq);
            log.error("dealOutHospInfo需要处理的出院病区患者信息：{}", patMedInhosps);
            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 {
                    ServiceTaskdept serviceTaskdept = new ServiceTaskdept();
                    serviceTaskdept.setLongtask(1L);
                    serviceTaskdept.setDeptCode(pmiBQ1.getLeavehospitaldistrictcode());
                    serviceTaskdept.setDeptType("2");
                    serviceTaskdept.setOrgid(pmiBQ1.getOrgid());
                    List<ServiceTaskdept> serviceTaskdeptList = serviceTaskdeptMapper.selectServiceTaskdeptList(serviceTaskdept);
                    //如果部门模板为空（将deptIsNull设置为true）
                    if (CollectionUtils.isEmpty(serviceTaskdeptList) || serviceTaskdeptList.size() == 0) {
                        PatMedInhosp patMedInhosp = patMedInhospMapper.selectPatMedInhospByInhospid(pmiBQ1.getInhospid());
                        pmiBQ1.setWardcheckFlag("2");
                        pmiBQ1.setLongTaskReason(patMedInhosp.getLongTaskReason() + "该患者所在病区未配置长期任务;");
                        patMedInhospMapper.updatePatMedInhosp(pmiBQ1);
                    } else {
                        for (ServiceTaskdept serviceTaskdept1 : serviceTaskdeptList) {
                            writeInSubTask(serviceTaskdept1.getTaskId(), true, pmiBQ1, patArchive, 2);
                        }
                        pmiBQ1.setWardcheckFlag("1");
                        patMedInhospMapper.updatePatMedInhosp(pmiBQ1);
                    }


                } catch (Exception e) {
                    e.printStackTrace();
                    log.error("人员处理出异常了：{}", e.getMessage());
                }
            }

            PatMedInhosp pmjb = new PatMedInhosp();
            //获取需要出院疾病随访，未处理的数据
            pmjb.setDiagcheckFlag("0");
            pmjb.setInhospstate("1");
            pmjb.setFuflag("1");
            List<PatMedInhosp> patMedInhospJBs = patMedInhospMapper.selectPatMedInhospList(pmjb);
            log.error("dealOutHospInfo需要处理的出院疾病患者信息：{}", patMedInhosps);
            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 {
                    if (StringUtils.isEmpty(pmiJB.getLeaveicd10code())) {
                        continue;
                    }
                    // 根据患者的疾病，获取该疾病的长期任务
                    ServiceTaskdiag serviceTaskdiag = new ServiceTaskdiag();
                    serviceTaskdiag.setLongtask(1L);
                    serviceTaskdiag.setIcd10code(pmiJB.getLeaveicd10code());
                    serviceTaskdiag.setOrgid(pmiJB.getOrgid());

                    List<ServiceTaskdiag> serviceTaskdiags = serviceTaskdiagMapper.selectServiceTaskdiagList(serviceTaskdiag);
                    //如果部门模板为空（将deptIsNull设置为true）
                    if (CollectionUtils.isEmpty(serviceTaskdiags) || serviceTaskdiags.size() == 0) {
                        PatMedInhosp patMedInhosp = patMedInhospMapper.selectPatMedInhospByInhospid(pmiJB.getInhospid());
                        pmiJB.setDiagcheckFlag("2");
                        pmiJB.setLongTaskReason(patMedInhosp.getLongTaskReason() + "所患的疾病未配置长期任务;");
                        patMedInhospMapper.updatePatMedInhosp(pmiJB);
                    } else {
                        for (ServiceTaskdiag serviceTaskdept1 : serviceTaskdiags) {
                            writeInSubTask(serviceTaskdept1.getTaskId(), true, pmiJB, patArchive, 3);
                        }
                        pmiJB.setDiagcheckFlag("1");
                        patMedInhospMapper.updatePatMedInhosp(pmiJB);
                    }

                } catch (Exception e) {
                    e.printStackTrace();
                    log.error("人员处理出异常了：{}", e.getMessage());
                }
            }
        }

        //获取未处理在院的数据(如果刚刚出院的患者数据的出院时间,在下面查询出的入院时间之前,那之前的出院患者的数据,也得停掉,因为又入院了)
        patMedInhosp.setCheckFlag("0");
        PatMedInhosp patMedInhosp = new PatMedInhosp();
        //获取需要出院部门随访，未处理的数据
        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;
    }

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

    /**
     * 获取出院，住院，门诊服务人次
@@ -313,7 +482,7 @@
    @Override
    public List<PatMedRes> getDeptRanking(PatMedReq patMedReq) {

        return patMedInhospMapper.getDeptRanking(patMedReq);
        return serviceSubtaskMapper.getDeptRanking(patMedReq);
    }

    @Override
@@ -361,30 +530,21 @@
    }

    //将患者放到subtask中
    private void writeInSubTask(Long taskid, Boolean check, PatMedInhosp patMedInhosp1, PatArchive patArchive) {
    private void writeInSubTask(Long taskid, Boolean check, PatMedInhosp patMedInhosp1, PatArchive patArchive, Integer type) {
        String longTaskReason = patMedInhosp1.getLongTaskReason();
        if (StringUtils.isEmpty(longTaskReason)) longTaskReason = "";
//            Long taskid = std.getTaskId();
        ServiceTask st = new ServiceTask();
        st.setTaskid(taskid);
        st.setSendState(2L);
        List<ServiceTask> serviceTasks = serviceTaskMapper.selectServiceTaskList(st);
        if (CollectionUtils.isEmpty(serviceTasks)) {
            log.error("该患者出院随访长期任务不存在,任务ID为：{}", taskid);
            patMedInhosp1.setCheckFlag("2");
            patMedInhosp1.setDeptcheckFlag("2");
            patMedInhosp1.setLongTaskReason(longTaskReason + " & 该患者出院随访长期任务不存在,任务ID为:" + taskid);
            patMedInhospMapper.updatePatMedInhosp(patMedInhosp1);
            return;
        }
        ServiceTask serviceTask = serviceTasks.get(0);
        if (!createTaskServiceType.contains(serviceTask.getServiceType())) {
            //不是允许的服务类型，则continue
            log.error("该患者出院随访长期任务的服务类型不在自动生成的服务类型列表中,任务ID为：{}", taskid);
            patMedInhosp1.setCheckFlag("2");
            patMedInhosp1.setLongTaskReason(longTaskReason + " & 该患者出院随访长期任务的服务类型不在自动生成的服务类型列表中,任务ID为：" + taskid);
            patMedInhospMapper.updatePatMedInhosp(patMedInhosp1);
            return;
        }
        //封装serviceSubtask
        ServiceSubtask serviceSubtask = boxedServiceSubtask(serviceTask, patMedInhosp1, patArchive);
        Integer i = 0;
@@ -394,6 +554,7 @@
            ServiceSubtaskVO subtask = new ServiceSubtaskVO();
            subtask.setPatid(patArchive.getId());
            subtask.setSendstate(2L);
            subtask.setTaskid(taskid);
            List<ServiceSubtask> selectServiceSubtaskList = serviceSubtaskMapper.selectServiceSubtaskList(subtask);
            log.error("该患者待执行的任务:{}", selectServiceSubtaskList);
            if (CollectionUtils.isNotEmpty(selectServiceSubtaskList) && selectServiceSubtaskList.size() > 0) {
@@ -402,25 +563,40 @@
                        //不是长期任务，不处理
                        continue;
                    }
                    if (serviceSubtask1.getEndtime().before(serviceSubtask.getEndtime())) {
                        //如果当前循环的子任务的出院时间在“准备新增的子任务”的出院时间之前，则将循环的子任务停掉
                    //type = 1或2 表示 ”科室、病区“
                    if (type == 1 || type == 2) {
                        if (serviceSubtask1.getEndtime().before(serviceSubtask.getEndtime()) && serviceSubtask1.getServiceType().equals("2")) {
                            //如果当前循环的子任务的出院时间在“准备新增的子任务”的出院时间之前，则将循环的子任务停掉
                            serviceSubtask1.setSendstate(4L);
                            serviceSubtask1.setRemark("患者再入院");
                            serviceSubtask1.setResult("error");
                            serviceSubtask1.setFinishtime(new Date());
                            serviceSubtask1.setUpdateBy(serviceTask.getUpdateBy());
                            serviceSubtask1.setUpdateTime(new Date());
                            Boolean aBoolean = serviceSubtaskMapper.updateServiceSubtask(serviceSubtask1);
                            if (aBoolean) i = 1;
                        } else {
                            //相反,则将当有的数据停掉
                            serviceSubtask.setResult("error");
                            serviceSubtask.setFinishtime(new Date());
                            serviceSubtask.setSendstate(4L);
                            serviceSubtask.setRemark("当前患者出院时间后有待执行的出院随访长期任务");
                            serviceSubtask.setCreateBy(serviceTask.getCreateBy());
                            serviceSubtask.setCreateTime(new Date());
                            i = serviceSubtaskMapper.insertServiceSubtask(serviceSubtask);
                        }
                    } else if (type == 3) {
                        //type=3 表示疾病
                        //将之前的停掉
                        serviceSubtask1.setSendstate(4L);
                        serviceSubtask1.setRemark("患者再入院");
                        serviceSubtask1.setRemark("疾病患者再入院");
                        serviceSubtask1.setResult("error");
                        serviceSubtask1.setFinishtime(new Date());
                        serviceSubtask1.setUpdateBy(serviceTask.getUpdateBy());
                        serviceSubtask1.setUpdateTime(new Date());
                        Boolean aBoolean = serviceSubtaskMapper.updateServiceSubtask(serviceSubtask1);
                        if (aBoolean) i = 1;
                    } else {
                        //相反,则将当有的数据停掉
                        serviceSubtask.setResult("error");
                        serviceSubtask.setFinishtime(new Date());
                        serviceSubtask.setSendstate(4L);
                        serviceSubtask.setRemark("当前患者出院时间后有待执行的出院随访长期任务");
                        serviceSubtask.setCreateBy(serviceTask.getCreateBy());
                        serviceSubtask.setCreateTime(new Date());
                        serviceSubtaskMapper.updateServiceSubtask(serviceSubtask1);
                        //重新新增子任务
                        i = serviceSubtaskMapper.insertServiceSubtask(serviceSubtask);

                    }
                }
            } else {
@@ -450,17 +626,22 @@
            //将check_flag改成1（已处理）
            PatMedInhosp patMedInhosp2 = new PatMedInhosp();
            patMedInhosp2.setInhospid(patMedInhosp1.getInhospid());
            patMedInhosp2.setCheckFlag("1");
            if (type == 1) patMedInhosp2.setDeptcheckFlag("1");
            if (type == 2) patMedInhosp2.setWardcheckFlag("1");
            if (type == 3) patMedInhosp2.setDiagcheckFlag("1");

            patMedInhospMapper.updatePatMedInhosp(patMedInhosp2);
        } else {
            //生成子任务失败，
            log.error("生成子任务失败serviceSubtask为：{}", serviceSubtask);
            PatMedInhosp patMedInhosp2 = new PatMedInhosp();
            patMedInhosp2.setInhospid(patMedInhosp1.getInhospid());
            patMedInhosp2.setRemark("生成子任务失败");
            if (type == 1) patMedInhosp2.setDeptcheckFlag("2");
            if (type == 2) patMedInhosp2.setWardcheckFlag("2");
            if (type == 3) patMedInhosp2.setDiagcheckFlag("2");
            patMedInhosp2.setRemark("生成子任务失败 " + type);
            patMedInhospMapper.updatePatMedInhosp(patMedInhosp2);
        }

    }

    //封装serviceSubtask
@@ -476,6 +657,8 @@
        serviceSubtask.setDrname(patMedInhosp1.getDrname());
        serviceSubtask.setDeptcode(patMedInhosp1.getLeaveldeptcode());
        serviceSubtask.setDeptname(patMedInhosp1.getLeaveldeptname());
        serviceSubtask.setLeaveicd10code(patMedInhosp1.getLeaveicd10code());
        serviceSubtask.setLeavediagname(patMedInhosp1.getDiagname());
        serviceSubtask.setTemplateid(serviceTask.getTemplateid());
        serviceSubtask.setTemplatename(serviceTask.getTemplatename());
        serviceSubtask.setPatid(patArchive.getId());
@@ -488,7 +671,7 @@
        serviceSubtask.setSendstate(2L);
        serviceSubtask.setStarttime(patMedInhosp1.getStarttime());
        serviceSubtask.setEndtime(patMedInhosp1.getEndtime());
        serviceSubtask.setServiceType("2");
        serviceSubtask.setServiceType(serviceTask.getServiceType());
        serviceSubtask.setPreachform(serviceTask.getPreachform());
        serviceSubtask.setHospType("2");
        serviceSubtask.setCreateTime(new Date());
@@ -538,7 +721,6 @@
                            serviceSubtask1.setResult("error");
                            serviceSubtask1.setFinishtime(new Date());
                            serviceSubtaskMapper.updateServiceSubtask(serviceSubtask1);
//                            patMedInhosp1.setCheckFlag("1");
                        }
                    }
                }