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

陈昶聿

11 小时以前 2d3b575ed96eee7ccd5b324baa3135d2236934ac

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

@@ -1175,9 +1175,24 @@
            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)
                // 且未填写时，按默认选项完成，避免进入下一种发送方式或最后一步超时。
@@ -1199,7 +1214,9 @@
                }

                //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);
@@ -1215,15 +1232,20 @@

                    serviceSubtaskMapper.updateServiceSubtask(serviceSubtask);
                    //修改发送方式的状态为失败
                    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);
            }
        }
    }
@@ -1277,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());
@@ -1291,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());
@@ -1310,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」、以及本方法后面
@@ -1417,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);

@@ -1597,6 +1662,46 @@
    }

    /**
     * 老数据兜底：子任务没有可用发送方式时，标记为超时并写清原因。
     * <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);
        }
    }

    /**
     * 按 {@code active}（站点）路由到对应的短信发送方。
     * <p>
     * 各站点差异见 {@code ruoyi-message} 模块各实现类；本方法只做「入参组装 + 路由 + 日志」。
@@ -1694,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)) {
@@ -1706,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);
@@ -1740,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)) {
@@ -1750,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();
        if (StringUtils.isEmpty(preachformDesc)) {
            log.error("ryTask--发送方式初始化失败，preachform_desc为空，taskid={}，subid={}",
                    serviceSubtask.getTaskid(), serviceSubtask.getId());
            return Collections.emptyList();
        }

        List<ServiceSubtaskPreachform> sspl = null;
        List<ServiceSubtaskPreachform> sspl;
        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());
            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("1");
                if (StringUtils.isNotEmpty(sendstate)) serviceSubtaskPreachform.setSendstate(sendstate);
            serviceSubtaskPreachform.setSendstate(StringUtils.isNotEmpty(sendstate) ? sendstate : "1");
                serviceSubtaskPreachform.setOrgid(serviceSubtask.getOrgid());
                serviceSubtaskPreachformMapper.insertServiceSubtaskPreachform(serviceSubtaskPreachform);
            inserted.add(serviceSubtaskPreachform);
            }

        }

        return sspl;
        return inserted;
    }

    private Integer setFail(List<ServiceSubtaskPreachform> serviceSubtaskPreachforms, ServiceSubtask serviceSubtask) {
@@ -1872,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());
@@ -1894,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)
@@ -1904,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已经是最后一个了，全部执行失败");
@@ -1933,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);
            }
        }