数据采集模块

liusheng

5 天以前 cc479e6a056785103996cc7ea67dbd5faa3e800e

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

@@ -25,7 +25,6 @@
import com.ruoyi.quartz.enums.MzGatherSlotEnum;
import com.ruoyi.quartz.enums.MzGatherStatusEnum;
import com.ruoyi.quartz.service.ICollectHISService;
import com.ruoyi.quartz.util.CreateDataTable;
import com.ruoyi.system.domain.SysConfig;
import com.ruoyi.system.mapper.SysConfigMapper;
import com.ruoyi.system.service.ISysConfigService;
@@ -34,8 +33,7 @@
import com.ruoyi.message.sms.provider.sltd.ws.MessageSend;
import com.smartor.common.QwenLLMUtil;
import com.smartor.domain.*;
import com.smartor.domain.VO.ServiceSubtaskDetailTraceVO;
import com.smartor.domain.entity.ServiceSubtaskEntity;
import com.ruoyi.task.domain.VO.ServiceSubtaskDetailTraceVO;
import com.smartor.mapper.*;
import com.smartor.service.*;
import lombok.extern.slf4j.Slf4j;
@@ -60,6 +58,24 @@
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;

import com.ruoyi.template.domain.HeLibrary;
import com.ruoyi.inhospvisit.domain.PatMedInhosp;
import com.ruoyi.template.api.TemplateFacade;
import com.ruoyi.common.core.domain.entity.PatArchive;
import com.ruoyi.task.domain.entity.ServiceSubtaskEntity;
import com.ruoyi.task.domain.ServiceSubtask;
import com.ruoyi.task.domain.ServiceSubtaskRecord;
import com.ruoyi.task.domain.ServiceTask;
import com.ruoyi.task.mapper.ServiceSubtaskMapper;
import com.ruoyi.task.mapper.ServiceTaskMapper;
import com.ruoyi.task.domain.ServiceSubtaskDetailTrace;
import com.ruoyi.task.domain.VO.ServiceSubtaskDetailTraceVO;
import com.ruoyi.task.service.IServiceSubtaskDetailTraceService;
import com.ruoyi.task.domain.ServiceOutPath;
import com.ruoyi.task.service.IServiceOutPathService;
import com.ruoyi.task.domain.ServiceSubtaskPreachform;
import com.ruoyi.task.service.IServiceSubtaskService;
import com.ruoyi.task.domain.SendMagParam;
/**
 * 定时任务调度测试
 *
@@ -71,6 +87,12 @@
    @Autowired
    private IServiceThirdDataService iServiceThirdDataService;

    /**
     * 模板数据一律经 ruoyi-template 的门面取用（跨模块数据访问原则）。
     */
    @Autowired
    private TemplateFacade templateFacade;

    @Autowired
    private IServiceOutPathService iServiceOutPathService;

@@ -80,11 +102,15 @@
    @Autowired
    private IPatMedInhospService iPatMedInhospService;

    /**
     * 手术随访模块的<b>常驻门面</b>（原注入 {@code IPatMedOperationService}）。
     * <p>
     * 手术随访编排已整体迁入 {@code ruoyi-othervisit}，本类只做调用。
     * ⚠️ 注入门面而不是模块内部实现：门面永远存在，模块未打进应用或
     * {@code othervisit.enabled=false} 时只是降级并打 WARN，不会启动失败。
     */
    @Autowired
    private IPatMedOuthospService iPatMedOuthospService;

    @Autowired
    private IPatMedOperationService iPatMedOperationService;
    private com.ruoyi.othervisit.api.OtherVisitFacade otherVisitFacade;

    @Autowired
    private IServiceSubtaskService iServiceSubtaskService;
@@ -92,17 +118,17 @@
    @Autowired
    private IServicePatientTempService iServicePatientTempService;

    @Autowired
    private IHNGatherPatArchiveService ihnGatherPatArchiveService;
    // ⚠️ 2026-10 移除：原 `IHNGatherPatArchiveService ihnGatherPatArchiveService` 字段。
    //    它在本类里**只**被 dealHisData 的河南分支使用（死字段检查：改前全文件仅 1 处使用），
    //    该分支已随方法体搬进 ruoyi-datacollection，故字段连带删除 ——
    //    留着它会让人误以为 smartor 的河南采集还有本类这个使用方
    //    （真正的使用方已是数据采集模块经契约 HisGatherApi 调用的 Bridge）。

    @Autowired
    private IServiceSLTDHealthcareRecordService serviceSLTDHealthcareRecordService;

    @Autowired
    private SysUserImportMapper sysUserImportMapper;

    @Autowired
    private HeLibraryMapper heLibraryMapper;

    @Autowired
    private ICollectHISService ichService;
@@ -115,7 +141,6 @@

    @Autowired
    private ISysUserService userService;


    @Value("${localIP}")
    private String localIP;
@@ -138,8 +163,9 @@
    @Autowired
    private IServiceSubtaskRecordService serviceSubtaskRecordService;

    @Autowired
    IIcd10Service iIcd10Service;
    // ⚠️ 2026-10 移除：原 `IIcd10Service iIcd10Service` 字段。
    //    它在本类里**只**被 dealHisData 的"疾病字典增量采集"一行调用，已随方法体搬进
    //    ruoyi-datacollection（经契约 HisGatherApi#gatherIcd10 调回 smartor 的实现）。

    @Autowired
    IPatArchiveService patArchiveService;
