【市一】1、登录服务问题处理 2、电话挂断问题处理 3、查询报错问题处理

陈昶聿

15 小时以前 2d3b575ed96eee7ccd5b324baa3135d2236934ac

 ruoyi-quartz/src/main/java/com/ruoyi/quartz/task/RyTask.java

@@ -33,6 +33,7 @@
import com.ruoyi.system.service.ISysUserService;
import com.ruoyi.message.sms.provider.sltd.ws.MessageSend;
import com.smartor.common.QwenLLMUtil;
import com.smartor.common.SpecificArchiveConstants;
import com.smartor.domain.*;
import com.ruoyi.task.domain.VO.ServiceSubtaskDetailTraceVO;
import com.smartor.mapper.*;
@@ -68,8 +69,12 @@
import com.ruoyi.task.domain.ServiceSubtask;
import com.ruoyi.task.domain.ServiceSubtaskRecord;
import com.ruoyi.task.domain.ServiceTask;
import com.ruoyi.task.domain.ServiceTaskSchedule;
import com.ruoyi.task.domain.ServiceTaskScheduleDetail;
import com.ruoyi.task.mapper.ServiceSubtaskMapper;
import com.ruoyi.task.mapper.ServiceTaskMapper;
import com.ruoyi.task.mapper.ServiceTaskScheduleMapper;
import com.ruoyi.task.mapper.ServiceTaskScheduleDetailMapper;
import com.ruoyi.task.domain.ServiceSubtaskDetailTrace;
import com.ruoyi.task.domain.VO.ServiceSubtaskDetailTraceVO;
import com.ruoyi.task.service.IServiceSubtaskDetailTraceService;
@@ -166,6 +171,12 @@

    @Autowired
    private ServiceSubtaskMapper serviceSubtaskMapper;

    @Autowired
    private ServiceTaskScheduleMapper serviceTaskScheduleMapper;

    @Autowired
    private ServiceTaskScheduleDetailMapper serviceTaskScheduleDetailMapper;

    @Autowired
    private RedisCache redisCache;
