代码提交

liusheng

2025-04-18 55ede3cff5dbbbcb8675d1592a67f20d598d49e7

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

@@ -33,30 +33,21 @@
    private ServiceTaskdeptMapper serviceTaskdeptMapper;

    @Autowired
    private ServiceTaskdiagMapper serviceTaskdiagMapper;

    @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
    private ServiceSubtaskMapper serviceSubtaskMapper;
    @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;

    /**
     * 查询患者住院记录
@@ -77,7 +68,12 @@
     */
    @Override
    public List<PatMedInhosp> selectPatMedInhospList(PatMedInhosp patMedInhosp) {
        return patMedInhospMapper.selectPatMedInhospList(patMedInhosp);
        List<PatMedInhosp> patMedInhospList = patMedInhospMapper.selectPatMedInhospList(patMedInhosp);
        for (PatMedInhosp patMedInhosp1 : patMedInhospList) {
            String tagname = patMedInhospMapper.getTagnameBypatid(patMedInhosp1.getPatid());
            patMedInhosp1.setTagname(tagname);
        }
        return patMedInhospList;
    }

    /**
@@ -191,43 +187,98 @@
        return patMedInhospMapper.deletePatMedInhospByInhospno(inhospno);
    }


    @Override
    public int dealOutHospInfo() {
        //定义三个变量用来记录，这个患者是不是三个随访都是为空
        Boolean deptIsNull = false;
        Boolean wardIsNull = false;
        Boolean diagIsNull = false;

        PatMedInhosp patMedInhosp = new PatMedInhosp();
        //获取需要出院随访，未处理的数据
        patMedInhosp.setCheckFlag("0");
        //获取需要出院部门随访，未处理的数据
        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) {
            //获取患者信息
            PatArchive patArchive = patArchiveMapper.selectPatArchiveByPatid(patMedInhosp1.getPatid());
            if (Objects.isNull(patArchive)) {
                patMedInhosp1.setDeptcheckFlag("2");
                patMedInhosp1.setWardcheckFlag("2");
                patMedInhosp1.setDiagcheckFlag("2");
                patMedInhosp1.setLongTaskReason("患者基本信息为空");
                patMedInhospMapper.updatePatMedInhosp(patMedInhosp1);
                continue;
            }
            try {
                //根据患者所在科室，获取该科室的长期任务
                ServiceTaskdept serviceTaskdept = new ServiceTaskdept();
                serviceTaskdept.setLongtask(1L);
                serviceTaskdept.setDeptCode(patMedInhosp1.getLeaveldeptcode());
                serviceTaskdept.setServiceType("2");
                serviceTaskdept.setDeptType("1");
                List<ServiceTaskdept> serviceTaskdepts = serviceTaskdeptMapper.selectServiceTaskdeptList(serviceTaskdept);
                //如果部门模板为空（暂定，将出入院表的check_flag设置为2  ，long_task_reason 记录原因）
                //如果部门模板为空（将deptIsNull设置为true）
                if (CollectionUtils.isEmpty(serviceTaskdepts) || serviceTaskdepts.size() == 0) {
                    patMedInhosp1.setCheckFlag("2");
                    patMedInhosp1.setLongTaskReason("该患者所在科室，未配置长期任务");
                    deptIsNull = true;
                } else {
                    for (ServiceTaskdept serviceTaskdept1 : serviceTaskdepts) {
                        writeInSubTask(serviceTaskdept1.getTaskId(), true, patMedInhosp1, patArchive, 1);
                    }
                    patMedInhosp1.setDeptcheckFlag("1");
                    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);
                }

                //获取患者信息
                PatArchive patArchive = patArchiveMapper.selectPatArchiveByPatid(patMedInhosp1.getPatid());
                writeInSubTask(serviceTaskdepts, patMedInhosp1, patArchive);
                //根据患者所在病区，获取该病区的长期任务,新华医院可以先不用根据病区和疾病来做
                if (visitHosp != 1) {
                    serviceTaskdept.setLongtask(1L);
                    serviceTaskdept.setDeptCode(patMedInhosp1.getLeavehospitaldistrictcode());
                    serviceTaskdept.setDeptType("2");
                    List<ServiceTaskdept> serviceTaskdeptList = serviceTaskdeptMapper.selectServiceTaskdeptList(serviceTaskdept);
                    //如果部门模板为空（将deptIsNull设置为true）
                    if (CollectionUtils.isEmpty(serviceTaskdeptList) || serviceTaskdeptList.size() == 0) {
                        wardIsNull = true;
                    } else {
                        for (ServiceTaskdept serviceTaskdept1 : serviceTaskdeptList) {
                            writeInSubTask(serviceTaskdept1.getTaskId(), true, patMedInhosp1, patArchive, 2);
                        }
                        patMedInhosp1.setWardcheckFlag("1");
                        patMedInhospMapper.updatePatMedInhosp(patMedInhosp1);
                    }

                    // 根据患者的疾病，获取该疾病的长期任务
                    ServiceTaskdiag serviceTaskdiag = new ServiceTaskdiag();
                    serviceTaskdiag.setLongtask(1L);
                    serviceTaskdiag.setIcd10code(patMedInhosp1.getLeaveldeptcode());
                    List<ServiceTaskdiag> serviceTaskdiags = serviceTaskdiagMapper.selectServiceTaskdiagList(serviceTaskdiag);
                    //如果部门模板为空（将deptIsNull设置为true）
                    if (CollectionUtils.isEmpty(serviceTaskdiags) || serviceTaskdiags.size() == 0) {
                        diagIsNull = true;
                    } else {

                        for (ServiceTaskdiag serviceTaskdept1 : serviceTaskdiags) {
                            writeInSubTask(serviceTaskdept1.getTaskId(), true, patMedInhosp1, patArchive, 3);
                        }
                        patMedInhosp1.setDiagcheckFlag("1");
                        patMedInhospMapper.updatePatMedInhosp(patMedInhosp1);
                    }
                }

                //三个都为空，没法随访了
                if (diagIsNull == true && deptIsNull == true && wardIsNull == true) {
                    patMedInhosp1.setDeptcheckFlag("2");
                    patMedInhosp1.setWardcheckFlag("2");
                    patMedInhosp1.setDiagcheckFlag("2");
                    patMedInhosp1.setLongTaskReason("该患者所在科室、病区 或所患的疾病，未配置长期任务;");
                    patMedInhospMapper.updatePatMedInhosp(patMedInhosp1);
                }

            } catch (Exception e) {
                e.printStackTrace();
                log.error("人员处理出异常了：{}", e.getMessage());
@@ -235,14 +286,120 @@
        }

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

    /**
     * 获取出院，住院，门诊服务人次
@@ -259,6 +416,10 @@
    @Override
    public List<PatMedInhosp> getDocAndPat(PatMedInhosp patMedInhosp) {
        List<PatMedInhosp> patMedInhospList = patMedInhospMapper.selectPatMedInhospList(patMedInhosp);
        for (PatMedInhosp patMedInhosp1 : patMedInhospList) {
            String tagname = patMedInhospMapper.getTagnameBypatid(patMedInhosp1.getPatid());
            patMedInhosp1.setTagname(tagname);
        }
        if (StringUtils.isNotEmpty(patMedInhosp.getPatname()) || StringUtils.isNotEmpty(patMedInhosp.getNurseName()) || StringUtils.isNotEmpty(patMedInhosp.getDrname())) {
            //获取外部导入信息,并将外部患者放到patMedInhospList中
            PatArchiveImport patArchiveImport = new PatArchiveImport();
@@ -297,38 +458,31 @@
    }

    //将患者放到subtask中
    private void writeInSubTask(List<ServiceTaskdept> serviceTaskdepts, 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 = "";
        for (ServiceTaskdept std : serviceTaskdepts) {
            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.setLongTaskReason(longTaskReason + " & 该患者出院随访长期任务不存在,任务ID为:" + taskid);
                patMedInhospMapper.updatePatMedInhosp(patMedInhosp1);
                continue;
            }
            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);
                continue;
            }
            //封装serviceSubtask
            ServiceSubtask serviceSubtask = boxedServiceSubtask(serviceTask, patMedInhosp1, patArchive);
            Integer i = 0;
        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.setDeptcheckFlag("2");
            patMedInhosp1.setLongTaskReason(longTaskReason + " & 该患者出院随访长期任务不存在,任务ID为:" + taskid);
            patMedInhospMapper.updatePatMedInhosp(patMedInhosp1);
            return;
        }
        ServiceTask serviceTask = serviceTasks.get(0);
        //封装serviceSubtask
        ServiceSubtask serviceSubtask = boxedServiceSubtask(serviceTask, patMedInhosp1, patArchive);
        Integer i = 0;
        //先判断一下，是否需要校验
        if (check) {
            //在新增之前，先通过患者ID，sendstate=2查询一下，在所有长期任务中，是不是还有该患者待执行的任务，有的话,比较之前的endtime是否小于当前的endtaime,如果之前的小于现在的，则直接将之前的停掉（原因再入院）
            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) {
@@ -337,38 +491,84 @@
                        //不是长期任务，不处理
                        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());
                        Boolean aBoolean = serviceSubtaskMapper.updateServiceSubtask(serviceSubtask1);
                        if (aBoolean) i = 1;
                    } else {
                        //相反,则将当有的数据停掉
                        serviceSubtask.setResult("error");
                        serviceSubtask.setFinishtime(new Date());
                        serviceSubtask.setSendstate(4L);
                        serviceSubtask.setRemark("当前患者出院时间后有待执行的出院随访长期任务");
                        serviceSubtask1.setUpdateBy(serviceTask.getUpdateBy());
                        serviceSubtaskMapper.updateServiceSubtask(serviceSubtask1);
                        //重新新增子任务
                        i = serviceSubtaskMapper.insertServiceSubtask(serviceSubtask);

                    }
                }
            }
            i = serviceSubtaskMapper.insertServiceSubtask(serviceSubtask);
            if (i == 1) {
                //将check_flag改成1（已处理）
                PatMedInhosp patMedInhosp2 = new PatMedInhosp();
                patMedInhosp2.setInhospid(patMedInhosp1.getInhospid());
                patMedInhosp2.setCheckFlag("1");
                patMedInhospMapper.updatePatMedInhosp(patMedInhosp2);
            } else {
                //生成子任务失败，
                log.error("生成子任务失败serviceSubtask为：{}", serviceSubtask);
                PatMedInhosp patMedInhosp2 = new PatMedInhosp();
                patMedInhosp2.setInhospid(patMedInhosp1.getInhospid());
                patMedInhosp2.setRemark("生成子任务失败");
                patMedInhospMapper.updatePatMedInhosp(patMedInhosp2);
                if (StringUtils.isEmpty(serviceSubtask.getPhone())) {
                    serviceSubtask.setRemark("手机号为空");
                    serviceSubtask.setSendstate(4L);
                    serviceSubtask.setResult("error");
                    serviceSubtask.setFinishtime(new Date());
                }
                serviceSubtask.setCreateBy(serviceTask.getCreateBy());
                serviceSubtask.setCreateTime(new Date());
                i = serviceSubtaskMapper.insertServiceSubtask(serviceSubtask);
            }
        } else {
            if (StringUtils.isEmpty(serviceSubtask.getPhone())) {
                serviceSubtask.setRemark("手机号为空");
                serviceSubtask.setSendstate(4L);
                serviceSubtask.setResult("error");
                serviceSubtask.setFinishtime(new Date());

            }
            serviceSubtask.setCreateBy(serviceTask.getCreateBy());
            serviceSubtask.setCreateTime(new Date());
            i = serviceSubtaskMapper.insertServiceSubtask(serviceSubtask);
        }
        if (i == 1) {
            //将check_flag改成1（已处理）
            PatMedInhosp patMedInhosp2 = new PatMedInhosp();
            patMedInhosp2.setInhospid(patMedInhosp1.getInhospid());
            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());
            if (type == 1) patMedInhosp2.setDeptcheckFlag("2");
            if (type == 2) patMedInhosp2.setWardcheckFlag("2");
            if (type == 3) patMedInhosp2.setDiagcheckFlag("2");
            patMedInhosp2.setRemark("生成子任务失败 " + type);
            patMedInhospMapper.updatePatMedInhosp(patMedInhosp2);
        }
    }

@@ -405,6 +605,8 @@
        serviceSubtask.setCreateBy(patMedInhosp1.getNurseName());
        serviceSubtask.setLeavehospitaldistrictcode(patMedInhosp1.getLeavehospitaldistrictcode());
        serviceSubtask.setLeavehospitaldistrictname(patMedInhosp1.getLeavehospitaldistrictname());
        serviceSubtask.setUpdateBy(serviceTask.getUpdateBy());
        serviceSubtask.setUpdateTime(new Date());
        //设置发送时间
        if (serviceTask.getSendDay() == null) serviceTask.setSendDay(1L);
        Date newDate = addDays(patMedInhosp1.getEndtime(), serviceTask.getSendDay().intValue());
@@ -445,7 +647,6 @@
                            serviceSubtask1.setResult("error");
                            serviceSubtask1.setFinishtime(new Date());
                            serviceSubtaskMapper.updateServiceSubtask(serviceSubtask1);
//                            patMedInhosp1.setCheckFlag("1");
                        }
                    }
                }