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

using System.Data;
using System.Globalization;
using System.Text.Json;
using Admin.NET.Plugin.AiDOP.Entity.S8;
using Admin.NET.Plugin.AiDOP.Infrastructure.S8;
using Microsoft.Extensions.Logging;
using SqlSugar;

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

/// <summary>
/// R2 TIMEOUT 类规则 evaluator MVP。
/// params_json 约定（首版最小集合）：
///   { dueAtField, statusField, completedStates[], objectCodeField, objectIdField, graceMinutes, exceptionTypeCode }
/// 判定：dueAt &lt;= now - graceMinutes 且 status 不在 completedStates 内 → HIT。
/// 不做严重度阶梯、不做 SLA 升级、不做事件触发。
/// </summary>
public class S8TimeoutRuleEvaluator : IS8RuleEvaluator, ITransient
{
    public const string RuleTypeCode = "TIMEOUT";
    public string RuleType => RuleTypeCode;

    // S8-WATCH-EXPRESSION-COLUMN-CONTRACT-FIX-1：S8ConfigDraftService.BuildExpression 统一把结果列
    // 别名为以下 canonical 名（无论源表真实列名为何）。evaluator 优先按 canonical 读取，仅当结果集
    // 不含 canonical 列时才回退到 params_json 指定的真实列名（兼容历史未别名规则）。
    private const string CanonicalDueAtColumn = "due_at";
    private const string CanonicalStatusColumn = "status";
    private const string CanonicalSourceObjectIdColumn = "source_object_id";
    private const string CanonicalRelatedObjectCodeColumn = "related_object_code";

    private readonly SqlSugarRepository<AdoS8DataSource> _dataSourceRep;
    private readonly S8DataSourceRowLoader _rowLoader;
    private readonly ILogger<S8TimeoutRuleEvaluator> _logger;

    public S8TimeoutRuleEvaluator(
        SqlSugarRepository<AdoS8DataSource> dataSourceRep,
        S8DataSourceRowLoader rowLoader,
        ILogger<S8TimeoutRuleEvaluator> logger)
    {
        _dataSourceRep = dataSourceRep;
        _rowLoader = rowLoader;
        _logger = logger;
    }

    public async Task<List<S8RuleHit>> EvaluateAsync(
        long tenantId,
        long factoryId,
        AdoS8WatchRule rule,
        IReadOnlyList<AdoS8AlertRule> alertRules,
        CancellationToken cancellationToken = default)
    {
        var hits = new List<S8RuleHit>();

        // R5 evaluator 失败语义保护：所有"非命中判定"路径均改为抛出 S8RuleEvaluatorException，
        // 由 SchedulerService 标记 evaluate_failed 并跳过 recovery reconcile，避免对未确认未命中的 rule 误标 recovered_at。
        if (string.IsNullOrWhiteSpace(rule.Expression) || string.IsNullOrWhiteSpace(rule.ParamsJson))
            throw new S8RuleEvaluatorException("rule_not_configured", $"TIMEOUT 规则 {rule.RuleCode} 缺少 expression 或 params_json");

        S8TimeoutParams parameters;
        try { parameters = S8TimeoutParams.Parse(rule.ParamsJson!); }
        catch (Exception ex) { throw new S8RuleEvaluatorException("params_parse_failed", $"TIMEOUT 规则 {rule.RuleCode} params_json 解析失败：{ex.Message}", ex); }

        if (string.IsNullOrWhiteSpace(parameters.DueAtField)
            || string.IsNullOrWhiteSpace(parameters.StatusField)
            || string.IsNullOrWhiteSpace(parameters.ExceptionTypeCode))
            throw new S8RuleEvaluatorException("params_schema_invalid", $"TIMEOUT 规则 {rule.RuleCode} params 缺少必填字段 dueAtField/statusField/exceptionTypeCode");

        var dataSource = await _dataSourceRep.AsQueryable()
            .Where(x => x.Id == rule.DataSourceId
                        && x.TenantId == tenantId
                        && x.FactoryId == factoryId
                        && x.Enabled)
            .FirstAsync();
        if (dataSource == null
            || string.IsNullOrWhiteSpace(dataSource.Endpoint)
            || !S8DataSourceRowLoader.IsSupportedType(dataSource.Type))
            throw new S8RuleEvaluatorException("data_source_unavailable", $"TIMEOUT 规则 {rule.RuleCode} 数据源不可用（id={rule.DataSourceId}）");

        // S8-SQL-EVALUATOR-GUARD-P2-1：每次评估解析 timeout / maxRows（env 优先，回退代码默认）。
        var timeoutSeconds = S8EvaluatorGuard.ResolveCommandTimeoutSeconds(_logger);
        var maxRows = S8EvaluatorGuard.ResolveMaxRows(_logger);

        DataTable table;
        try
        {
            table = await _rowLoader.LoadAsync(
                dataSource,
                rule.Expression!,
                _dataSourceRep.Context.CurrentConnectionConfig.DbType,
                timeoutSeconds,
                cancellationToken);
        }
        catch (Exception ex)
        {
            throw new S8RuleEvaluatorException("query_failed", $"TIMEOUT 规则 {rule.RuleCode} 取数失败：{ex.Message}", ex);
        }

        // 超过安全上限 → result_too_many_rows（由既有 EVALUATE_FAILED 路径承接）。
        // 必须置于 try-catch 之外，避免被 query_failed 误捕获再包装。
        S8EvaluatorGuard.EnsureRowCountWithinLimit(table.Rows.Count, maxRows, RuleTypeCode, rule.RuleCode);

        var detectedAt = DateTime.Now;
        var threshold = detectedAt.AddMinutes(-parameters.GraceMinutes);
        var sourceObjectType = string.IsNullOrWhiteSpace(rule.SourceObjectType)
            ? rule.WatchObjectType
            : rule.SourceObjectType!;

        // 结果列名一次性解析（结果集列在整张 DataTable 内稳定）：canonical 优先，缺失回退 params 真实列名。
        var statusColumn = ResolveResultColumn(table, CanonicalStatusColumn, parameters.StatusField);
        var dueAtColumn = ResolveResultColumn(table, CanonicalDueAtColumn, parameters.DueAtField);
        var objectCodeColumn = ResolveResultColumn(table, CanonicalRelatedObjectCodeColumn, parameters.ObjectCodeField);
        var objectIdColumn = ResolveResultColumn(table, CanonicalSourceObjectIdColumn, parameters.ObjectIdField);

        foreach (DataRow row in table.Rows)
        {
            var status = ReadString(row, statusColumn) ?? string.Empty;
            if (parameters.CompletedStates.Contains(status, StringComparer.OrdinalIgnoreCase))
                continue;

            var due = ReadDateTime(row, dueAtColumn);
            if (due == null || due > threshold) continue;

            var relatedObjectCode = ReadString(row, objectCodeColumn) ?? string.Empty;
            if (string.IsNullOrWhiteSpace(relatedObjectCode)) continue;

            var sourceObjectId = ReadString(row, objectIdColumn) ?? relatedObjectCode;

            var dedupKey = BuildDedupKey(tenantId, factoryId, rule.RuleCode, sourceObjectType, sourceObjectId);

            hits.Add(new S8RuleHit
            {
                SourceRuleId = rule.Id,
                SourceRuleCode = rule.RuleCode,
                SourceObjectType = sourceObjectType,
                SourceObjectId = sourceObjectId,
                RelatedObjectCode = relatedObjectCode,
                ExceptionTypeCode = parameters.ExceptionTypeCode!,
                SceneCode = rule.SceneCode,
                Severity = S8SeverityCode.Normalize(rule.Severity),
                DedupKey = dedupKey,
                SourcePayload = BuildPayload(row, sourceObjectType, sourceObjectId, due.Value, status, parameters),
                DetectedAt = detectedAt,
                Title = $"[超时] {sourceObjectType} {sourceObjectId} 已超期至 {due.Value:yyyy-MM-dd HH:mm:ss}（状态 {status}）",
                DataSourceId = dataSource.Id,
                OccurrenceDeptId = ReadLong(row, "occurrence_dept_id"),
                ResponsibleDeptId = ReadLong(row, "responsible_dept_id")
            });
        }

        return hits;
    }

