AiDOPWarehouse/server/Plugins/Admin.NET.Plugin.AiDOP/Job/S0DimAutoRefreshJob.cs

using Admin.NET.Plugin.AiDOP.DataPlatform.S0Dim;
using Furion.Schedule;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;
using System.Text.Json;

namespace Admin.NET.Plugin.AiDOP.Job;

/// <summary>
/// S0 主数据标准层自动刷新：逐租户跑一轮全量 FULL REPLACE（source → mdp_stg_s0_* → dim_*/ref_*/bridge_*）。
///
/// <para><b>为什么必须有它</b>：在此之前 <c>S0DimRefreshService</c> 全仓唯一调用方是
/// <c>AdoS0DimRefreshController</c>，零 Cron、零 Job、零 Scheduler；
/// <c>mdp_transform_run_log</c> 156 条记录的 <c>trigger_type</c> 100% 是 <c>MANUAL</c>。
/// 后果是标准层的覆盖面完全取决于有没有人手工点过 ——
/// 实测 92 个「源有数据」的 (对象 × 租户) 组合里 <b>28 个目标表为 0 行</b>，
/// 默认租户 <c>1300000000001</c> 的 7 个对象**从未刷过一次**。
/// 消费者一旦迁到标准层，这些租户会直接看到空列表。</para>
///
/// <para><b>租户与维度都是动态枚举，不维护第二份清单</b>：见 <see cref="S0DimScopeCatalog"/>——
/// 租户取 <c>SysTenant.Status = Enable</c>（**含默认租户**，理由见该类注释），
/// 维度取 <see cref="S0DimCatalog.All"/> 减去 <c>mdp_entity.status != 1</c> 的已停用对象。</para>
///
/// <para><b>逐 (租户 × 维度) 组合调用</b>，而不是整租户一次 <c>key=null</c>：
/// ① <c>mdp_transform_run_log</c> 没有 <c>entity_key</c> 独立列，维度 key 只存在于
///    <c>summary_json</c> 里；一组合一行 run log 才能让 <c>summary_json-&gt;&gt;'$[0].Key'</c> 可查、可索引；
/// ② 单个维度失败不会把整租户的 run log status 拖成 FAILED；
/// ③ 与现状天然一致 —— 既有 156 条 run log 里 155 条本来就是单 key。</para>
///
/// <para><b>失败隔离</b>分两层，都已存在、本类只是不破坏它们：
/// ① 维度级 —— <c>S0DimMaterializer.RunAsync</c> 内部捕获异常并把该维度置 <c>FAILED</c>；
/// ② 组合级 —— 本类逐 (租户,维度) try/catch，一个组合炸掉不阻断其余组合。
/// 两层都不静默：维度级进 <c>mdp_transform_run_log.summary_json</c>，组合级进日志。</para>
///
/// <para><b>失败快照语义保持不变</b>：刷新失败 → 事务回滚 → 目标表停在上一轮完整快照，
/// **绝不清空**（见 <c>S0DimMaterializer</c> 的阶段 III 注释）。</para>
///
/// <para><b>无变化即跳过</b>：<c>S0DimMaterializer</c> 的写前校验和闸门会在 purge / pull / replace
/// 之前比对 source 与 dim 的 (count, checksum)，一致则该组合记
/// <c>SKIPPED_NO_CHANGE</c> 且不触碰任何数据。主数据变更频率低，小时级调度下**多数组合都会跳过**。
/// 汇总里 <c>skipped</c> 与 <c>ok</c> / <c>failed</c> 分开计 —— 跳过不是失败，也不是「刷过一轮」。</para>
///
/// <para><b>并发</b>：<c>Concurrent = false</c> 由 Furion 保证同一作业不并行；
/// 本类内部对 (租户 × 维度) 组合**严格串行**，不叠加任何并行度。
/// 这不是保守，是有实证约束的：<c>ISqlSugarClient</c> 是单例
/// （<c>SqlSugarSetup.cs:74</c>），而 dim 写入走显式事务
/// （<c>MdpStdFullReplace</c> 的 BeginTran/Commit），在同一 scope 上并行开事务是明确的踩雷点；
/// 且主库连接池上限只有 20。—— 单租户全量最慢约 90s
/// （<c>ITEM_BOM</c> 57199 行 27s + <c>ITEM</c> 21s + <c>ITEM_ROUTING_OP</c> 15s + 其余），
/// 全租户一轮约数分钟，远小于调度间隔，无需并行。
/// 并行反而会让多个租户同时对同一张目标表做 <c>DELETE ... WHERE tenant_id</c> + INSERT，
/// 徒增锁竞争。</para>
///
/// <para><b>频率</b>：默认每小时一次（错开整点，避开 <c>job_s5_t8_kpi_refresh</c> 的 :00）。
/// 该值只是**默认值** —— Furion 的 <c>[JobDetail]</c>/<c>[Cron]</c> 会自动持久化到
/// <c>sys_job_detail</c> / <c>sys_job_trigger</c>，运行期可在作业管理页直接改 Cron 表达式，
/// **无需改代码、无需发版**。故这里不再另建配置文件。
/// 主数据变更频率低，且写路径校验类消费者已判定继续直读源表（不依赖标准层的 read-after-write），
/// 小时级新鲜度对「看板筛选下拉」这类消费场景是够的。</para>
/// </summary>
[JobDetail("job_s0_dim_auto_refresh",
    Description = "S0 主数据标准层自动刷新（逐租户 FULL：source → mdp_stg_s0_* → dim_*/ref_*/bridge_*）",
    GroupName = "default",
    Concurrent = false)]