@@ -154,12 +180,6 @@
    IPatMedOuthospService patMedOuthospService;

    @Autowired
    ISvyTaskTemplateService svyTaskTemplateService;

    @Autowired
    IIvrTaskTemplateService iIvrTaskTemplateService;

    @Autowired
    IXHGatherPatArchiveService ixhGatherPatArchiveService;

    @Autowired
@@ -168,12 +188,70 @@
    @Autowired
    ICollectHISService icollectHis;

    /**
     * 门诊分表维护已整体迁入 {@code ruoyi-outpatientvisit}，这里只持有它的常驻门面。
     * <p>
     * ⚠️ 注入门面而不是内部实现：门面<b>永远存在</b>，即使模块没被打进应用本类也不会启动失败。
     */
    @Autowired
    CreateDataTable createDataTable;
    private com.ruoyi.outpatientvisit.api.OuthospVisitFacade outhospVisitFacade;

    /**
     * 出入院随访模块的<b>常驻门面</b>。
     * <p>
     * ⚠️ 2025 修复：本类的 <b>3 个随访入口原先不判开关</b> ——
     * 它们调用 {@code IPatMedInhospService}（smartor 里的遗留实现，见
     * {@code PatMedInhospServiceImpl}），而那个实现用门面<b>只是为了取数据</b>
     * （{@code selectPatMedInhospList} / {@code updatePatMedInhosp}），
     * <b>从不调用门面的编排方法</b>。于是 {@code inhospvisit.enabled} /
     * {@code publicity.enabled} / {@code othervisit.enabled} 对定时任务<b>完全失效</b>：
     * 门面的编排守卫（{@code InhospVisitFacade#dealOutHospInfo} 等）虽然有实现、
     * 有测试，却只有 HTTP 手动触发那一条路走得到。
     * <p>
     * 现在改为与手术随访（手术随访早已走 {@code otherVisitFacade}，见 {@link #dealOperationInfo()}）
     * 完全同形：定时任务走门面，开关在门面里统一判。模块实现内部会回调
     * {@code PublicityApi} / {@code OtherVisitApi}，那两处各自判自己的开关，
     * 所以一次切换让 3 个开关同时生效。
     * <p>
     * ⚠️ <b>不能注入 {@code InhospVisitApi} 接口</b>：容器里有两个实现
     * （本门面 + 内部实现 {@code DefaultInhospVisitApi}），按类型注入会歧义；
     * 而且只有门面才判开关。Quartz 依赖本模块、不存在反向依赖，所以直接注入门面是安全的。
     */
    @Autowired
    private com.ruoyi.inhospvisit.api.InhospVisitFacade inhospVisitFacade;

    @Value("${appid}")
    private String appid;
    /**
     * 宣教模块的<b>常驻门面</b>，用于判 {@code sys_config: publicity.enabled}。
     * <p>
     * ⚠️ 2025 修复：本类原本只在**生成**宣教时受开关管（走 inhospvisit 门面回调 PublicityApi），
     * 但**发送**宣教（{@link #sfHandlle} 的 {@code type == 3} 分支）从来不读宣教开关 ——
     * 所以关掉 {@code publicity.enabled} 后，已生成的宣教子任务照样通过
     * 短信/公众号/电话发出去。
     */
    @Autowired
    private com.ruoyi.publicity.api.PublicityFacade publicityFacade;

    /**
     * 数据采集模块的<b>常驻门面</b>。
     * <p>
     * ⚠️ 2026-10 模块化：本类的 {@code dealHisData(String)} 方法体（连同私有帮手
     * {@code collectSegmentData}）已整体搬进 {@code ruoyi-datacollection}，
     * 本类只保留定时任务入口（sys_job 的 invoke_target 是 {@code ryTask.dealHisData('...')}，
     * 入口名不能变）。站点分支、时间窗口、分段回溯、日志文案都在模块里，一行未改。
     * <p>
     * 注入门面而不是模块内部 Service：门面<b>永远存在</b>，且只有门面判
     * {@code sys_config: datacollection.enabled} 开关。
     */
    @Autowired
    private com.ruoyi.datacollection.api.DataCollectionFacade dataCollectionFacade;

    // ⚠️ 2026-10 删除：原 `@Value("${appid}") private String appid;`
    //    它是「新华微信公众号推送」的遗留字段（提交 8590ef6a 引入，只被
    //    xinHuaWXReq.setAppid(appid) 用过）。该推送逻辑已搬进 ruoyi-message
    //    （公众号凭据改由 sys_config.wx.mp.config.* 下发），本类里已无引用；
    //    但它的 @Value 没有默认值，而 application-nhfy.yml / -xh.yml / -ls.yml
    //    都没定义 appid 这个 key，这些 profile 启动时会直接报
    //    `Could not resolve placeholder 'appid'`。留着是定时炸弹，故删除。

    @Value("${server.port}")
    private String port;
