AiDOPWarehouse/server/Plugins/Admin.NET.Plugin.AiDOP/Service/S8/S8WatchRuleService.cs

using System.Text.Json;
using Admin.NET.Plugin.AiDOP.Entity.S8;
using Admin.NET.Plugin.AiDOP.Infrastructure;
using Admin.NET.Plugin.AiDOP.Infrastructure.S8;
using Admin.NET.Plugin.AiDOP.Service.S8.Rules;
using Admin.NET.Plugin.AiDOP.Service.S8.Rules.DataAccess;
using Admin.NET.Plugin.AiDOP.Service.S8.Rules.Definitions;

namespace Admin.NET.Plugin.AiDOP.Service.S8;

public class S8WatchRuleService : ITransient
{
    private readonly SqlSugarRepository<AdoS8WatchRule> _rep;
    private readonly SqlSugarRepository<AdoS8SceneConfig> _sceneRep;
    private readonly IS8DatasetCatalog _datasetCatalog;
    private readonly S8DatasetEnableGate _datasetEnableGate;
    private readonly IS8RuleCatalog _ruleCatalog;

    public S8WatchRuleService(
        SqlSugarRepository<AdoS8WatchRule> rep,
        SqlSugarRepository<AdoS8SceneConfig> sceneRep,
        IS8DatasetCatalog datasetCatalog,
        S8DatasetEnableGate datasetEnableGate,
        IS8RuleCatalog ruleCatalog)
    {
        _rep = rep;
        _sceneRep = sceneRep;
        _datasetCatalog = datasetCatalog;
        _datasetEnableGate = datasetEnableGate;
        _ruleCatalog = ruleCatalog;
    }

    public async Task<List<AdoS8WatchRule>> ListAsync(long tenantId, long factoryId) =>
        await _rep.AsQueryable()
            .Where(x => x.TenantId == tenantId && x.FactoryId == factoryId)
            .ToListAsync();

    // S8-TENANT-FACTORY-P0-CLOSURE-1：归属一律由服务端可信作用域盖章，忽略 body.TenantId / body.FactoryId。
    //
    // S8-STANDARD-DATASET-HARD-CUTOVER-1：去掉 origin 形参与 S8RuleCreationPolicy。
    // 那套「按创建来源分治」的治理，存在意义是区分"调用方自带 SQL"与"服务端生成 SQL"；
    // 两者现在都不存在了 —— 规则唯一的取数配置是 dataset_code，由 ValidateAsync 强制。
    public async Task<AdoS8WatchRule> CreateAsync(AdoS8WatchRule body, S8TrustedScope scope)
    {
        body.TenantId = scope.TenantId;
        body.FactoryId = scope.FactoryId;
        await ValidateAsync(body, scope);
        // S8-STEP6E：新建一律走 canonical 词表 + params schema，杜绝「存得下但运行时永远不生效」。
        ValidateVocabularyForCreate(body);
        if (!string.IsNullOrWhiteSpace(body.ParamsJson))
            ValidateParamsJsonShape(body.ParamsJson!.Trim());
        body.Id = 0;
        body.CreatedAt = DateTime.Now;
        // S8-STEP6E（与 CFG_DATASRC D-3 / CFG_ROLES 同源缺陷）：回填自增主键。
        // 原 InsertAsync 只返回 bool，body.Id 保持 0，调用方随后 GET/PUT/DELETE 一律 404。
        body.Id = await _rep.AsInsertable(body).ExecuteReturnBigIdentityAsync();
        return body;
    }

