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

陈昶聿

15 小时以前 2d3b575ed96eee7ccd5b324baa3135d2236934ac

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

@@ -14,6 +14,7 @@
import com.ruoyi.common.enums.ServiceFromEnum;
import com.ruoyi.common.utils.*;
import com.ruoyi.common.utils.http.HttpUtils;
import com.ruoyi.common.utils.sms.SmsUtils;
import com.ruoyi.message.SendResult;
import com.ruoyi.message.sms.SmsSendRequest;
import com.ruoyi.message.sms.SmsSenderFactory;
@@ -32,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.*;
@@ -39,6 +41,7 @@
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.lang3.ObjectUtils;
import org.apache.commons.lang3.math.NumberUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
@@ -66,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;
@@ -164,6 +171,12 @@

    @Autowired
    private ServiceSubtaskMapper serviceSubtaskMapper;

    @Autowired
    private ServiceTaskScheduleMapper serviceTaskScheduleMapper;

    @Autowired
    private ServiceTaskScheduleDetailMapper serviceTaskScheduleDetailMapper;

    @Autowired
    private RedisCache redisCache;
@@ -1149,18 +1162,61 @@
            serviceSubtaskList.addAll(compensateServiceSubtaskList);
        }
        for (ServiceSubtask serviceSubtask : serviceSubtaskList) {
            //currentPreachform为空，说明该子任务还没有执行过任何一种发送方式(sendstate=1，属于首次补偿)，
            //这里直接交给sfHandlle处理，它会按sort=1的第一种发送方式发送，与getSendPreachform中的处理保持一致
            if (StringUtils.isEmpty(serviceSubtask.getCurrentPreachform())) {
                log.warn("【compensateTask】subid：{}，currentPreachform为空，按第一种发送方式补偿处理", serviceSubtask.getId());
                sfHandlle(serviceSubtask);
                continue;
            }
            //根据当前的执行方式，获取下一种执行方式
            ServiceSubtaskPreachform serviceSubtaskPreachform = new ServiceSubtaskPreachform();
            serviceSubtaskPreachform.setTaskid(serviceSubtask.getTaskid());
            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);
@@ -1176,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);
            }
        }
    }