@@ -195,8 +273,12 @@
    @Autowired
    private SysConfigMapper sysConfigMapper;

    @Autowired
    private IServiceTaskScheduleService serviceTaskScheduleService;
    // ⚠️ 2025 移除：原 `IServiceTaskScheduleService serviceTaskScheduleService` 字段。
    //    它在本类里**只**被 rollTaskGroupCycle() 用来调 rollCycleTasks()（死字段检查：
    //    改前全文件仅 1 处使用）。该调用已切到 inhospVisitFacade.rollTaskGroupCycle()，
    //    所以字段连带失效并删除 —— 留着它会让人误以为 smartor 的 rollCycleTasks 还有人用。
    //    smartor 侧的 ServiceTaskScheduleServiceImpl.rollCycleTasks() 本身**保留不删**
    //    （它可能仍被现网其它入口/接口调用，删除属另一件事）。

    public void ryMultipleParams(String s, Boolean b, Long l, Double d, Integer i) {
        System.out.println(StringUtils.format("执行多参方法： 字符串类型{}，布尔类型{}，长整型{}，浮点型{}，整形{}", s, b, l, d, i));
@@ -352,7 +434,6 @@
        }
    }


    /**
     * 定时处理外链的数据
     */
@@ -380,267 +461,57 @@
        dealHisData(formattedNow);
    }


    /**
     * HIS数据采集
     * 定时任务：采集患者信息、出院、门诊数据
     * todayZeroStr  当前的时间   例如：2026-05-06 00:00:00
     * <p>
     * ⚠️ <b>2026-10 模块化</b>：方法体（连同私有帮手 {@code collectSegmentData}）已整体搬进
     * {@code ruoyi-datacollection}，实现见
     * {@code com.ruoyi.datacollection.service.impl.HisDataCollectionServiceImpl}。
     * 这里只保留<b>定时任务入口</b>：sys_job 的 invoke_target 仍是
     * {@code ryTask.dealHisData('...')}，入口名不能变，所以本方法是<b>纯转发</b>。
     * <p>
     * 关闭数据采集模块（{@code sys_config: datacollection.enabled=false}）时门面会抛
     * {@link com.ruoyi.datacollection.api.DataCollectionModuleDisabledException}；
     * 本入口捕获后只打一条 WARN —— 那是"模块被主动关掉"，不是采集失败，
     * 不该让定时任务记成执行异常（否则运维会看到一片红色失败记录）。
     */
    public void dealHisData(String todayZeroStr) {
        log.info("【dealHisData】开始执行HIS数据采集任务");
        // 获取昨天0点到今天0点的时间范围
        LocalDateTime todayZero = LocalDateTime.now().with(LocalTime.MIN);
        if (StringUtils.isNotBlank(todayZeroStr)) {
            DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
            todayZero = LocalDateTime.parse(todayZeroStr, formatter);
        }
        LocalDateTime yesterdayZero = todayZero.minusDays(1);
        log.info("【dealHisData】采集时间范围：{} ~ {}", yesterdayZero, todayZero);

        if (active.trim().equals("xh")) {
            try {
                // 采集入院数据
                log.info("【dealHisData】新华开始采集入院数据");
                ixhGatherPatArchiveService.getInHospDataGather("0", yesterdayZero, todayZero);
                log.info("【dealHisData】新华入院数据采集完成");

                // 采集出院数据
                log.info("【dealHisData】新华开始采集出院数据");
                ixhGatherPatArchiveService.getInHospDataGather("1", yesterdayZero, todayZero);
                log.info("【dealHisData】新华出院数据采集完成");

            } catch (Exception e) {
                log.error("【dealHisData】新华数据采集异常", e);
            }
        } else if (active.trim().equals("hn")) {
            try {
                // 河南数据采集
                HnDataGatherVO hnDataGatherVO = new HnDataGatherVO();
                log.info("【dealHisData】河南开始采集数据");
                Date startTime = Date.from(yesterdayZero.atZone(ZoneId.systemDefault()).toInstant());
                Date endTime = Date.from(todayZero.atZone(ZoneId.systemDefault()).toInstant());

                hnDataGatherVO.setStartTime(startTime);
                hnDataGatherVO.setEndTime(endTime);
                ihnGatherPatArchiveService.hnDataGather(hnDataGatherVO);
                log.info("【dealHisData】河南结束采集数据");
            } catch (Exception e) {
                log.error("【dealHisData】河南数据采集异常", e);
            }
        } else if (active.trim().equals("sltd") || active.trim().equals("nhfy")) {
            //省立同德与华南附一用同一套采集方法（都是来未来提供）

            try {
                //获取是否需要采集用户、部门信息
                SysConfig config = new SysConfig();
                config.setConfigKey("sltd.gather.sysuser");
                config.setOrgid("20001001");
                List<SysConfig> sysConfigs = configService.selectConfigList(config);

                //获取省立同德要采集的院区
                SysConfig cf = new SysConfig();
                cf.setConfigKey("sltd.gather.campusid");
                cf.setOrgid("20001001");
                List<SysConfig> sysConfigcampusids = configService.selectConfigList(cf);

                List<Long> campusidList = new ArrayList<>();
                if (CollectionUtils.isNotEmpty(sysConfigcampusids)) {
                    String[] split = sysConfigcampusids.get(0).getConfigValue().split(",");
                    campusidList = Arrays.stream(split).map(Long::valueOf).collect(Collectors.toList());
                } else {
                    log.error("SysConfig中的院区ID为空！");
                    return;
                }

                //configValue = 1 不需要采集       configValue = 2需要采集
                if (CollectionUtils.isNotEmpty(sysConfigs) && sysConfigs.get(0).getConfigValue().equals("2")) {
                    log.info("【dealHisData】省立同德“部门信息”开始采集数据");
                    ServiceSLTDDeptReqVO serviceSLTDDeptReqVO = new ServiceSLTDDeptReqVO();
                    serviceSLTDDeptReqVO.setOrgId("20001001");
                    serviceSLTDDeptReqVO.setCampusIds(campusidList);
                    Boolean aBoolean1 = serviceSLTDHealthcareRecordService.queryDeptWardAreaInfoList(serviceSLTDDeptReqVO);
                    log.info("【dealHisData】省立同德“部门信息”结束采集数据：{}", aBoolean1);

                    Boolean aBoolean = false;
                    for (Long cid : campusidList) {
                        log.info("【dealHisData】省立同德“用户信息”开始采集数据，院区：{}", cid);
                        ServiceSLTDInhospReqVO reqVO = new ServiceSLTDInhospReqVO();
                        reqVO.setOrgId("20001001");
                        reqVO.setCampusId(cid);
                        ArrayList<String> statusList = new ArrayList<>();
                        statusList.add("1");
                        reqVO.setStatusList(statusList);
                        aBoolean = serviceSLTDHealthcareRecordService.queryHospUserInfoList(reqVO);
                    }
                    log.info("【dealHisData】省立同德“用户信息”结束采集数据：{}", aBoolean);
                    //疾病字典采集
                    iIcd10Service.queryAddIcd10();
                }

                // nhfy/sltd回溯30天分段采集判断（每段最多4天）
                boolean isBackfill = (active.trim().equals("nhfy") || active.trim().equals("sltd")) && StringUtils.isNotBlank(todayZeroStr);
                if (isBackfill) {
                    DateTimeFormatter dateFmt = DateTimeFormatter.ofPattern("yyyy-MM-dd");
                    LocalDate segStart = todayZero.toLocalDate().minusDays(30);
                    LocalDate segEndDate = todayZero.toLocalDate();
                    int segCount = 0;
                    while (!segStart.isAfter(segEndDate)) {
                        LocalDate segEnd = segStart.plusDays(3);
                        if (segEnd.isAfter(segEndDate)) {
                            segEnd = segEndDate;
                        }
                        segCount++;
                        log.info("【dealHisData】{}回溯第{}段采集，日期范围：{} ~ {}", active.trim(), segCount, segStart.format(dateFmt), segEnd.format(dateFmt));
                        for (Long cid : campusidList) {
                            collectSegmentData(cid, segStart.format(dateFmt), segEnd.format(dateFmt));
                        }
                        segStart = segEnd.plusDays(1);
                    }
                    log.info("【dealHisData】{}回溯采集完成，共{}段", active.trim(), segCount);
                }

                // 省立同德数据采集（非回溯模式才执行）
                if (!isBackfill) {
                    for (Long cid : campusidList) {
                        log.info("【dealHisData】省立同德预入院开始采集数据，院区：{}", cid);
                        String nowTime = LocalDate.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd"));
                        ServiceSLTDInhospReqVO serviceSLTDInhospReqVO = new ServiceSLTDInhospReqVO();
                        serviceSLTDInhospReqVO.setOrgId("20001001");
                        serviceSLTDInhospReqVO.setCampusId(cid);
                        serviceSLTDInhospReqVO.setEncounterTimeStart(nowTime);
                        serviceSLTDInhospReqVO.setEncounterTimeEnd(nowTime);
                        if (active.trim().equals("nhfy")) {
                            serviceSLTDInhospReqVO.setEncounterTimeStart(yesterdayZero.format(DateTimeFormatter.ofPattern("yyyy-MM-dd")));
                            serviceSLTDInhospReqVO.setEncounterTimeEnd(todayZero.format(DateTimeFormatter.ofPattern("yyyy-MM-dd")));
                        }
                        List<String> list = new ArrayList<>();
                        list.add("FH0109.22");
                        list.add("FH0109.23");
                        list.add("FH0109.53");
                        serviceSLTDInhospReqVO.setStatusList(list);
//                        log.info("【dealHisData】省立同德“预入院”采集数据入参：{}", serviceSLTDInhospReqVO);
                        serviceSLTDHealthcareRecordService.queryHealthcareRecordList(serviceSLTDInhospReqVO);
                        log.info("【dealHisData】省立同德“预入院”結束采集数据，院区：{}", cid);

                        log.info("【dealHisData】省立同德“入院”开始采集数据，院区：{}", cid);
                        serviceSLTDInhospReqVO.setOrgId("20001001");
                        serviceSLTDInhospReqVO.setCampusId(cid);
                        serviceSLTDInhospReqVO.setEncounterTimeStart(null);
                        serviceSLTDInhospReqVO.setEncounterTimeEnd(null);
                        serviceSLTDInhospReqVO.setStartHeadTime(nowTime);
                        serviceSLTDInhospReqVO.setStartTailTime(nowTime);
                        if (active.trim().equals("nhfy")) {
                            serviceSLTDInhospReqVO.setStartHeadTime(yesterdayZero.format(DateTimeFormatter.ofPattern("yyyy-MM-dd")));
                            serviceSLTDInhospReqVO.setStartTailTime(todayZero.format(DateTimeFormatter.ofPattern("yyyy-MM-dd")));
                        }
                        List<String> listStr = new ArrayList<>();
                        listStr.add("FH0109.24");
                        serviceSLTDInhospReqVO.setStatusList(listStr);
//                        log.info("【dealHisData】省立同德“入院”采集数据入参：{}", serviceSLTDInhospReqVO);
                        serviceSLTDHealthcareRecordService.queryHealthcareRecordList(serviceSLTDInhospReqVO);
                        log.info("【dealHisData】省立同德“入院”結束采集数据，院区：{}", cid);

                        log.info("【dealHisData】省立同德“出院”开始采集数据，院区：{}", cid);
                        serviceSLTDInhospReqVO.setStartHeadTime(null);
                        serviceSLTDInhospReqVO.setStartTailTime(null);
                        serviceSLTDInhospReqVO.setEncounterTimeStart(null);
                        serviceSLTDInhospReqVO.setEncounterTimeEnd(null);
                        serviceSLTDInhospReqVO.setPreOutHospitalHeadDate(nowTime);
                        serviceSLTDInhospReqVO.setPreOutHospitalTailDate(nowTime);
                        if (active.trim().equals("nhfy")) {
                            serviceSLTDInhospReqVO.setPreOutHospitalHeadDate(yesterdayZero.format(DateTimeFormatter.ofPattern("yyyy-MM-dd")));
                            serviceSLTDInhospReqVO.setPreOutHospitalTailDate(todayZero.format(DateTimeFormatter.ofPattern("yyyy-MM-dd")));
                        }
                        serviceSLTDInhospReqVO.setHealthcareRecordTypeList(null);
                        List<String> list2 = new ArrayList<>();
//                    list2.add("FH0108.02");
                        //出院
                        list2.add("FH0109.27");
                        //预出院
                        list2.add("FH0109.25");
                        serviceSLTDInhospReqVO.setStatusList(list2);
//                        log.info("【dealHisData】省立同德“出院”采集数据入参：{}", serviceSLTDInhospReqVO);
                        serviceSLTDHealthcareRecordService.queryHealthcareRecordList(serviceSLTDInhospReqVO);
                        log.info("【dealHisData】省立同德“出院”束采集数据，院区：{}", cid);
                    }
                }

            } catch (Exception e) {
                log.error("【dealHisData】省立同德数据采集异常", e);
            }
        try {
            dataCollectionFacade.dealHisData(todayZeroStr);
        } catch (com.ruoyi.datacollection.api.DataCollectionModuleDisabledException e) {
            log.warn("【dealHisData】{}（本轮定时采集跳过）", e.getMessage());
        }
    }

    /**
     * 分段采集数据（预入院、入院、出院）
     * 用于nhfy/sltd回溯采集，每次最多查询7天数据
     * 在院患者"科室 / 病区 / 床位"刷新（南华附一，每天一次）。
     * <p>
     * 在院患者会转科、转病区、换床，而 {@code pat_med_inhosp} 的位置字段只在入院时写过一次，
     * 之后不会自己更新 —— 这里每天按患者查一遍 HIS 里<b>该患者当前的在院信息</b>
     * （{@code dtcQueryHealthcareRecordList}，与入院采集是同一个接口，按
     * {@code healthcareRecordNo} 单查 + {@code statusList=["FH0109.24"]}），
     * 与库内比对后只把变化的字段写回去。实现与判定口径见
     * {@code com.ruoyi.datacollection.service.impl.InhospDeptRefreshServiceImpl}。
     * <p>
     * 与 {@link #dealHisData(String)} 同样的降级口径：模块被关掉（
     * {@code sys_config: datacollection.enabled=false}）时门面抛
     * {@link com.ruoyi.datacollection.api.DataCollectionModuleDisabledException}，
     * 这里只打一条 WARN —— 那是"模块被主动关掉"，不该记成定时任务执行异常。
     * <p>
     * sys_job 的 invoke_target 为 {@code ryTask.refreshInhospDeptInfo()}，
     * 建议每天 03:30（避开 01:00 入院采集与 02:00 出院处理），并发策略选"禁止并发"。
     *
     * @param cid          院区ID
     * @param startDateStr 日期开始 yyyy-MM-dd
     * @param endDateStr   日期结束 yyyy-MM-dd
     * @return 本次实际更新的在院记录条数（0 = 无变化 / 站点不匹配 / 模块被关闭）
     */
    private void collectSegmentData(Long cid, String startDateStr, String endDateStr) {
//        // 预入院
        log.info("【dealHisData】预入院开始采集数据，院区：{}，时间段：{} ~ {}", cid, startDateStr, endDateStr);
        ServiceSLTDInhospReqVO reqVO = new ServiceSLTDInhospReqVO();
        reqVO.setOrgId("20001001");
        reqVO.setCampusId(cid);
        reqVO.setEncounterTimeStart(startDateStr);
        reqVO.setEncounterTimeEnd(endDateStr);
        List<String> preAdmitStatus = new ArrayList<>();
        preAdmitStatus.add("FH0109.22");
        preAdmitStatus.add("FH0109.23");
        preAdmitStatus.add("FH0109.53");
        reqVO.setStatusList(preAdmitStatus);
        log.info("【dealHisData】预入院采集数据入参：{}", reqVO);
    public int refreshInhospDeptInfo() {
        try {
            serviceSLTDHealthcareRecordService.queryHealthcareRecordList(reqVO);
        } catch (Exception e) {
            // 单类数据失败不再向上抛：否则一段失败会让本次回溯后面的所有段都不执行
            log.error("【dealHisData】预入院采集失败，跳过该类继续。院区：{}，时间段：{} ~ {}", cid, startDateStr, endDateStr, e);
            return dataCollectionFacade.refreshInhospDeptInfo();
        } catch (com.ruoyi.datacollection.api.DataCollectionModuleDisabledException e) {
            log.warn("【refreshInhospDeptInfo】{}（本轮在院信息刷新跳过）", e.getMessage());
            return 0;
        }
        log.info("【dealHisData】预入院終了采集数据，院区：{}", cid);

        // 入院
        log.info("【dealHisData】入院开始采集数据，院区：{}，时间段：{} ~ {}", cid, startDateStr, endDateStr);
        reqVO = new ServiceSLTDInhospReqVO();
        reqVO.setOrgId("20001001");
        reqVO.setCampusId(cid);
        reqVO.setStartHeadTime(startDateStr);
        reqVO.setStartTailTime(endDateStr);
        List<String> admitStatus = new ArrayList<>();
        admitStatus.add("FH0109.24");
        reqVO.setStatusList(admitStatus);
        log.info("【dealHisData】入院采集数据入参：{}", reqVO);
        try {
            serviceSLTDHealthcareRecordService.queryHealthcareRecordList(reqVO);
        } catch (Exception e) {
            // 单类数据失败不再向上抛：否则一段失败会让本次回溯后面的所有段都不执行
            log.error("【dealHisData】入院采集失败，跳过该类继续。院区：{}，时间段：{} ~ {}", cid, startDateStr, endDateStr, e);
        }
        log.info("【dealHisData】入院終了采集数据，院区：{}", cid);

        // 出院
        log.info("【dealHisData】出院开始采集数据，院区：{}，时间段：{} ~ {}", cid, startDateStr, endDateStr);
        reqVO = new ServiceSLTDInhospReqVO();
        reqVO.setOrgId("20001001");
        reqVO.setCampusId(cid);
        reqVO.setPreOutHospitalHeadDate(startDateStr);
        reqVO.setPreOutHospitalTailDate(endDateStr);
        List<String> dischargeStatus = new ArrayList<>();
        //出院
        dischargeStatus.add("FH0109.27");
        //预出院
        dischargeStatus.add("FH0109.25");
        reqVO.setStatusList(dischargeStatus);
        log.info("【dealHisData】出院采集数据入参：{}", reqVO);
        try {
            serviceSLTDHealthcareRecordService.queryHealthcareRecordList(reqVO);
        } catch (Exception e) {
            // 单类数据失败不再向上抛：否则一段失败会让本次回溯后面的所有段都不执行
            log.error("【dealHisData】出院采集失败，跳过该类继续。院区：{}，时间段：{} ~ {}", cid, startDateStr, endDateStr, e);
        }
        log.info("【dealHisData】出院结束采集数据，院区：{}", cid);
    }

    /**
@@ -1072,7 +943,6 @@
        }
    }


    public void dealHisDataSLTD() {
        log.info("【dealHisData】开始执行HIS数据采集任务");

@@ -1130,27 +1000,50 @@

    /**
     * 处理患者信息，进入子任务表
     * <p>
     * ⚠️ 2025 修复（开关失效）：本方法原走 {@code iPatMedInhospService.dealOutHospInfo(config)}，
     * 那是 smartor 里的遗留实现，**不判任何模块开关** —— 于是：
     * <ul>
     *   <li>关 {@code inhospvisit.enabled} 照样生成出院/长期随访；</li>
     *   <li>关 {@code publicity.enabled} 照样发入院宣教与药品宣教；</li>
     *   <li>关 {@code othervisit.enabled} 照样生成手术随访。</li>
     * </ul>
     * 现改走模块门面：门面判 {@code inhospvisit.enabled}，模块实现内部再回调
     * {@code PublicityApi} / {@code OtherVisitApi}，三处各自判自己的开关。
     */
    public void dealOutHospInfo() {
        String config = configService.selectConfigByKey("visit.early.day");
        if (port.equals("8095")) {
            //出院表
            iPatMedInhospService.dealOutHospInfo(config);
            //出院表（含入院宣教 / 药品宣教 / 手术随访 —— 均由模块实现回调对应模块门面）
            inhospVisitFacade.dealOutHospInfo(config);
            //门诊表(新华的暂时不做门诊随访)
            if (!active.equals("xh")) {
                iPatMedOuthospService.dealOutpatientInfo();
                // 【门急诊模块化切换】门面内部判 sys_config: outpatientvisit.enabled（运行时热读），
                // 关闭时返回 0 并打 WARN。
                //
                // ⚠️ 2025 修复：这里原先是 iPatMedOuthospService.dealOutpatientInfo()，
                // 它经 IPatMedOuthospService → PatMedOuthospServiceDelegatingImpl
                // → OuthospDataFacade.dealOutpatientInfo()，而**那条路上没有开关守卫** ——
                // OuthospVisitFacade.dealOutpatientInfo() 才是带守卫的入口，却全仓零调用者。
                // 结果是 outpatientvisit.enabled=false 对定时任务**完全失效**。
                // 现在与下面 dealOperationInfo() 走 otherVisitFacade 的形状一致。
                outhospVisitFacade.dealOutpatientInfo();
            }
        }
    }

    /**
     * 处理患者信息，进入子任务表(任务组)
     * <p>
     * ⚠️ 2025 修复（开关失效）：原走 smartor 遗留实现，不判开关（同 {@link #dealOutHospInfo()}）。
     * 现走模块门面。注意模块侧的 {@code dealOutHospInfoBySchedule} 内部仍会转发回 smartor
     * （{@code OtherVisitApiBridge}，见该类注释），但<b>开关在门面这一层判</b>，所以关闭时不会走到那里。
     */
    public void dealOutHospInfoBySchedule() {
        String config = configService.selectConfigByKey("visit.early.day");
        if (port.equals("8095")) {
            //出院表
            iPatMedInhospService.dealOutHospInfoBySchedule(config);
            inhospVisitFacade.dealOutHospInfoBySchedule(config);
            //门诊表(新华的暂时不做门诊随访)
//            if (!active.equals("xh")) {
//                //iPatMedOuthospService.dealOutpatientInfo();
@@ -1158,12 +1051,13 @@
        }
    }


    /**
     * 处理手术信息，进入子任务表
     */
    public void dealOperationInfo() {
        if (port.equals("8095")) iPatMedOperationService.dealOperationInfo();
        // 【手术模块化切换】出口改为调用 ruoyi-othervisit 的常驻门面。
        // 门面内部判 sys_config: othervisit.enabled（运行时热读），关闭时返回 0 并打 WARN。
        if (port.equals("8095")) otherVisitFacade.dealOperationInfo();

    }

@@ -1177,7 +1071,10 @@
     */
    public void createOuthospQuarterTable() {
        log.info("【createOuthospQuarterTable】开始执行门诊分表任务");
        createDataTable.createOuthospQuarterTable();
        // 【门诊模块化】CreateDataTable 已整体迁入 ruoyi-outpatientvisit
        // （实现为 OuthospPartitionMaintainer，经 OuthospVisitFacade 暴露）。
        // 这里只做调用；建表逻辑一行未动。
        outhospVisitFacade.createOuthospQuarterTable();
    }

    /**
@@ -1190,7 +1087,6 @@
            List<ServicePatientTemp> servicePatientTemps = iServicePatientTempService.selectServicePatientTempList(new ServicePatientTemp());
        }
    }


    /**
     * 长期任务发送
@@ -1289,7 +1185,6 @@
        if (StringUtils.isNotEmpty(failDay)) iServiceSubtaskService.setFailSubTaskDefalutVal(Long.valueOf(failDay));
    }


    /**
     * 判断日期是否是今天
     *
@@ -1341,6 +1236,22 @@
        }

        String descByCode = ServiceFromEnum.getDescByCode(Integer.valueOf(sendPreachform));

        // ⚠️ 2025 修复（宣教开关失效）：type == 3 是**宣教/通知**（纯发送、无作答 ——
        // 见 setSuccessPreachForm 里「宣教或通知…直接改成 9」、以及本方法后面
        // 「宣教或通知，发送成功则直接改成 6L」的判定），整条派发的所有通道
        // （电话/短信/公众号/人工）发的都是宣教内容。关掉 publicity.enabled 时应**一个通道都不发**。
        //
        // ⚠️ 刻意**不推进 subtask 状态、也不记失败**（与 RedisMqReceiver 同口径）：
        // 关闭是"暂时不发"，不是"这个患者不需要宣教"。标成失败/不需要会让这条宣教
        // 在开关恢复后永远丢失。保持 sendstate 不动，开关打开后下一次 longTaskSend/compensateTask
        // 会照常把它捞出来发出。
        if ("3".equals(serviceSubtask.getType()) && !publicityFacade.isEnabled()) {
            log.warn("【宣教】模块未启用（参数配置 publicity.enabled=false），跳过宣教发送。subtaskId={}, patid={}",
                    serviceSubtask.getId(), serviceSubtask.getPatid());
            return;
        }

        if (descByCode.equals("电话")) {
            List<String> list = new ArrayList<>();
            ServiceTask ivrTask = serviceTaskMapper.selectServiceTaskByTaskid(serviceSubtask.getTaskid());
@@ -1450,7 +1361,13 @@
                            sendMagParam.setContent(smsContemt.replace("${wjurl}", sendMagParam.getUrl()));
                        }
                    } else {
                        HeLibrary heLibrary = heLibraryMapper.selectHeLibraryById(serviceSubtask.getLibtemplateid());
                        // ⚠️ 这里**刻意不**为 TemplateModuleDisabledException 做降级：
                        // 模板模块关闭（sys_config: template.enabled=false）时，宣教内容确实取不到，
                        // 短信也就确实发不出去。外层 try-catch 会如实记为"短信发送失败"，
                        // 并通过 setSuccessPreachForm(..., "5") 按既有机制升级到下一个通道（公众号/人工）。
                        // 若在这里硬记成"发送成功"，等于用一条假记录掩盖"没发出去"，
                        // 事后从任务记录上完全看不出问题 —— 那是更坏的降级。
                        HeLibrary heLibrary = templateFacade.findHeLibraryById(serviceSubtask.getLibtemplateid());
                        if (heLibrary.getHetype().equals("1")) {
                            sendMagParam.setPhone(serviceSubtask.getPhone());
                            url = StringUtils.isNotEmpty(req_path) ? localIP + ":" + req_path + "/xj?p=" + format : localIP + "/xj?p=" + format;
@@ -1643,7 +1560,6 @@
        SysDept sysDept = CollectionUtils.isNotEmpty(sysDepts) ? sysDepts.get(0) : new SysDept();
        return ObjectUtils.isNotEmpty(sysDept) ? sysDept.getCampusid() : "2";
    }


    private Date getNextVisitTime(Long subid, Long taskid, Date visitTime) {
        ServiceSubtaskPreachform serviceSubtaskPreachform = new ServiceSubtaskPreachform();
@@ -1970,7 +1886,9 @@
        }
        try {
            String config = configService.selectConfigByKey("visit.early.day");
            iPatMedInhospService.dealOutHospInfoBySchedule(config);
            // ⚠️ 2025 修复（开关失效）：原走 smartor 遗留实现，不判开关（同 dealOutHospInfo）。
            // 现走模块门面，与 RyTask#dealOutHospInfo 一致。
            inhospVisitFacade.dealOutHospInfoBySchedule(config);
            log.info("【dealTaskGroupOutHosp】任务组首轮纳入扫描完成");
        } catch (Exception e) {
            log.error("【dealTaskGroupOutHosp】任务组扫描异常", e);
@@ -1988,7 +1906,18 @@
    public void rollTaskGroupCycle() {
        log.info("【rollTaskGroupCycle】开始扫描循环任务组");
        try {
            int rolled = serviceTaskScheduleService.rollCycleTasks();
            // ⚠️ 2025 修复（开关失效）：原走 smartor 的 ServiceTaskScheduleServiceImpl.rollCycleTasks()，
            // 不判开关 —— 关掉 inhospvisit.enabled 照样「推进轮次 + 新建 subtask」。
            //
            // 现走模块门面，完成模块化方案里第 10 步一直没做的那一步切换：
            //   InhospVisitFacade#rollTaskGroupCycle（判开关）
            //     → DefaultInhospVisitApi#rollTaskGroupCycle
            //     → TaskGroupCycleRoller#rollCycleTasks（逐行搬自原 L170-190）
            //     → ScheduleRollPortBridge（smartor 侧端口实现，116 字段深拷贝等留在实现侧）
            // 该类的注释明确写了「第 10 步切过来之前不能被挂到任何调度上，否则双跑」——
            // 本行就是那个切换点，切完老的 rollCycleTasks 即退役（全仓只有本方法调它）。
            int rolled = inhospVisitFacade.rollTaskGroupCycle();
            // 门面内部的 TaskGroupCycleRoller 已打「本次推进 N 个计划」，这里只补一句总览
            log.info("【rollTaskGroupCycle】本次推进 {} 个计划", rolled);
        } catch (Exception e) {
            log.error("【rollTaskGroupCycle】滚动调度异常", e);
@@ -2027,10 +1956,26 @@
    }

    /**
     * 处理超时随访任务
     * @return
     * 处理超时随访任务（随访超时 → 生成"再次随访"）
     * <p>
     * ⚠️ 2025 修复（开关失效）：本方法原不判任何模块开关 ——
     * 关掉 {@code inhospvisit.enabled} 照样建"再次随访"子任务。
     * <p>
     * <b>为什么这里是"入口判开关"而不是像 {@link #dealOutHospInfo()} 那样切到门面</b>：
     * 模块侧只提供了 {@code InhospVisitApi#buildAgainVisitDraft}（组装草稿），
     * <b>没有</b>完整的"扫描超时 → 落库 → 回写原任务状态"入口，
     * 而本方法自己组装并 insert（见下方 {@code insertServiceSubtask}）。
     * 造一个模块入口属于新增能力、超出"只解决开关"的范围，所以取最小改动：入口守卫。
     * <p>
     * ⚠️ 全仓只有 {@code ServiceSubtaskController#dealSubtaskDeadline} 一个调用者。
     */
    public void dealSubtaskDeadline(String orgid, Integer deadlineDay){
        // ⚠️ 开关守卫：先判再干活，与 dealOutHospInfo / rollTaskGroupCycle 同口径。
        // 关闭时直接返回，不扫描、不建"再次随访"子任务。
        if (!inhospVisitFacade.isEnabled()) {
            log.warn("【dealSubtaskDeadline】模块未启用（参数配置 inhospvisit.enabled=false），跳过超时随访处理。orgid={}", orgid);
            return;
        }
        //获取任务信息
        ServiceTask st = new ServiceTask();
        st.setDelFlag("0");
@@ -2056,6 +2001,7 @@
                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()) {