    // ================================================================================
    // S8-STEP6E-CFG-WATCH-FIX-AND-SAFE-CERT-1：通用整实体 PUT 已退役。
    //
    // 原实现 `_rep.UpdateAsync(body)` 是**整列更新**，而 body 直接由客户端 JSON 绑定
    // （本实体即 DTO），服务端只重新盖章 5 个字段（Tenant/Factory/Id/CreatedAt/UpdatedAt）。
    // 实体与仓储层均无 UpdateIgnoreColumns / IsOnlyIgnoreUpdate 保护，因此调用方可写入
    // 全部 13 个 scheduler-owned 运行时列：
    //   lock_token / locked_by / lock_until / running_started_at /
    //   next_run_at / last_run_at / last_status / last_error / last_duration_ms / last_run_id /
    //   consecutive_failure_count / paused_until / pause_reason
    //
    // 后果（按 S8WatchSchedulerService 的租约语义）：
    //   · 写 lock_token/lock_until → 窃取或作废活跃租约，令运行中实例的回写静默失败
    //   · 清 lock → 第二实例重复拾取同一规则 → 重复建单
    //   · lock_until 设远未来 → 该规则永不再被 PickReadyRulesAsync 选中（静默 DoS）
    //   · paused_until 设远未来 → UI 仍显示「启用」但监控实际已停
    //   · 写 last_status/last_run_id/last_error → 伪造调度审计轨迹
    // 且**无需恶意**：部分字段的 PUT body 会让这 13 列静默变 NULL（HTTP 200、无报错）。
    //
    // 退役而非改白名单，是因为该入口没有正式消费方（已穷举：前端 s8ConfigApi.watchRules
    // 无 update；e2e 只用 GET/POST/DELETE；服务端唯一引用是本 controller），
    // 而正式配置修改已有 UpdateParamsAsync / UpdateScheduleAsync 等窄入口。
    //
    // ⚠️ 抛出发生在**任何 DB 访问之前**：不做 LoadScopedAsync、不做重复性查询。
    //    这既保证零 DB 触碰，也保证任意 id（含越权 id）一律 410 而非 404
    //    ——「这个能力没了」优先于「这条记录不属于你」，避免越权探测反推他租户数据是否存在。
    //
    // 保留方法签名是硬约束：S8TenantIsolationContractTests 用反射断言带 S8TrustedScope
    // 的写入口存在、且无 scope 的旧重载不存在。
    // ================================================================================
    public Task<AdoS8WatchRule> UpdateAsync(long id, AdoS8WatchRule body, S8TrustedScope scope) =>
        throw new S8WriteRetiredException(S8WriteRetiredException.WatchRuleUpdateMessage);

    // S8-TENANT-FACTORY-P0-CLOSURE-1：删除必须先按可信作用域绑行，禁止裸 DeleteByIdAsync(id)。
    public async Task DeleteAsync(long id, S8TrustedScope scope)
    {
        var e = await LoadScopedAsync(id, scope);
        await _rep.DeleteByIdAsync(e.Id);
    }

    /// <summary>按 Id + 可信作用域取行；不在作用域内一律按「不存在」处理，不泄露他租户资源是否存在。</summary>
    private async Task<AdoS8WatchRule> LoadScopedAsync(long id, S8TrustedScope scope) =>
        await _rep.AsQueryable()
            .Where(x => x.Id == id && x.TenantId == scope.TenantId && x.FactoryId == scope.FactoryId)
            .FirstAsync() ?? throw new S8NotFoundException();