@@ -1220,11 +1281,49 @@
    }

    /**
     * 随访-补偿处理
     * 按机构查询配置值（同一 key 在不同机构下可配置不同值）
     *
     * @param configKey 配置key
     * @param orgid     机构ID
     * @return 配置值，未配置返回 null
     */
    private String getConfigValue(String configKey, String orgid) {
        SysConfig query = new SysConfig();
        query.setConfigKey(configKey);
        query.setOrgid(orgid);
        List<SysConfig> sysConfigs = configService.selectConfigList(query);
        if (CollectionUtils.isNotEmpty(sysConfigs)) {
            return sysConfigs.get(0).getConfigValue();
        }
        return null;
    }

    /**
     * 随访-补偿处理。
     * <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());
@@ -1234,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());
@@ -1253,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」、以及本方法后面
@@ -1352,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())) {
@@ -1360,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);

@@ -1374,7 +1496,7 @@
                            sysConfig = sysConfigMapper.checkConfigKeyUnique("wj.sms.template");
                        }
                        log.info("sysConfig的值为：{}", sysConfig);
                        if (!Objects.isNull(sysConfig)) {
                        if (!Objects.isNull(sysConfig) && StringUtils.isNotEmpty(sysConfig.getConfigValue())) {
                            String smsContemt = sysConfig.getConfigValue();
//                            sendMagParam.setContent("您好，邀请您填写出院调查表，请点击" + sendMagParam.getUrl() + "填写。感谢您配合！");
                            sendMagParam.setContent(smsContemt.replace("${wjurl}", sendMagParam.getUrl()));
@@ -1394,7 +1516,7 @@
                            sendMagParam.setUrl(url);

                            SysConfig sysConfig = sysConfigMapper.checkConfigKeyUnique("xj.sms.template");
                            if (!Objects.isNull(sysConfig)) {
                            if (!Objects.isNull(sysConfig) && StringUtils.isNotEmpty(sysConfig.getConfigValue())) {
                                String smsContemt = sysConfig.getConfigValue();
//                              sendMagParam.setContent("您好，邀请您填写出院宣教调查表，请点击" + sendMagParam.getUrl() + "查看。感谢您配合！");
                                sendMagParam.setContent(smsContemt.replace("${xjurl}", sendMagParam.getUrl()));
@@ -1410,6 +1532,13 @@

                    }

                    //内容为空说明短信模板未配置或宣教/通知内容为空，直接按发送失败处理，避免后续发送时出现空指针
                    if (StringUtils.isEmpty(sendMagParam.getContent())) {
                        log.error("【sfHandlle】长期任务短信内容为空，无法发送，subid：{}，taskid：{}，type：{}，机构ID：{}", serviceSubtask.getId(), serviceSubtask.getTaskid(), serviceSubtask.getType(), serviceSubtask.getOrgid());
                        setSuccessPreachForm(serviceSubtask, sendPreachform, "长期任务短信发送失败:短信内容为空(短信模板未配置或内容为空), 时间: " + now, "5");
                        return;
                    }

                    serviceOutPath.setRadix(format);
                    serviceOutPath.setUpdateTime(new Date());
                    serviceOutPath.setUrl(url);
@@ -1417,9 +1546,24 @@
                    //短信发送：各站点对接方式差异较大（报文/签名/token/返回判定都不同），
                    //已收口到 ruoyi-message 模块，这里只负责组装入参并路由
                    log.info("active的值为：{}", active);
                    SendResult smsSendResult = sendSmsByActive(serviceSubtask, sendMagParam);
                    log.info("smsSendResult的值为：{}", smsSendResult);
                    String isSuccess = smsSendResult.asLegacyFlag();
                    String isSuccess = "";
                    if ("ls".equals(active) && "47226079133110211G1001".equals(serviceSubtask.getOrgid())) {
                        //丽水妇幼走中国移动云MAS，不依赖 ls.msg.info 与 token；
                        //ruoyi-message 的 ls 通道尚未覆盖云MAS，故此处保留 SmsUtils 直连
                        SmsUtils.YunMasConfig yunMasConfig = SmsUtils.YunMasConfig.of(getConfigValue("ls.msg.yunmas", serviceSubtask.getOrgid()));
                        SmsUtils.SmsResult yunMasSmsResult = SmsUtils.sendYunMasSms(yunMasConfig, sendMagParam.getPhone(), sendMagParam.getContent());
                        log.info("【sfHandlle】云MAS短信发送结果：ok={}，rspcod={}，msgGroup={}，message={}",
                                yunMasSmsResult.isOk(), yunMasSmsResult.getRspcod(), yunMasSmsResult.getMsgGroup(), yunMasSmsResult.getMessage());
                        isSuccess = yunMasSmsResult.isOk() ? "true" : "false";
                        if (!yunMasSmsResult.isOk()) {
                            log.error("【sfHandlle】云MAS短信发送失败，subid：{}，手机号：{}，原因：{}",
                                    serviceSubtask.getId(), sendMagParam.getPhone(), yunMasSmsResult.getMessage());
                        }
                    } else {
                        SendResult smsSendResult = sendSmsByActive(serviceSubtask, sendMagParam);
                        log.info("smsSendResult的值为：{}", smsSendResult);
                        isSuccess = smsSendResult.asLegacyFlag();
                    }
                    //任务发送记录
                    ServiceSubtaskRecord serviceSubtaskRecord = new ServiceSubtaskRecord();
                    serviceSubtaskRecord.setTaskid(serviceSubtask.getTaskid().toString());
@@ -1473,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);
@@ -1487,6 +1631,7 @@
                    //任务发送记录
                    ServiceSubtaskRecord serviceSubtaskRecord = new ServiceSubtaskRecord();
                    serviceSubtaskRecord.setTaskid(serviceSubtask.getTaskid().toString());
                    serviceSubtaskRecord.setSubtaskId(serviceSubtask.getId());
                    serviceSubtaskRecord.setUuid(UUID.randomUUID().toString());
                    serviceSubtaskRecord.setTasktype(serviceSubtask.getType());
                    serviceSubtaskRecord.setPreachform("4");
@@ -1514,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);
        }
    }

    /**
@@ -1614,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)) {
@@ -1626,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);
@@ -1660,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)) {
@@ -1670,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) {
@@ -1727,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);
        }
    }

@@ -1773,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());
@@ -1795,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)
@@ -1805,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已经是最后一个了，全部执行失败");
@@ -1834,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);
            }
        }
@@ -1854,14 +2104,15 @@
     * @return
     */
    private String getObject(ServiceSubtask serviceSubtask, String scriptContent) {
        //内容为空时直接返回，避免下面的replace出现空指针
        if (StringUtils.isEmpty(scriptContent)) {
            return scriptContent;
        }
        Map<String, Map<String, String>> param = getParam(serviceSubtask.getTaskid());
        for (Map<String, String> map : param.values()) {
            for (String key : map.keySet()) {
                scriptContent = scriptContent.replace(key, StringUtils.isNotEmpty(map.get(key)) ? map.get(key) : "");
            }
        }
        if (StringUtils.isEmpty(scriptContent)) {
            return scriptContent;
        }
        scriptContent = scriptContent.replace("${name}", StringUtils.isNotEmpty(serviceSubtask.getSendname()) ? serviceSubtask.getSendname() : "");
        scriptContent = scriptContent.replace("${dzz}", StringUtils.isNotEmpty(serviceSubtask.getAddr()) ? serviceSubtask.getAddr() : "");
@@ -1962,31 +2213,89 @@
        if (Objects.isNull(serviceSubtask) || CollectionUtils.isEmpty(serviceSubtaskPreachforms)) {
            return false;
        }
        // 基准时刻：出院时间 + 发送日（sendDay 缺省按 1），并兜底避免 NPE/脏数据
        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().mapToInt(x -> x.getCompensateTime() == null ? 0 : Integer.parseInt(x.getCompensateTime())).sum();
        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），
     * 按当前任务的 nexttaskid 生成再次随访任务，科室固定为随访中心科室。
     * <p>
     * 注意：截止时间必须在循环外计算一次。历史实现把 {@code deadlineDay = -deadlineDay}
     * 写在循环体内，每轮取反一次，导致偶数轮用「今天 + deadlineDay」做截止时间，
     * 把出院不满 28 天的超时任务也扫了进来。
     * <p>
     * ⚠️ 2025 修复（开关失效）：本方法原不判任何模块开关 ——
     * 关掉 {@code inhospvisit.enabled} 照样建"再次随访"子任务。
     * <p>
     * <b>为什么这里是"入口判开关"而不是像 {@link #dealOutHospInfo()} 那样切到门面</b>：
     * 模块侧只提供了 {@code InhospVisitApi#buildAgainVisitDraft}（组装草稿），
     * <b>没有</b>完整的"扫描超时 → 落库 → 回写原任务状态"入口，
     * 而本方法自己组装并 insert（见下方 {@code insertServiceSubtask}）。
     * 造一个模块入口属于新增能力、超出"只解决开关"的范围，所以取最小改动：入口守卫。
     * 超时扫描与回写原任务状态的入口由 service 侧承接（见下方 {@code addSubTaskAgainByDeadline}）。
     * <p>
     * ⚠️ 全仓只有 {@code ServiceSubtaskController#dealSubtaskDeadline} 一个调用者。
     *
     * @param orgid       机构ID
     * @param deadlineDay 出院满多少天算超时（正数，如 28）
     */
    public void dealSubtaskDeadline(String orgid, Integer deadlineDay) {
        // ⚠️ 开关守卫：先判再干活，与 dealOutHospInfo / rollTaskGroupCycle 同口径。
@@ -2002,9 +2311,17 @@
        st.setNexttaskflag("1");
        st.setOrgid(orgid);
        List<ServiceTask> serviceTasks = serviceTaskMapper.selectServiceTaskList(st);

        // 截止时间只算一次：出院时间 <= 今天 - deadlineDay
        int days = Math.abs(ObjectUtils.isEmpty(deadlineDay) ? 28 : deadlineDay);
        Date deadline = DateUtils.addDays(new Date(), -days);
        log.info("【dealSubtaskDeadline】开始扫描, orgid={}, day={}, deadline={}, 任务数={}",
                orgid, days, deadline, serviceTasks.size());

        for (ServiceTask serviceTask : serviceTasks) {
            deadlineDay = -deadlineDay;
            Date deadline = DateUtils.addDays(new Date(), deadlineDay);
            if (ObjectUtils.isEmpty(serviceTask.getNexttaskid())) {
                continue;
            }
            //通过任务ID拿到患者信息,并且随访时间得是今天之前的
            ServiceSubtaskEntity serviceSubtaskVO = new ServiceSubtaskEntity();
            serviceSubtaskVO.setOrgid(orgid);
@@ -2013,44 +2330,19 @@
            serviceSubtaskVO.setVisitCount(1);
            serviceSubtaskVO.setTaskid(serviceTask.getTaskid());
            serviceSubtaskVO.setEndOutHospTime(deadline);
            List<ServiceSubtask> serviceSubtaskList = serviceSubtaskMapper.selectServiceSubtaskList(serviceSubtaskVO);
            List<ServiceSubtask> serviceSubtaskList
                    = serviceSubtaskMapper.selectServiceSubtaskList(serviceSubtaskVO);
            log.info("【dealSubtaskDeadline】获取到{}个超时任务, taskid={}", serviceSubtaskList.size(), serviceTask.getTaskid());
            for (ServiceSubtask serviceSubtask : serviceSubtaskList) {
                PatMedInhosp patMedInhospVo = new PatMedInhosp();
                patMedInhospVo.setOrgid(serviceSubtask.getOrgid());
                patMedInhospVo.setInhospid(serviceSubtask.getInhospid());
                patMedInhospVo.setCry(1);
                List<PatMedInhosp> patMedInhospList = iPatMedInhospService.selectPatMedInhospList(patMedInhospVo);
                PatMedInhosp patMedInhosp = new PatMedInhosp();
                if (!patMedInhospList.isEmpty()) {
                    patMedInhosp = patMedInhospList.get(0);
                } else {
                    continue;
                }
                if (ObjectUtils.isEmpty(serviceTask.getNexttaskid())) {
                    continue;
                }
                ServiceTask nextServiceTask = serviceTaskMapper.selectServiceTaskByTaskid(serviceTask.getNexttaskid());
                PatArchive patArchive = patArchiveService.selectPatArchiveByPatid(serviceSubtask.getPatid());
                String config = configService.selectConfigByKey("visit.early.day");
                Integer type = 1;

                //新增再次随访任务
                ServiceSubtask serviceSubtaskAgain = iPatMedInhospService.boxedServiceSubtask(nextServiceTask, patMedInhosp, patArchive, config, type);
                serviceSubtaskAgain.setId(null);
                serviceSubtaskAgain.setUpid(serviceSubtask.getId().intValue());
                serviceSubtaskAgain.setVisitCount(serviceSubtask.getVisitCount() + 1);
                serviceSubtaskAgain.setSendstate(2L);
                serviceSubtaskAgain.setCreateTime(new Date());
                serviceSubtaskAgain.setUpdateTime(new Date());
                serviceSubtaskAgain.setVisitType(serviceSubtask.getVisitType());
                serviceSubtaskAgain.setVisitDeptCode(serviceSubtask.getVisitDeptCode());
                serviceSubtaskAgain.setVisitDeptName(serviceSubtask.getVisitDeptName());
                int i = serviceSubtaskMapper.insertServiceSubtask(serviceSubtaskAgain);
                if (i == 1) {
                    //再次随访任务创建成功后，原任务改为失败状态
                    serviceSubtask.setSendstate(5L);
                    serviceSubtaskMapper.updateServiceSubtask(serviceSubtask);
                try {
                    // 生成逻辑统一收口到 service：锁 + 幂等 + 事务 + 发送方式明细初始化
                    String result = iServiceSubtaskService.addSubTaskAgainByDeadline(serviceSubtask);
                    log.info("【dealSubtaskDeadline】生成再次随访, subId={}, taskid={}, 结果={}",
                            serviceSubtask.getId(), serviceTask.getTaskid(), result);
                } catch (Exception e) {
                    // 单条失败不影响其他患者
                    log.error("【dealSubtaskDeadline】生成再次随访失败, subId=" + serviceSubtask.getId()
                            + ", taskid=" + serviceTask.getTaskid(), e);
                }
            }
        }