@@ -1164,12 +1175,48 @@
            serviceSubtaskPreachform.setSubid(serviceSubtask.getId());
            serviceSubtaskPreachform.setOrgid(serviceSubtask.getOrgid());
            List<ServiceSubtaskPreachform> serviceSubtaskPreachforms = serviceSubtaskPreachformMapper.selectServiceSubtaskPreachformList(serviceSubtaskPreachform);
            if (CollectionUtils.isEmpty(serviceSubtaskPreachforms)) {
                // current_preachform 有值但发送方式明细一条都没有，属于不可修复的脏数据。
                log.error("【compensateTask】子任务发送方式明细为空，subid：{}，currentPreachform：{}",
                        serviceSubtask.getId(), serviceSubtask.getCurrentPreachform());
                closeSubtaskForMissingPreachform(serviceSubtask);
                continue;
            }
            //获取当前执行方式的序号
            Optional<Long> currentSort = serviceSubtaskPreachforms.stream().filter(item -> serviceSubtask.getCurrentPreachform().equals(item.getPreachform())).map(ServiceSubtaskPreachform::getSort).findFirst();
            Optional<Long> id = serviceSubtaskPreachforms.stream().filter(item -> serviceSubtask.getCurrentPreachform().equals(item.getPreachform())).map(ServiceSubtaskPreachform::getId).findFirst();
            Optional<Long> currentSort = serviceSubtaskPreachforms.stream()
                    .filter(Objects::nonNull)
                    .filter(item -> serviceSubtask.getCurrentPreachform().equals(item.getPreachform()))
                    .map(ServiceSubtaskPreachform::getSort)
                    .findFirst();
            Optional<Long> id = serviceSubtaskPreachforms.stream()
                    .filter(Objects::nonNull)
                    .filter(item -> serviceSubtask.getCurrentPreachform().equals(item.getPreachform()))
                    .map(ServiceSubtaskPreachform::getId)
                    .findFirst();
            if (currentSort.isPresent()) {
                // 方案B：只处理当前子任务——公众号已领取(service_subtask.sendstate=1 + current_preachform=5)
                // 且未填写时，按默认选项完成，避免进入下一种发送方式或最后一步超时。
                // 先用内存字段快速过滤，其他医院/任务/发送方式不会进入下面的默认完成逻辑。
                if (IServiceSubtaskService.WECHAT_DEFAULT_COMPLETE_ORGID.equals(serviceSubtask.getOrgid())
                        && "2".equals(serviceSubtask.getType())
                        && "5".equals(serviceSubtask.getCurrentPreachform())
                        && Long.valueOf(1L).equals(serviceSubtask.getSendstate())
                        && !Long.valueOf(1L).equals(serviceSubtask.getSubmit())) {
                    try {
                        if (iServiceSubtaskService.completeWechatClaimedByDefault(serviceSubtask)) {
                            log.info("【compensateTask】subid：{}，微信公众号已领取未填写，按默认选项完成", serviceSubtask.getId());
                            continue;
                        }
                    } catch (Exception e) {
                        // 单个子任务失败不影响其他任务，回滚后继续原补偿流程
                        log.error("【compensateTask】微信公众号默认完成失败，subid：{}，继续原补偿流程", serviceSubtask.getId(), e);
                    }
                }

                //1先检查一下，是不是有执行状态是完成的（怕之前已经有完的了，没有将servuce_subtask的状态改成功，这里再检查一下）
                boolean finishState = serviceSubtaskPreachforms.stream().allMatch(item -> item.getSendstate().equals("9"));
                boolean finishState = serviceSubtaskPreachforms.stream()
                        .filter(Objects::nonNull)
                        .allMatch(item -> "9".equals(item.getSendstate()));
                if (finishState) {
                    serviceSubtask.setSendstate(6L);
                    serviceSubtaskMapper.updateServiceSubtask(serviceSubtask);
@@ -1185,15 +1232,20 @@

                    serviceSubtaskMapper.updateServiceSubtask(serviceSubtask);
                    //修改发送方式的状态为失败
                    serviceSubtaskPreachform.setSendstate("5");
                    serviceSubtaskPreachform.setId(id.get());

                    serviceSubtaskPreachformMapper.updateServiceSubtaskPreachform(serviceSubtaskPreachform);
                    if (id.isPresent()) {
                        serviceSubtaskPreachform.setSendstate("5");
                        serviceSubtaskPreachform.setId(id.get());
                        serviceSubtaskPreachformMapper.updateServiceSubtaskPreachform(serviceSubtaskPreachform);
                    }
                    continue;
                }

                //3.不是最后一个，获取到下一个执行方式(因为都是在今天执行，那就直接发出去就完了)
                sfHandlle(serviceSubtask);
            } else {
                log.error("【compensateTask】current_preachform 在发送方式明细中不存在，subid：{}，currentPreachform：{}",
                        serviceSubtask.getId(), serviceSubtask.getCurrentPreachform());
                closeSubtaskForMissingPreachform(serviceSubtask);
            }
        }
    }