    /// <summary>
    /// S8-RULE-GOVERNANCE-BATCH1：运行参数的**部分更新**。
    ///
    /// <para>与被它取代的 <c>UpdateParamsAsync</c> 的三处根本差异：</para>
    /// <list type="number">
    ///   <item><b>不再接受 params_json 原文</b>。判定语义（dueAtField / statusField /
    ///         completedStates / objectIdField / exceptionTypeCode）现在只存在于代码定义里，
    ///         没有任何 API 能改到它们；</item>
    ///   <item><b>不再承担启停</b>。enabled 走 <see cref="EnableAsync"/> / <see cref="DisableAsync"/>；</item>
    ///   <item><b>PATCH 而非整块覆盖</b>。未提供的字段保持原值 —— 这是 G1 的直接修复：
    ///         旧实现里一次 <c>{"enabled":false}</c> 就会把 params_json 抹成 NULL。</item>
    /// </list>
    ///
    /// <para>写入用 <c>UpdateColumns</c> 白名单，物理上无法触碰 Definition 投影列与 13 个调度运行态列。</para>
    /// </summary>
    public async Task<AdoS8WatchRule> UpdateParametersAsync(long id, S8RuleParametersPayload payload, S8TrustedScope scope)
    {
        // 前置拒绝：在任何 DB 访问之前判掉非法载荷，越权 id 也不会被用来探测记录是否存在。
        // 同一道守卫在 ApplyParameters 内再做一次 —— 那里才是所有调用方的必经之处。
        EnsureNoDefinitionFields(payload);

        var entity = await LoadScopedAsync(id, scope);
        var definition = _ruleCatalog.GetRequired(entity.RuleCode);

        var next = ApplyParameters(entity, payload, definition);

        await _rep.Context.Updateable<AdoS8WatchRule>()
            .SetColumns(x => new AdoS8WatchRule
            {
                PollIntervalSeconds = next.PollIntervalSeconds,
                TriggerCountRequired = next.TriggerCountRequired,
                RecoverCountRequired = next.RecoverCountRequired,
                Severity = next.Severity,
                ParamsJson = next.ToParamsJson(),
                UpdatedAt = DateTime.Now
            })
            .Where(x => x.Id == id && x.TenantId == scope.TenantId && x.FactoryId == scope.FactoryId)
            .ExecuteCommandAsync();

        return await LoadScopedAsync(id, scope);
    }

    /// <summary>
    /// 纯函数：把 PATCH 载荷叠加到「当前生效参数」上，并按 Definition 声明的取值域校验。
    ///
    /// <para>抽成 static 是为了让 G1 的核心不变量（未提供 = 不变）能在**不接数据库**的情况下被测试
    /// 逐字段断言。之前那条缺陷之所以能活到生产，正是因为它藏在一个必须有仓储才能跑的方法里。</para>
    /// </summary>
    internal static S8RuleRuntimeParameters ApplyParameters(
        AdoS8WatchRule entity, S8RuleParametersPayload payload, S8RuleDefinition definition)
    {
        EnsureNoDefinitionFields(payload);

        var current = S8RuleRuntimeParameters.Resolve(entity, definition);
        var policy = definition.Parameters ?? new S8RuleParameterPolicy();

        var poll = payload.PollIntervalSeconds ?? current.PollIntervalSeconds;
        var trigger = payload.TriggerCountRequired ?? current.TriggerCountRequired;
        var recover = payload.RecoverCountRequired ?? current.RecoverCountRequired;
        var grace = payload.GraceMinutes ?? current.GraceMinutes;
        var severity = payload.Severity?.Trim() ?? current.Severity;

        EnsureInRange("轮询间隔（秒）", poll, policy.PollIntervalSecondsMin, policy.PollIntervalSecondsMax);
        EnsureInRange("连续命中建单次数", trigger, policy.TriggerCountRequiredMin, policy.TriggerCountRequiredMax);
        EnsureInRange("连续未命中恢复次数", recover, policy.RecoverCountRequiredMin, policy.RecoverCountRequiredMax);
        EnsureInRange("宽限分钟", grace, policy.GraceMinutesMin, policy.GraceMinutesMax);

        if (!policy.AllowedSeverities.Contains(severity, StringComparer.Ordinal))
            throw new S8BizException(
                $"不支持的严重度：{severity}；当前规则仅支持 {string.Join(" / ", policy.AllowedSeverities)}");

        var occurrenceDept = payload.DefaultOccurrenceDeptId ?? current.DefaultOccurrenceDeptId;
        var responsibleDept = payload.DefaultResponsibleDeptId ?? current.DefaultResponsibleDeptId;
        if (!policy.AllowsDepartmentDefaults && (occurrenceDept.HasValue || responsibleDept.HasValue))
            throw new S8BizException("当前规则不支持配置部门兜底");

        return new S8RuleRuntimeParameters
        {
            PollIntervalSeconds = poll,
            TriggerCountRequired = trigger,
            RecoverCountRequired = recover,
            Severity = severity,
            GraceMinutes = grace,
            DefaultOccurrenceDeptId = occurrenceDept,
            DefaultResponsibleDeptId = responsibleDept
        };
    }