    /// <summary>构造 R2 dedup_key 稳定字符串：T{tenant}:F{factory}:R{ruleCode}:{sourceObjectType}:{sourceObjectId}。internal 暴露供测试。</summary>
    internal static string BuildDedupKey(long tenantId, long factoryId, string ruleCode, string sourceObjectType, string sourceObjectId) =>
        $"T{tenantId}:F{factoryId}:R{ruleCode}:{sourceObjectType}:{sourceObjectId}";

    private static string BuildPayload(DataRow row, string sourceObjectType, string sourceObjectId, DateTime dueAt, string status, S8TimeoutParams parameters)
    {
        var payload = new Dictionary<string, object?>(StringComparer.OrdinalIgnoreCase);
        foreach (DataColumn column in row.Table.Columns)
        {
            var value = row[column];
            payload[column.ColumnName] = value == DBNull.Value ? null : value;
        }
        payload["__ruleType"] = RuleTypeCode;
        payload["__sourceObjectType"] = sourceObjectType;
        payload["__sourceObjectId"] = sourceObjectId;
        payload["__dueAt"] = dueAt;
        payload["__status"] = status;
        payload["__graceMinutes"] = parameters.GraceMinutes;
        payload["__exceptionTypeCode"] = parameters.ExceptionTypeCode;
        return JsonSerializer.Serialize(payload);
    }

    /// <summary>
    /// 结果列名解析：BuildExpression 已把结果列统一别名为 canonical（due_at/status/source_object_id/
    /// related_object_code）。优先返回 canonical 列名；仅当结果集不含 canonical 列时，回退到 params_json
    /// 指定的真实列名（兼容历史未别名规则）。仅在 canonical 与 params 字段之间二选一，不新增无依据兜底字段。
    /// </summary>
    private static string ResolveResultColumn(DataTable table, string canonicalColumn, string? paramsColumn)
    {
        if (table.Columns.Contains(canonicalColumn)) return canonicalColumn;
        return string.IsNullOrWhiteSpace(paramsColumn) ? canonicalColumn : paramsColumn!;
    }

    private static string? ReadString(DataRow row, string columnName)
    {
        if (string.IsNullOrWhiteSpace(columnName)) return null;
        if (!row.Table.Columns.Contains(columnName)) return null;
        var v = row[columnName];
        return v == DBNull.Value ? null : Convert.ToString(v)?.Trim();
    }

    private static DateTime? ReadDateTime(DataRow row, string columnName)
    {
        if (!row.Table.Columns.Contains(columnName)) return null;
        var v = row[columnName];
        if (v == DBNull.Value) return null;
        if (v is DateTime dt) return dt;
        return DateTime.TryParse(Convert.ToString(v, CultureInfo.InvariantCulture), out var p) ? p : null;
    }

    private static long? ReadLong(DataRow row, string columnName)
    {
        if (!row.Table.Columns.Contains(columnName)) return null;
        var v = row[columnName];
        if (v == DBNull.Value) return null;
        return long.TryParse(Convert.ToString(v, CultureInfo.InvariantCulture), out var r) ? r : null;
    }

}