【丽水】默认完成-下次补偿判断，上一次补偿方式是微信，状态是已领取，没选的填充默认选项，已完成

陈昶聿

9 天以前 bb5c9f74bcd20f299a514ad36ff47e6dd1dce7ae

【丽水】默认完成-下次补偿判断，上一次补偿方式是微信，状态是已领取，没选的填充默认选项，已完成

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

@@ -941,6 +941,25 @@
            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();
            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"));
                if (finishState) {

 smartor/src/main/java/com/smartor/mapper/ServiceSubtaskMapper.java

@@ -143,6 +143,14 @@

    public Boolean updateServiceSubtaskByCondition(ServiceSubtask ServiceSubtask);

    /**
     * 微信公众号已领取未填写按默认选项完成：只更新当前子任务，且只允许 sendstate=1、未提交的数据。
     *
     * @param serviceSubtask 必填 id、finishtime、result、remark
     * @return 影响行数
     */
    public int updateWechatDefaultComplete(ServiceSubtask serviceSubtask);

    public Boolean updateServiceSubtaskByTaskGuid(ServiceSubtask ServiceSubtask);

    /**

 smartor/src/main/java/com/smartor/mapper/ServiceSubtaskPreachformMapper.java

@@ -50,6 +50,15 @@
    public int updateSSPByCondition(ServiceSubtaskPreachform serviceSubtaskPreachform);

    /**
     * 微信公众号已领取未填写按默认选项完成时，将当前发送方式置为完成(9)。
     * 仅更新当前子任务、当前公众号行，且只允许从已发送(2)/已领取(3)迁移，避免影响其他任务。
     *
     * @param serviceSubtaskPreachform 必填 id、subid、preachform、remark
     * @return 影响行数
     */
    public int updateWechatPreachformComplete(ServiceSubtaskPreachform serviceSubtaskPreachform);

    /**
     * 删除【请填写功能名称】
     *
     * @param id 【请填写功能名称】主键

 smartor/src/main/java/com/smartor/service/IServiceSubtaskService.java

@@ -23,6 +23,12 @@
 */
public interface IServiceSubtaskService {
    /**
     * 丽水中医院 orgid。
     * 微信公众号已领取未填写按默认选项完成，暂时只对该机构生效，其他医院仍走原补偿逻辑。
     */
    String WECHAT_DEFAULT_COMPLETE_ORGID = "47231022633110211A2101";

    /**
     * 查询单一任务（随访）
     *
     * @param id 单一任务（随访）主键
@@ -241,6 +247,19 @@
     */
    public void setFailSubTaskDefalutVal(Long failDay);

    /**
     * 微信公众号已领取未填写：按题目默认选项补齐当前子任务，并将当前子任务完成。
     * <p>
     * 仅处理传入的当前子任务（subid），只允许：
     * 问卷类型(type=2)、当前发送方式为公众号(5)、子任务已领取(1)、未提交(submit!=1)、
     * 当前公众号发送方式为已发送(2)/已领取(3) 的数据。
     * 其他任务、其他发送方式、其他子任务均不受影响。
     *
     * @param serviceSubtask 当前子任务
     * @return true=已按默认选项完成；false=不满足条件或没有可填充的默认选项
     */
    public Boolean completeWechatClaimedByDefault(ServiceSubtask serviceSubtask);

    public Map<String, Object> getHeLibraryCount(@RequestBody HeLibraryCountVO heLibraryCountVO);

    public List<ServiceSubtask> gethelibraryCountHyperlink(@RequestBody HeLibraryCountVO heLibraryCountVO);

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

@@ -5926,6 +5926,184 @@
        }
    }

    /**
     * 微信公众号已领取未填写：按题目默认选项补齐当前子任务，并将当前子任务完成。
     * <p>
     * 所有查询、明细写入、状态更新都只使用当前 subid，避免影响其他任务/子任务。
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public Boolean completeWechatClaimedByDefault(ServiceSubtask serviceSubtask) {
        if (serviceSubtask == null || serviceSubtask.getId() == null) {
            return false;
        }

        // 重新读取当前子任务，所有判断只针对这一个 subid
        ServiceSubtask current = serviceSubtaskMapper.selectServiceSubtaskById(serviceSubtask.getId());
        if (current == null) {
            return false;
        }
        // 只处理：丽水中医院、问卷、当前方式公众号、已领取、未提交
        // 其他医院 orgid 不匹配时直接返回 false，继续走原补偿逻辑。
        if (!IServiceSubtaskService.WECHAT_DEFAULT_COMPLETE_ORGID.equals(current.getOrgid())
                || !"2".equals(current.getType())
                || !"5".equals(current.getCurrentPreachform())
                || !Long.valueOf(1L).equals(current.getSendstate())
                || Long.valueOf(1L).equals(current.getSubmit())) {
            return false;
        }

        // 查询当前子任务自己的公众号发送方式，必须是已发送(2)或已领取(3)
        ServiceSubtaskPreachform query = new ServiceSubtaskPreachform();
        query.setSubid(current.getId());
        query.setTaskid(current.getTaskid());
        query.setPreachform("5");
        List<ServiceSubtaskPreachform> preachforms = serviceSubtaskPreachformMapper.selectServiceSubtaskPreachformList(query);
        if (CollectionUtils.isEmpty(preachforms)) {
            return false;
        }
        ServiceSubtaskPreachform currentPreachform = preachforms.stream()
                .filter(item -> "2".equals(item.getSendstate()) || "3".equals(item.getSendstate()))
                .findFirst().orElse(null);
        if (currentPreachform == null) {
            return false;
        }

        // 只给当前 subid 补齐默认选项；至少有一题默认选项才继续
        int filled = fillWechatDefaultDetailForCurrentSubtask(current);
        if (filled <= 0) {
            log.info("【微信公众号默认完成】subid：{} 没有可填充的默认选项，跳过", current.getId());
            return false;
        }

        // 当前公众号发送方式：已发送/已领取 -> 完成(9)
        ServiceSubtaskPreachform updatePreachform = new ServiceSubtaskPreachform();
        updatePreachform.setId(currentPreachform.getId());
        updatePreachform.setSubid(current.getId());
        updatePreachform.setPreachform("5");
        updatePreachform.setOrgid(current.getOrgid());
        updatePreachform.setRemark("已领取未填写，按默认选项完成");
        int preachformUpdated = serviceSubtaskPreachformMapper.updateWechatPreachformComplete(updatePreachform);
        if (preachformUpdated == 0) {
            throw new BaseException("微信公众号默认完成失败：发送方式状态已变化，subid=" + current.getId());
        }

        // 当前子任务：已领取(1) -> 完成(6)，只更新这一个 subid
        ServiceSubtask complete = new ServiceSubtask();
        complete.setId(current.getId());
        complete.setOrgid(current.getOrgid());
        complete.setFinishtime(new Date());
        complete.setResult("success");
        complete.setRemark("已领取未填写，按默认选项完成");
        int subtaskUpdated = serviceSubtaskMapper.updateWechatDefaultComplete(complete);
        if (subtaskUpdated == 0) {
            throw new BaseException("微信公众号默认完成失败：子任务状态已变化，subid=" + current.getId());
        }

        log.info("【微信公众号默认完成】subid：{}，已按默认选项完成，填充题目数：{}", current.getId(), filled);
        return true;
    }

    /**
     * 仅给当前子任务补齐问卷单选/多选题中 default_value=2 的选项。
     * 已有非空答案的题目跳过，不覆盖患者已填写内容。
     *
     * @return 实际填充（或此前已由系统默认填充）的题目数
     */
    private int fillWechatDefaultDetailForCurrentSubtask(ServiceSubtask serviceSubtask) {
        Long templateId = serviceSubtask.getTemplateid();
        ServiceTask serviceTask = serviceTaskService.selectServiceTaskByTaskid(serviceSubtask.getTaskid());
        if (templateId == null && serviceTask != null) {
            templateId = serviceTask.getTemplateid();
        }
        if (templateId == null) {
            return 0;
        }

        SvyTaskTemplateScript scriptQuery = new SvyTaskTemplateScript();
        scriptQuery.setTemplateID(templateId);
        List<SvyTaskTemplateScript> scripts = svyTaskTemplateScriptService.selectSvyTaskTemplateScriptList(scriptQuery);
        if (CollectionUtils.isEmpty(scripts)) {
            return 0;
        }

        int filled = 0;
        for (SvyTaskTemplateScript script : scripts) {
            SvyTaskTemplateScriptVO scriptVO = DtoConversionUtils.sourceToTarget(script, SvyTaskTemplateScriptVO.class);
            SvyTaskTemplateScriptVO scriptWithOptions = svyTaskTemplateScriptService.selectInfoByCondition(scriptVO);
            if (scriptWithOptions == null
                    || scriptWithOptions.getId() == null
                    || CollectionUtils.isEmpty(scriptWithOptions.getSvyTaskTemplateTargetoptions())
                    || (!"1".equals(scriptWithOptions.getScriptType()) && !"2".equals(scriptWithOptions.getScriptType()))) {
                continue;
            }

            List<SvyTaskTemplateTargetoption> options = scriptWithOptions.getSvyTaskTemplateTargetoptions();
            List<SvyTaskTemplateTargetoption> defaultOptions = options.stream()
                    .filter(option -> option.getDefaultValue() != null && option.getDefaultValue() == 2L)
                    .filter(option -> StringUtils.isNotBlank(option.getOptioncontent()))
                    .collect(Collectors.toList());
            if (CollectionUtils.isEmpty(defaultOptions)) {
                continue;
            }

            // 已有非空答案则不覆盖，避免影响患者已填写内容
            ServiceSubtaskDetail detailQuery = new ServiceSubtaskDetail();
            detailQuery.setSubId(serviceSubtask.getId());
            detailQuery.setScriptid(scriptWithOptions.getId());
            List<ServiceSubtaskDetail> existingDetails = serviceSubtaskDetailMapper.selectServiceSubtaskDetailList(detailQuery);
            ServiceSubtaskDetail existing = CollectionUtils.isNotEmpty(existingDetails) ? existingDetails.get(0) : null;
            if (existing != null
                    && (StringUtils.isNotBlank(existing.getAsrtext()) || StringUtils.isNotBlank(existing.getMatchedtext()))) {
                // 之前已由系统默认填充过的，计入已填充，保证重试幂等
                if ("DEFAULT".equals(existing.getOperate())) {
                    filled++;
                }
                continue;
            }

            String targetValue = options.stream()
                    .map(SvyTaskTemplateTargetoption::getOptioncontent)
                    .filter(StringUtils::isNotBlank)
                    .collect(Collectors.joining("&"));
            String defaultValue = defaultOptions.stream()
                    .map(SvyTaskTemplateTargetoption::getOptioncontent)
                    .collect(Collectors.joining("&"));

            ServiceSubtaskDetail detail = new ServiceSubtaskDetail();
            detail.setSubId(serviceSubtask.getId());
            detail.setTaskid(serviceSubtask.getTaskid());
            detail.setPatid(serviceSubtask.getPatid());
            detail.setScriptid(scriptWithOptions.getId());
            detail.setTemplatequestionnum(scriptWithOptions.getId());
            detail.setQuestiontext(scriptWithOptions.getScriptContent());
            detail.setCategoryid(scriptWithOptions.getCategoryid());
            detail.setTargetid(scriptWithOptions.getTargetid() != null ? scriptWithOptions.getTargetid().intValue() : null);
            detail.setValueType(scriptWithOptions.getScriptType());
            detail.setTargetvalue(targetValue);
            detail.setAsrtext(defaultValue);
            detail.setMatchedtext(defaultValue);
            detail.setOperate("DEFAULT");
            detail.setTemplateType(2);
            detail.setLibTemplateid(serviceSubtask.getLibtemplateid() != null ? serviceSubtask.getLibtemplateid().intValue() : null);
            detail.setTemplateid(templateId.toString());
            detail.setGuid(scriptWithOptions.getGuid());
            detail.setOrgid(StringUtils.isNotEmpty(scriptWithOptions.getOrgid()) ? scriptWithOptions.getOrgid()
                    : (serviceTask != null ? serviceTask.getOrgid() : null));
            detail.setCreateTime(new Date());
            detail.setUpdateTime(new Date());

            if (existing != null) {
                detail.setId(existing.getId());
                serviceSubtaskDetailMapper.updateServiceSubtaskDetail(detail);
            } else {
                serviceSubtaskDetailMapper.insertServiceSubtaskDetail(detail);
            }
            filled++;
        }
        return filled;
    }

    @Override
    public Map<String, Object> getHeLibraryCount(@RequestBody HeLibraryCountVO heLibraryCountVO) {
        if (ObjectUtils.isEmpty(heLibraryCountVO)) {

 smartor/src/main/resources/mapper/smartor/ServiceSubtaskMapper.xml

@@ -1319,6 +1319,25 @@
        where id = #{id}
    </update>

    <!-- 微信公众号已领取未填写按默认选项完成：只更新当前子任务。
         条件 sendstate=1 + 未提交，保证只处理当前被领取且未填写的子任务，不波及其他任务。 -->
    <update id="updateWechatDefaultComplete" parameterType="com.smartor.domain.ServiceSubtask">
        update service_subtask
        set sendstate = 6,
            finishtime = #{finishtime},
            result = #{result},
            remark = case
                         when remark is null or remark = '' then #{remark}
                         else concat(remark, ',', #{remark})
                     end,
            update_time = now(),
            finish_state = <include refid="finishStateExpr"/>
        where id = #{id}
          and orgid = #{orgid}
          and sendstate = 1
          and (submit is null or submit != 1)
    </update>

    <update id="updateServiceSubtaskByPatId" parameterType="com.smartor.domain.ServiceSubtask">
        update service_subtask
        <trim prefix="SET" suffixOverrides=",">

 smartor/src/main/resources/mapper/smartor/ServiceSubtaskPreachformMapper.xml

@@ -263,6 +263,23 @@
            </if>
    </update>

    <!-- 微信公众号已领取未填写按默认选项完成：仅更新当前子任务的当前公众号行。
         只允许从已发送(2)/已领取(3)迁移到完成(9)，避免并发或重复补偿覆盖其他状态。 -->
    <update id="updateWechatPreachformComplete" parameterType="com.smartor.domain.ServiceSubtaskPreachform">
        update service_subtask_preachform
        set sendstate = '9',
            remark = case
                         when remark is null or remark = '' then #{remark}
                         else concat(remark, ',', #{remark})
                     end,
            update_time = now()
        where id = #{id}
          and subid = #{subid}
          and orgid = #{orgid}
          and preachform = #{preachform}
          and sendstate in ('2', '3')
    </update>


    <update id="deleteServiceSubtaskPreachformById" parameterType="Long">
        update service_subtask_preachform