    /// <summary>
    /// 载荷里出现 Definition 字段（或已迁走的 enabled）一律**显式拒绝**。
    ///
    /// <para>静默忽略等于告诉调用方"改成功了"，而实际什么都没发生 —— 那比报错更危险，
    /// 因为调用方会据此认为规则已经按新口径运行。</para>
    ///
    /// <para>放在 <see cref="ApplyParameters"/> 内而不是只放在 API 层：
    /// 纯函数是所有写入路径的必经之处，守卫挂在这里才不会被下一个调用方绕过。</para>
    /// </summary>
    private static void EnsureNoDefinitionFields(S8RuleParametersPayload payload)
    {
        if (payload == null) throw new S8BizException("请求体不能为空");

        var rejected = payload.RejectedDefinitionFields;
        if (rejected.Count > 0)
            throw new S8BizException(
                "以下字段由代码定义，不能通过参数接口修改：" + string.Join(" / ", rejected)
                + "；启停请使用 /enable 与 /disable");
    }

    private static void EnsureInRange(string label, int value, int min, int max)
    {
        if (value < min || value > max)
            throw new S8BizException($"{label} 必须在 {min}–{max} 之间，当前值 {value}");
    }

    /// <summary>
    /// 启用规则。<b>只写 enabled 与调度触发时间，绝不触碰任何参数列或 Definition 投影列。</b>
    ///
    /// <para>幂等：已启用时直接返回，不产生写入 —— 重复调用不会重排下次执行时间，
    /// 也就不会被用来变相"插队"调度。</para>
    /// </summary>
    public async Task<AdoS8WatchRule> EnableAsync(long id, S8TrustedScope scope)
    {
        var entity = await LoadScopedAsync(id, scope);
        if (entity.Enabled) return entity;

        // ① 没有代码定义的规则不得启用。这是 Create API 仍然存在期间的安全过渡：
        //    业务即使造出一条任意 rule_code 的规则，也无法让调度器替它跑。
        var definition = _ruleCatalog.GetRequired(entity.RuleCode);

        // ② 数据集侧完整运行条件。按 Definition 的 dataset_code / rule_type 判定，
        //    而不是 DB 上那两列 —— 后者是投影，可能被人为改过。
        _datasetEnableGate.EnsureCanEnable(
            definition.DatasetCode, definition.RuleType, definition.RuleCode, scope.TenantId, scope.FactoryId);

        var now = DateTime.Now;
        await _rep.Context.Updateable<AdoS8WatchRule>()
            .SetColumns(x => new AdoS8WatchRule
            {
                Enabled = true,
                NextRunAt = now,
                UpdatedAt = now
            })
            .Where(x => x.Id == id && x.TenantId == scope.TenantId && x.FactoryId == scope.FactoryId)
            .ExecuteCommandAsync();

        return await LoadScopedAsync(id, scope);
    }