@@ -1247,11 +1299,31 @@
    }

    /**
     * 随访-补偿处理
     * 随访-补偿处理。
     * <p>
     * 单条子任务异常只记录日志，不影响同一批次其他子任务。
     *
     * @param serviceSubtask
     */
    private void sfHandlle(ServiceSubtask serviceSubtask) {
        try {
            doSfHandlle(serviceSubtask);
        } catch (Exception e) {
            log.error("【sfHandlle】处理子任务异常，subid={}，taskid={}，orgid={}",
                    serviceSubtask == null ? null : serviceSubtask.getId(),
                    serviceSubtask == null ? null : serviceSubtask.getTaskid(),
                    serviceSubtask == null ? null : serviceSubtask.getOrgid(), e);
        }
    }

    /**
     * 随访-补偿处理实际逻辑。
     */
    private void doSfHandlle(ServiceSubtask serviceSubtask) {
        if (serviceSubtask == null) {
            log.error("【sfHandlle】子任务为空，跳过处理");
            return;
        }
        //这里需要根据身份证去重(给微信小程序的固定任务用的)
        List<ServiceSubtask> serviceSubtaskListFilter = new ArrayList<>();
        ServiceTask ivrTask1 = serviceTaskMapper.selectServiceTaskByTaskid(serviceSubtask.getTaskid());
@@ -1261,15 +1333,31 @@
        //获取发送方式
        String sendPreachform = getSendPreachform(serviceSubtaskPreachform, serviceSubtask);
        log.info("sendPreachform的发送方式是啥：{}", sendPreachform);
        if (sendPreachform.equals("-1") || serviceSubtask.getSendstate() == 6 || serviceSubtask.getSendstate() == 5 || serviceSubtask.getSendstate() == 4) {
            //说明已经全部遍历完了，当前的执行方式序号是最后一个了   或者  该患者已经随访结束（成功或失败了或不执行）
            log.error("说明已经全部遍历完了，当前的执行方式序号是最后一个了   或者  该患者已经随访结束（成功或失败了或不执行）");

        Long sendstate = serviceSubtask.getSendstate();
        if (Long.valueOf(6L).equals(sendstate)
                || Long.valueOf(5L).equals(sendstate)
                || Long.valueOf(4L).equals(sendstate)) {
            //该患者已经随访结束（成功、失败或不执行）
            log.error("该患者已经随访结束（成功、失败或不执行），subid={}，sendstate={}", serviceSubtask.getId(), sendstate);
            return;
        }
        if (StringUtils.isEmpty(sendPreachform)) {
            // 老数据可能存在 service_subtask_preachform 缺失、service_task.preachform_desc 为空、
            // current_preachform 与明细不一致等情况。此时不能继续，否则 sendPreachform.equals(...) 会 NPE。
            closeSubtaskForMissingPreachform(serviceSubtask);
            return;
        }
        if ("-1".equals(sendPreachform)) {
            //说明已经全部遍历完了，当前的执行方式序号是最后一个了
            log.error("说明已经全部遍历完了，当前的执行方式序号是最后一个了，subid={}", serviceSubtask.getId());
            return;
        }

        //先判断患者是不是还要发送
        PatArchive patArchive = patArchiveService.selectPatArchiveByPatid(serviceSubtask.getPatid());
        log.info("patArchive的值为：{}", patArchive);
        if (!Objects.isNull(patArchive) && patArchive.getNotrequiredFlag() == "1") {
        if (!Objects.isNull(patArchive) && "1".equals(patArchive.getNotrequiredFlag())) {
            //不需要发送
            serviceSubtask.setResult("患者不需要随访");
            serviceSubtask.setRemark(StringUtils.isNotEmpty(serviceSubtask.getRemark()) ? serviceSubtask.getRemark() + "," + "患者不需要随访," + patArchive.getNotrequiredreason() : "患者不需要随访," + patArchive.getNotrequiredreason());
@@ -1280,7 +1368,14 @@
            return;
        }

        String descByCode = ServiceFromEnum.getDescByCode(Integer.valueOf(sendPreachform));
        int sendCode = NumberUtils.toInt(sendPreachform, -1);
        String descByCode = ServiceFromEnum.getDescByCode(sendCode);
        if (StringUtils.isEmpty(descByCode)) {
            log.error("【sfHandlle】发送方式编码非法，subid={}，taskid={}，sendPreachform={}",
                    serviceSubtask.getId(), serviceSubtask.getTaskid(), sendPreachform);
            closeSubtaskForMissingPreachform(serviceSubtask);
            return;
        }

        // ⚠️ 2025 修复（宣教开关失效）：type == 3 是**宣教/通知**（纯发送、无作答 ——
        // 见 setSuccessPreachForm 里「宣教或通知…直接改成 9」、以及本方法后面
@@ -1379,7 +1474,7 @@
                    serviceOutPath.setOrgid(serviceSubtask.getOrgid());
                    iServiceOutPathService.insertServiceOutPath(serviceOutPath);
                    String url = "";
                    String format = String.format("%03X", serviceOutPath.getId());
                    String format = ShortCode.encode(serviceOutPath.getId());
                    //先判断一下发的是不是宣教
                    log.info("serviceSubtask.getType的值为：{}", serviceSubtask.getType());
                    if (!"3".equals(serviceSubtask.getType())) {
@@ -1387,7 +1482,7 @@
                        url = StringUtils.isNotEmpty(req_path) ? localIP + ":" + req_path + "/wt?p=" + format : localIP + "/wt?p=" + format;
                        sendMagParam.setUrl(url);
                        //如果type是语音随访的话（说明补偿发送方式中有电话随访的方式，这里的外链就地址只能用/sf）
                        if (serviceSubtask.getType().equals("1"))
                        if ("1".equals(serviceSubtask.getType()))
                            url = StringUtils.isNotEmpty(req_path) ? localIP + ":" + req_path + "/sf?p=" + format : localIP + "/sf?p=" + format;
                        sendMagParam.setUrl(url);

@@ -1522,7 +1617,7 @@
                    serviceOutPath.setCreateTime(new Date());
                    serviceOutPath.setOrgid(serviceSubtask.getOrgid());
                    iServiceOutPathService.insertServiceOutPath(serviceOutPath);
                    String format = String.format("%03X", serviceOutPath.getId());
                    String format = ShortCode.encode(serviceOutPath.getId());
                    serviceOutPath.setRadix(format);
                    serviceOutPath.setUpdateTime(new Date());
                    serviceOutPath.setUrl(url);
@@ -1564,6 +1659,46 @@
            setSuccessPreachForm(serviceSubtask, sendPreachform, "人工发送成功", "2");
        }

    }

    /**
     * 老数据兜底：子任务没有可用发送方式时，标记为超时并写清原因。
     * <p>
     * 这类数据通常来自 {@code service_subtask_preachform} 缺失、{@code service_task.preachform_desc}
     * 为空/非法，或 {@code current_preachform} 与明细不一致。标记为终态后不会再被
     * {@code longTaskSend}/{@code compensateTask} 反复捞取，也不会因一条脏数据中断整批任务。
     */
    private void closeSubtaskForMissingPreachform(ServiceSubtask serviceSubtask) {
        if (serviceSubtask == null || serviceSubtask.getId() == null) {
            log.error("【sfHandlle】子任务为空或缺少ID，无法标记无发送方式");
            return;
        }
        try {
            Long currentSendstate = serviceSubtask.getSendstate();
            if (Long.valueOf(4L).equals(currentSendstate)
                    || Long.valueOf(5L).equals(currentSendstate)
                    || Long.valueOf(6L).equals(currentSendstate)
                    || Long.valueOf(7L).equals(currentSendstate)) {
                log.warn("【sfHandlle】子任务已是终态，不再重复标记。subid={}，sendstate={}",
                        serviceSubtask.getId(), currentSendstate);
                return;
            }
            String reason = "未查询到有效发送方式，任务自动终止（数据异常，请检查service_subtask_preachform与service_task.preachform_desc）";
            // 只更新必要字段，避免把查询时的整行快照覆盖回数据库。
            ServiceSubtask update = new ServiceSubtask();
            update.setId(serviceSubtask.getId());
            update.setSendstate(7L);
            update.setUpdateTime(new Date());
            update.setRemark(StringUtils.isNotEmpty(serviceSubtask.getRemark())
                    ? serviceSubtask.getRemark() + "," + reason : reason);
            serviceSubtaskMapper.updateServiceSubtask(update);
            log.error("【sfHandlle】子任务无有效发送方式，已标记为超时。subid={}，taskid={}，orgid={}，currentPreachform={}",
                    serviceSubtask.getId(), serviceSubtask.getTaskid(), serviceSubtask.getOrgid(),
                    serviceSubtask.getCurrentPreachform());
        } catch (Exception e) {
            log.error("【sfHandlle】标记无发送方式子任务失败，subid={}，taskid={}",
                    serviceSubtask.getId(), serviceSubtask.getTaskid(), e);
        }
    }

    /**
@@ -1664,7 +1799,13 @@

        // 情况1：currentPreachform为空，取sort为1的preachform
        if (StringUtils.isEmpty(serviceSubtask.getCurrentPreachform())) {
            String firstPreachform = serviceSubtaskPreachforms.stream().filter(item -> item.getSort() == 1L).map(ServiceSubtaskPreachform::getPreachform).findFirst().orElse(null);
            String firstPreachform = serviceSubtaskPreachforms.stream()
                    .filter(Objects::nonNull)
                    .filter(item -> Long.valueOf(1L).equals(item.getSort()))
                    .map(ServiceSubtaskPreachform::getPreachform)
                    .filter(item -> StringUtils.isNotEmpty(item))
                    .findFirst()
                    .orElse(null);

            //更新一下当前发送时间
            if (StringUtils.isNotEmpty(firstPreachform)) {
@@ -1676,11 +1817,17 @@
        }

        // 情况2：currentPreachform不为空，找下一个sort
        Optional<Long> currentSort = serviceSubtaskPreachforms.stream().filter(item -> serviceSubtask.getCurrentPreachform().equals(item.getPreachform())).map(ServiceSubtaskPreachform::getSort).findFirst();
        Optional<Long> currentSort = serviceSubtaskPreachforms.stream()
                .filter(Objects::nonNull)
                .filter(item -> serviceSubtask.getCurrentPreachform().equals(item.getPreachform()))
                .map(ServiceSubtaskPreachform::getSort)
                .findFirst();

        if (currentSort.isPresent()) {
            // 检查是否所有sendstate不等于9
            boolean allSendStateNot1AndNot9 = serviceSubtaskPreachforms.stream().allMatch(item -> !item.getSendstate().equals("9"));
            boolean allSendStateNot1AndNot9 = serviceSubtaskPreachforms.stream()
                    .filter(Objects::nonNull)
                    .allMatch(item -> !"9".equals(item.getSendstate()));
            if (!allSendStateNot1AndNot9) {
                //说明，在某种方式发送失败后，又成功了（例如短信或公众号，在规定时间外患者做完了，这个时候，状态改成了9）
                serviceSubtask.setSendstate(6L);
@@ -1710,7 +1857,13 @@
            }

            // 找到下一个sort对应的preachform
            String nextPreachform = serviceSubtaskPreachforms.stream().filter(item -> nextSort.equals(item.getSort())).map(ServiceSubtaskPreachform::getPreachform).findFirst().orElse("-1");
            String nextPreachform = serviceSubtaskPreachforms.stream()
                    .filter(Objects::nonNull)
                    .filter(item -> nextSort.equals(item.getSort()))
                    .map(ServiceSubtaskPreachform::getPreachform)
                    .filter(item -> StringUtils.isNotEmpty(item))
                    .findFirst()
                    .orElse("-1");

            //更新一下当前发送时间
            if (StringUtils.isNotEmpty(nextPreachform)) {
@@ -1720,36 +1873,62 @@
            }
            return nextPreachform;
        }

        log.warn("【getSendPreachform】未找到可用的发送方式，subid={}，taskid={}，currentPreachform={}",
                serviceSubtask.getId(), serviceSubtask.getTaskid(), serviceSubtask.getCurrentPreachform());
        return null;
    }

    private List<ServiceSubtaskPreachform> addServiceSubtaskPreachform(ServiceSubtask serviceSubtask, String sendstate) {
        //将preachformDesc的json对象，放到list集合中
        ServiceTask serviceTask = serviceTaskMapper.selectServiceTaskByTaskid(serviceSubtask.getTaskid());
        if (serviceTask == null) {
            log.error("ryTask--发送方式初始化失败，任务不存在，taskid={}，subid={}",
                    serviceSubtask.getTaskid(), serviceSubtask.getId());
            return Collections.emptyList();
        }
        String preachformDesc = serviceTask.getPreachformDesc();

        List<ServiceSubtaskPreachform> sspl = null;
        ObjectMapper objectMapper = new ObjectMapper();
        if (org.apache.commons.lang3.StringUtils.isNotEmpty(preachformDesc)) {
            try {
                sspl = objectMapper.readValue(preachformDesc, new TypeReference<List<ServiceSubtaskPreachform>>() {
                });
            } catch (JsonProcessingException e) {
                log.error("ryTask--preachform转List<ServiceSubtaskPreachform>报错了：{}", e.getMessage());
            }
            for (ServiceSubtaskPreachform serviceSubtaskPreachform : sspl) {
                serviceSubtaskPreachform.setTaskid(serviceSubtask.getTaskid());
                serviceSubtaskPreachform.setSubid(serviceSubtask.getId());
                //这个sendstate需要在数据库设置一个默认值为“1”
                serviceSubtaskPreachform.setSendstate("1");
                if (StringUtils.isNotEmpty(sendstate)) serviceSubtaskPreachform.setSendstate(sendstate);
                serviceSubtaskPreachform.setOrgid(serviceSubtask.getOrgid());
                serviceSubtaskPreachformMapper.insertServiceSubtaskPreachform(serviceSubtaskPreachform);
            }

        if (StringUtils.isEmpty(preachformDesc)) {
            log.error("ryTask--发送方式初始化失败，preachform_desc为空，taskid={}，subid={}",
                    serviceSubtask.getTaskid(), serviceSubtask.getId());
            return Collections.emptyList();
        }

        return sspl;
        List<ServiceSubtaskPreachform> sspl;
        ObjectMapper objectMapper = new ObjectMapper();
        try {
            sspl = objectMapper.readValue(preachformDesc, new TypeReference<List<ServiceSubtaskPreachform>>() {
            });
        } catch (JsonProcessingException e) {
            log.error("ryTask--preachform转List<ServiceSubtaskPreachform>报错了，taskid={}，subid={}，preachformDesc={}",
                    serviceSubtask.getTaskid(), serviceSubtask.getId(), preachformDesc, e);
            return Collections.emptyList();
        }
        if (CollectionUtils.isEmpty(sspl)) {
            log.error("ryTask--preachformDesc解析后为空，taskid={}，subid={}，preachformDesc={}",
                    serviceSubtask.getTaskid(), serviceSubtask.getId(), preachformDesc);
            return Collections.emptyList();
        }

        List<ServiceSubtaskPreachform> inserted = new ArrayList<>();
        for (ServiceSubtaskPreachform serviceSubtaskPreachform : sspl) {
            if (serviceSubtaskPreachform == null) {
                continue;
            }
            if (StringUtils.isEmpty(serviceSubtaskPreachform.getPreachform())) {
                log.warn("ryTask--preachformDesc中存在空的preachform，跳过。taskid={}，subid={}",
                        serviceSubtask.getTaskid(), serviceSubtask.getId());
                continue;
            }
            serviceSubtaskPreachform.setTaskid(serviceSubtask.getTaskid());
            serviceSubtaskPreachform.setSubid(serviceSubtask.getId());
            //这个sendstate需要在数据库设置一个默认值为“1”
            serviceSubtaskPreachform.setSendstate(StringUtils.isNotEmpty(sendstate) ? sendstate : "1");
            serviceSubtaskPreachform.setOrgid(serviceSubtask.getOrgid());
            serviceSubtaskPreachformMapper.insertServiceSubtaskPreachform(serviceSubtaskPreachform);
            inserted.add(serviceSubtaskPreachform);
        }
        return inserted;
    }

    private Integer setFail(List<ServiceSubtaskPreachform> serviceSubtaskPreachforms, ServiceSubtask serviceSubtask) {
@@ -1777,6 +1956,25 @@
            log.info("【dealHisData】HIS结束采集数据");
        } catch (Exception e) {
            log.error("【dealHisData】HIS数据采集异常", e);
        }
    }

    /**
     * 采集丽水市妇幼保健院门诊接诊完成记录，并按配置生成妇科/儿科档案。
     * 定时任务默认采集昨天 00:00:00 ~ 今天 00:00:00。
     */
    public void collectMchArchive() {
        try {
            LocalDateTime todayZero = LocalDateTime.now().with(LocalTime.MIN);
            LocalDateTime yesterdayZero = todayZero.minusDays(1);
            Date startTime = Date.from(yesterdayZero.atZone(ZoneId.systemDefault()).toInstant());
            Date endTime = Date.from(todayZero.atZone(ZoneId.systemDefault()).toInstant());
            log.info("【collectMchArchive】开始采集丽水妇幼门诊接诊完成记录");
            ichService.collectMchOuthospAndGenerateArchive(
                    SpecificArchiveConstants.LISHUI_MCH_ORG_ID, startTime, endTime);
            log.info("【collectMchArchive】丽水妇幼门诊接诊完成记录采集结束");
        } catch (Exception e) {
            log.error("【collectMchArchive】丽水妇幼门诊接诊完成记录采集异常", e);
        }
    }

@@ -1823,7 +2021,7 @@

    public Boolean setSuccessPreachForm(ServiceSubtask serviceSubtask, String preachform, String remark, String failSendstate) {
        log.info("setSuccessPreachForm的入参为：serviceSubtask = {}，  preachform = {}，  remark = {}， failSendstate = {}", serviceSubtask, preachform, remark, failSendstate);
        if (preachform.equals("-1")) {
        if ("-1".equals(preachform)) {
            //说明都不需要执行了
            ServiceSubtaskPreachform serviceSubtaskPreachform = new ServiceSubtaskPreachform();
            serviceSubtaskPreachform.setSubid(serviceSubtask.getId());
@@ -1845,7 +2043,7 @@
        //1:未发送状态
        serviceSubtaskPreachform.setSendstate("1");
        //电话的未发送状态，需要查2，因为，数据可能卡在队列里了; （没进队列，电话状态还是1）
        if (preachform.equals("3") && StringUtils.isNotEmpty(failSendstate) && Long.valueOf(failSendstate) > 2)
        if ("3".equals(preachform) && NumberUtils.toInt(failSendstate, 0) > 2)
            serviceSubtaskPreachform.setSendstate("2");
//        //人工的未发送状态，需要查2
//        if (preachform.equals("1") && StringUtils.isNotEmpty(failSendstate) && Long.valueOf(failSendstate) > 2)
@@ -1855,16 +2053,18 @@
        if (CollectionUtils.isNotEmpty(serviceSubtaskPreachforms)) {
            ServiceSubtaskPreachform serviceSubtaskPreachform1 = serviceSubtaskPreachforms.get(0);
            serviceSubtaskPreachform1.setSendstate(failSendstate);
            if (serviceSubtask.getType().equals("3") || serviceSubtask.getType().equals("4")) {
            if ("3".equals(serviceSubtask.getType()) || "4".equals(serviceSubtask.getType())) {
                //如果是宣教或通知，并且发送成功，直接将发送状态改成9
                if (failSendstate.equals("2")) serviceSubtaskPreachform1.setSendstate("9");
                if ("2".equals(failSendstate)) serviceSubtaskPreachform1.setSendstate("9");
            }
            serviceSubtaskPreachform1.setRemark(remark);
            serviceSubtaskPreachformMapper.updateServiceSubtaskPreachform(serviceSubtaskPreachform1);
            log.info("---------serviceSubtaskPreachform1的入参是 :  {}", serviceSubtaskPreachform1);
            //如果当前的preachform已经是最后一个了，那直接将serviceSubtask的sendstate状态改成7就行了(全超时了)
            if (serviceSubtaskPreachform1.getSort() == sspCount.size() && isSubtaskDeadline(serviceSubtask, serviceSubtaskPreachforms)) {
                if (failSendstate.equals("4") || failSendstate.equals("5")) {
            if (serviceSubtaskPreachform1.getSort() != null
                    && serviceSubtaskPreachform1.getSort() == sspCount.size()
                    && isSubtaskDeadline(serviceSubtask, serviceSubtaskPreachforms)) {
                if ("4".equals(failSendstate) || "5".equals(failSendstate)) {
                    serviceSubtask.setCurrentPreachform(preachform);
                    serviceSubtask.setSendstate(7L);
                    log.error("setSuccessPreachForm方法，当前的preachform已经是最后一个了，全部执行失败");
@@ -1884,9 +2084,9 @@
        serviceSubtask.setCurrentPreachform(preachform);
        serviceSubtask.setSendstate(3L);

        if (serviceSubtask.getType().equals("3") || serviceSubtask.getType().equals("4")) {
        if ("3".equals(serviceSubtask.getType()) || "4".equals(serviceSubtask.getType())) {
            //如果是宣教或通知，并且发送成功，则直接将serviceSubtask状态改成6L（这个患者是没有题做的，不会再触发接口进行状态修改）
            if (failSendstate.equals("2")) {
            if ("2".equals(failSendstate)) {
                serviceSubtask.setSendstate(6L);
            }
        }
@@ -2013,25 +2213,69 @@
        if (Objects.isNull(serviceSubtask) || CollectionUtils.isEmpty(serviceSubtaskPreachforms)) {
            return false;
        }
        // 基准时刻：出院时间 + 发送日（sendDay 缺省按 1），并兜底避免 NPE/脏数据
        if (serviceSubtask.getEndtime() == null) {
            log.warn("【isSubtaskDeadline】subid：{} endtime为空，无法计算超时，按未超时处理", serviceSubtask.getId());
            return false;
        }
        ServiceTask serviceTask = serviceTaskMapper.selectServiceTaskByTaskid(serviceSubtask.getTaskid());
        int sendDay = serviceTask != null && serviceTask.getSendDay() != null ? serviceTask.getSendDay().intValue() : 1;
        Date deadline = DateUtils.addDays(serviceSubtask.getEndtime(), sendDay);
        int sumCompensateTime = CollectionUtils.isEmpty(serviceSubtaskPreachforms) ? 0 : serviceSubtaskPreachforms.stream()
        Date deadline;
        if (serviceTask != null && "5".equals(serviceTask.getAppltype())) {
            // 任务组：基准 = schedule_benchmark 解析出的时间 + day_offset，不叠加 send_day
            deadline = resolveTaskGroupDeadlineBase(serviceSubtask);
            if (deadline == null) {
                log.warn("【isSubtaskDeadline】subid：{} 任务组基准时间为空，无法计算超时，按未超时处理", serviceSubtask.getId());
                return false;
            }
        } else {
            // 非任务组：基准 = 出院时间 + 发送日（sendDay 缺省按 1）
            if (serviceSubtask.getEndtime() == null) {
                log.warn("【isSubtaskDeadline】subid：{} endtime为空，无法计算超时，按未超时处理", serviceSubtask.getId());
                return false;
            }
            int sendDay = serviceTask != null && serviceTask.getSendDay() != null ? serviceTask.getSendDay().intValue() : 1;
            deadline = DateUtils.addDays(serviceSubtask.getEndtime(), sendDay);
        }
        int sumCompensateTime = serviceSubtaskPreachforms.stream()
                .mapToInt(x -> NumberUtils.toInt(x.getCompensateTime(), 0))
                .sum();
        sumCompensateTime = sumCompensateTime + 1;
        // 只补偿最后一步自身的补偿时间（天），脏值一律按 0 兜底
        // 补偿时间脏值一律按 0 兜底，最后再加 1 天宽限
        deadline = DateUtils.addDays(deadline, sumCompensateTime);
        // 出院(发送)时间 + 本步补偿时间 小于当前时间 -> 超时
        return deadline.getTime() < new Date().getTime();
    }

    /**
     * 任务组基准时间：按 schedule_benchmark 解析后加 day_offset。
     * 0/其它-自定义时间 1-入院 2-出院 3-就诊 4-入组
     */
    private Date resolveTaskGroupDeadlineBase(ServiceSubtask serviceSubtask) {
        if (serviceSubtask.getScheduleId() == null || serviceSubtask.getScheduleDetailId() == null) {
            return null;
        }
        ServiceTaskSchedule schedule = serviceTaskScheduleMapper.selectServiceTaskScheduleById(serviceSubtask.getScheduleId());
        ServiceTaskScheduleDetail detail = serviceTaskScheduleDetailMapper.selectServiceTaskScheduleDetailById(serviceSubtask.getScheduleDetailId());
        if (schedule == null || detail == null || detail.getDayOffset() == null) {
            return null;
        }
        Date base;
        Integer benchmark = schedule.getScheduleBenchmark() == null ? 0 : schedule.getScheduleBenchmark();
        switch (benchmark) {
            case 1:
                base = serviceSubtask.getStarttime();
                break;
            case 2:
                base = serviceSubtask.getEndtime();
                break;
            case 3:
                base = serviceSubtask.getAdmindate();
                break;
            case 4:
                base = serviceSubtask.getCreateTime();
                break;
            default:
                base = schedule.getScheduleBenchmarkCustomTime();
                break;
        }
        return base == null ? null : DateUtils.addDays(base, detail.getDayOffset());
    }

    /**
     * 处理超时随访任务（随访超时 → 生成"再次随访"）
     * <p>
     * 扫描「出院满 deadlineDay 天仍未完成」的首次随访任务（sendstate=7 + visit_count=1），