[Cron("15 * * * *",
    TriggerId = "trigger_s0_dim_auto_refresh",
    Description = "每小时第 15 分触发（5 字段：分 时 日 月 周）。错开整点以避开 S5/T8 作业。")]
public class S0DimAutoRefreshJob : IJob
{
    private readonly IServiceScopeFactory _scopeFactory;
    private readonly ILogger _logger;

    /// <summary>构造。</summary>
    public S0DimAutoRefreshJob(IServiceScopeFactory scopeFactory, ILoggerFactory loggerFactory)
    {
        _scopeFactory = scopeFactory;
        _logger = loggerFactory.CreateLogger(nameof(S0DimAutoRefreshJob));
    }

    /// <inheritdoc />
    public async Task ExecuteAsync(JobExecutingContext context, CancellationToken stoppingToken)
    {
        using var scope = _scopeFactory.CreateScope();
        var catalog = scope.ServiceProvider.GetRequiredService<S0DimScopeCatalog>();
        var refresh = scope.ServiceProvider.GetRequiredService<S0DimRefreshService>();

        var sc = await catalog.ResolveAsync(stoppingToken);
        if (sc.DisabledKeys.Count > 0)
            _logger.LogInformation("S0DimAutoRefreshJob 跳过已停用维度 {Keys}（mdp_entity.status != 1）",
                string.Join(",", sc.DisabledKeys));

        // skipped 必须与 ok / failed 分开计：
        // 它既不是失败（不能进 failed），也不是「刷过一轮」（混进 ok 会让
        // 「自动刷新是否真的在工作」不可观测 —— 全跳过与全刷新在日志里将无法区分）。
        int ok = 0, warned = 0, skipped = 0, failed = 0;

        foreach (var tenantId in sc.Tenants)
        {
            foreach (var def in sc.Definitions)
            {
                stoppingToken.ThrowIfCancellationRequested();
                try
                {
                    // triggerType=AUTO：与手工触发在 run log 里可区分，
                    // 便于回答「这次陈旧是没人点，还是自动刷挂了」。
                    var result = await refresh.RefreshAsync(
                        tenantId, key: def.Key, triggerType: "AUTO", ct: stoppingToken);

                    if (result.Status == S0DimMaterializeResult.StatusFailed) failed++;
                    else if (result.Status == S0DimMaterializeResult.StatusSkippedNoChange) skipped++;
                    else if (result.Status == "SUCCESS_WITH_WARNING") warned++;
                    else ok++;
                }
                catch (OperationCanceledException)
                {
                    // 应用停机 / 作业被取消：直接向上抛，让 Furion 记为取消，不吞。
                    throw;
                }
                catch (Exception ex)
                {
                    // 组合级隔离：一个 (租户,维度) 炸掉不阻断其余组合，但必须留痕。
                    failed++;
                    _logger.LogError(ex, "S0DimAutoRefreshJob 组合失败 tenant={Tenant} key={Key}",
                        tenantId, def.Key);
                }
            }
        }

        _logger.LogInformation("S0DimAutoRefreshJob 完成 {Payload}", JsonSerializer.Serialize(new
        {
            tenants = sc.Tenants.Count,
            definitions = sc.Definitions.Count,
            combinations = sc.Tenants.Count * sc.Definitions.Count,
            ok, warned, skipped, failed,
            skippedDisabled = sc.DisabledKeys.Count
        }));
    }
}