    /// <summary>
    /// 停用规则。<b>只写 enabled。</b>
    ///
    /// <para>幂等：已停用时直接返回。</para>
    /// <para>不动 lease / next_run_at：<c>PickReadyRulesAsync</c> 的候选谓词第一条就是
    /// <c>x.Enabled</c>，停用后自然不会再被拾取；正在执行中的那一轮由
    /// <c>ResetExpiredLeasesAsync</c> 按既有租约语义收尾。强行清租约反而会与正在跑的实例撕扯。</para>
    /// </summary>
    public async Task<AdoS8WatchRule> DisableAsync(long id, S8TrustedScope scope)
    {
        var entity = await LoadScopedAsync(id, scope);
        if (!entity.Enabled) return entity;

        // 停用**不过** Enable Gate：数据集出问题之后仍然必须能把规则关掉。
        await _rep.Context.Updateable<AdoS8WatchRule>()
            .SetColumns(x => new AdoS8WatchRule
            {
                Enabled = false,
                UpdatedAt = DateTime.Now
            })
            .Where(x => x.Id == id && x.TenantId == scope.TenantId && x.FactoryId == scope.FactoryId)
            .ExecuteCommandAsync();

        return await LoadScopedAsync(id, scope);
    }

    /// <summary>
    /// S8-STEP6E：WATCH 侧 canonical 词表，**严格取自真实 evaluator dispatch**
    /// （S8WatchSchedulerService.RunSingleRuleAsync 的 switch，ordinal 大小写敏感），
    /// 不是从 NOTIFY 词表套用过来的。
    /// 注意 rule_type 为空/空白是**合法的历史态**（调度器按 rule_type_empty_skipped 跳过、
    /// 不算失败），但**不允许新建**——新建一条永远不会被任何 evaluator 承载的规则没有产品意义。
    /// </summary>
    private static readonly string[] CanonicalRuleTypes =
    {
        S8TimeoutRuleEvaluator.RuleTypeCode,
        S8ShortageRuleEvaluator.RuleTypeCode,
        S8OutOfRangeRuleEvaluator.RuleTypeCode,
    };

    /// <summary>
    /// S8-STEP6E：新建时的 canonical 词表校验（rule_type / scene / severity）。
    ///
    /// 只作用于 Create：
    ///   · UpdateParamsAsync / UpdateScheduleAsync / Pause / Resume 都不修改这三个字段，无需重复校验；
    ///   · TestAsync 是对**既有行**的探针，若在此加严会让 legacy 无效行连自检都跑不了。
    /// 即「legacy 无效数据允许读取与停用，但禁止继续创建」。
    /// </summary>
    private static void ValidateVocabularyForCreate(AdoS8WatchRule body)
    {
        // rule_type：必须是真实存在 evaluator 的三类之一。
        if (string.IsNullOrWhiteSpace(body.RuleType)
            || Array.IndexOf(CanonicalRuleTypes, body.RuleType) < 0)
            throw new S8BizException(
                "不支持的规则类型：" + (string.IsNullOrWhiteSpace(body.RuleType) ? "(空)" : body.RuleType)
                + "；当前仅支持 " + string.Join(" / ", CanonicalRuleTypes));

        // scene：S8SceneCode 本身没有 IsValid，canonical 单模块场景判定复用 S8ModuleCode.IsValid
        //（仓内唯一「严格 S1–S7、拒 legacy 复合场景」的现成实现，不另造第二套）。
        if (!S8ModuleCode.IsValid(body.SceneCode))
            throw new S8BizException(
                "不支持的场景编码：" + body.SceneCode + "；当前仅支持 " + string.Join(" / ", S8ModuleCode.All));

        // severity：必须在 S8SeverityCode.Normalize **之前**校验。
        // Normalize 的兜底分支是 `_ => Follow`，放在之后会把 HIGH / 拼写错误静默降级成 FOLLOW，
        // 门禁永远命中不了——DB 中 severity='HIGH' 的那一行正是这样进来的。
        // 也刻意不复用 S8SeverityCode.IsValid：那是宽松六值版（含 LOW/MEDIUM/HIGH/CRITICAL），
        // 供 legacy 查询参数兼容用，拿来当写入门禁会直接放行 legacy 值。
        if (!string.Equals(body.Severity, S8SeverityCode.Follow, StringComparison.Ordinal)
            && !string.Equals(body.Severity, S8SeverityCode.Serious, StringComparison.Ordinal))
            throw new S8BizException(
                "不支持的严重度：" + body.Severity + "；当前仅支持 "
                + S8SeverityCode.Follow + " / " + S8SeverityCode.Serious);
    }

    /// <summary>
    /// S8-RULE-GOVERNANCE-BATCH1：params_json 的按类型 schema 校验已退役。
    ///
    /// <para>它校验的是 <c>dueAtField</c> / <c>statusField</c> / <c>exceptionTypeCode</c> 这些
    /// **A 类判定语义**是否齐备 —— 而这些字段现在只存在于代码定义里，params_json 根本不再承载它们。
    /// 继续校验等于要求调用方提交一份已经没有意义的 JSON。</para>
    ///
    /// <para>保留 JSON 合法性检查：脏文本存进去会让运行期解析失败，
    /// 虽然 <see cref="S8RuleRuntimeParameters.Resolve"/> 会回落默认值而不报错，
    /// 但让一份读不懂的文本静静躺在库里没有任何好处。</para>
    /// </summary>
    private static void ValidateParamsJsonShape(string paramsJson)
    {
        try { using (JsonDocument.Parse(paramsJson)) { } }
        catch (JsonException ex)
        {
            throw new S8BizException($"params_json 不是合法 JSON：{ex.Message}");
        }
    }

    public async Task<object> TestAsync(long id, S8TrustedScope scope)
    {
        var entity = await LoadScopedAsync(id, scope);
        await ValidateAsync(entity, scope, id);
        return new { id, success = true, message = "规则基础校验通过", pollIntervalSeconds = entity.PollIntervalSeconds };
    }

    // S8-SCHED-FRONTEND-1：远未来手工暂停哨兵值（与 SqlSugar DateTime 兼容；前端按 paused_until > now 判定）。
    private static readonly DateTime ManualPausedSentinel = new(9999, 12, 31, 23, 59, 59);

    /// <summary>
    /// S8-SCHED-FRONTEND-1：调度参数安全更新。仅修改 poll_interval_seconds / trigger_count_required /
    /// recover_count_required；不动 params_json / expression / rule_type / scene_code / data_source_id。
    /// </summary>
    public Task<AdoS8WatchRule> UpdateScheduleAsync(long id, S8WatchRuleSchedulePayload payload, S8TrustedScope scope) =>
        // S8-RULE-GOVERNANCE-BATCH1：三个调度字段已并入统一参数白名单，本入口只做形状转换后委托，
        // 不再各自维护一份取值域 —— 两处取值域一旦漂移，就会出现「A 接口存得下、B 接口存不下」。
        UpdateParametersAsync(id, new S8RuleParametersPayload
        {
            PollIntervalSeconds = payload?.PollIntervalSeconds,
            TriggerCountRequired = payload?.TriggerCountRequired,
            RecoverCountRequired = payload?.RecoverCountRequired
        }, scope);

    /// <summary>
    /// S8-SCHED-FRONTEND-1：立即执行一次。把 next_run_at 置为 NOW，让下个 tick 拾取。
    /// 不直接同步执行 evaluator；不阻塞请求；返回 200 + 提示。
    /// </summary>
    public async Task<object> RunNowAsync(long id, S8TrustedScope scope)
    {
        var entity = await LoadScopedAsync(id, scope);
        if (!entity.Enabled)
            throw new S8BizException("规则未启用，不能立即执行");
        var now = DateTime.Now;
        if (entity.PausedUntil.HasValue && entity.PausedUntil.Value > now)
            throw new S8BizException("规则已暂停，请先恢复");
        if (entity.LockUntil.HasValue && entity.LockUntil.Value > now)
            throw new S8BizException("规则正在执行中，请稍后再试");

        await _rep.Context.Updateable<AdoS8WatchRule>()
            .SetColumns(x => new AdoS8WatchRule
            {
                NextRunAt = now,
                UpdatedAt = now
            })
            .Where(x => x.Id == id && x.TenantId == scope.TenantId && x.FactoryId == scope.FactoryId)
            .ExecuteCommandAsync();
        return new { id, queued = true, message = "已排队，最长 1 分钟内执行" };
    }

    /// <summary>
    /// S8-SCHED-FRONTEND-1：手工暂停。paused_until = 9999-12-31 哨兵 + pause_reason=MANUAL_PAUSED。
    /// 不强杀正在执行的 lease；当前运行完成后下一轮自然不被拾取。
    /// 不清 last_status / last_error。
    /// </summary>
    public async Task<object> PauseAsync(long id, S8TrustedScope scope)
    {
        var entity = await LoadScopedAsync(id, scope);
        await _rep.Context.Updateable<AdoS8WatchRule>()
            .SetColumns(x => new AdoS8WatchRule
            {
                PausedUntil = ManualPausedSentinel,
                PauseReason = "MANUAL_PAUSED",
                UpdatedAt = DateTime.Now
            })
            .Where(x => x.Id == id && x.TenantId == scope.TenantId && x.FactoryId == scope.FactoryId)
            .ExecuteCommandAsync();
        return new { id, paused = true, message = "已暂停" };
    }

    /// <summary>
    /// S8-SCHED-FRONTEND-1：恢复。清 paused_until / pause_reason / last_error；归零 consecutive_failure_count；
    /// next_run_at = NOW 让下个 tick 立即拾取。不改 enabled / params_json / rule_type。
    /// </summary>
    public async Task<object> ResumeAsync(long id, S8TrustedScope scope)
    {
        var entity = await LoadScopedAsync(id, scope);
        var now = DateTime.Now;
        await _rep.Context.Updateable<AdoS8WatchRule>()
            .SetColumns(x => new AdoS8WatchRule
            {
                PausedUntil = null,
                PauseReason = null,
                ConsecutiveFailureCount = 0,
                LastError = null,
                NextRunAt = now,
                UpdatedAt = now
            })
            .Where(x => x.Id == id && x.TenantId == scope.TenantId && x.FactoryId == scope.FactoryId)
            .ExecuteCommandAsync();
        return new { id, resumed = true, message = "已恢复，并将在下一轮调度中执行" };
    }

    private async Task ValidateAsync(AdoS8WatchRule body, S8TrustedScope scope, long? id = null)
    {
        if (string.IsNullOrWhiteSpace(body.RuleCode) || string.IsNullOrWhiteSpace(body.SceneCode))
            throw new S8BizException("规则编码和场景编码必填");

        var exists = await _rep.AsQueryable()
            .AnyAsync(x => x.Id != (id ?? 0) && x.TenantId == body.TenantId && x.FactoryId == body.FactoryId && x.RuleCode == body.RuleCode);
        if (exists) throw new S8BizException("监视规则编码已存在");

        // 保存级校验（dataset_code 结构 + 目录归属，不要求 Provider 已上线）。
        S8WatchRuleDataAccessValidator.ValidateForSave(body, _datasetCatalog);

        // 只有真正要启用时才要求完整运行条件；草稿 / disabled 规则允许 Provider 未上线。
        // S8-RULE-GOVERNANCE-BATCH1：启用条件按**代码定义**判定，不按 body 上的投影列。
        if (body.Enabled)
        {
            var definition = _ruleCatalog.GetRequired(body.RuleCode);
            _datasetEnableGate.EnsureCanEnable(
                definition.DatasetCode, definition.RuleType, definition.RuleCode, scope.TenantId, scope.FactoryId);
        }

        var scene = await _sceneRep.GetFirstAsync(x => x.TenantId == body.TenantId && x.FactoryId == body.FactoryId && x.SceneCode == body.SceneCode)
            ?? throw new S8BizException("关联场景不存在");
        if (!scene.Enabled) throw new S8BizException("关联场景未启用");

        if (body.PollIntervalSeconds <= 0) throw new S8BizException("轮询间隔必须大于 0");
    }
}