AiDOPWarehouse/server/Plugins/Admin.NET.Plugin.AiDOP/MaterialWarehouse/OutsourceIssueMdpSyncService.cs

using Admin.NET.Plugin.AiDOP.DataPlatform;
using Admin.NET.Plugin.AiDOP.DataPlatform.Executors;

namespace Admin.NET.Plugin.AiDOP.MaterialWarehouse;

/// <summary>
/// S5 委外发料单 数据中台只读同步转换服务（DOP 内部，head-detail 双 std 专表，独立于 S5MdpSyncTransformService 的 KPI 管线）。
///
/// B-① 迁通用管线：源(NbrMaster/NbrDetail, Type='CA') 经执行器灌 mdp_stg_outsource_issue_pull（头/明细共表，source_table 区分）
///   → transform 读 pull stg（MdpJsonSql 跨源类型兼容）→ mdp_std_outsource_issue(_detail)（typed，明细回填 std_head_id）。
///   维表 DepartmentMaster(d) 仍本库 LEFT JOIN（富化 department_name，业务 code 由事实表保留）。
///   注：canonical 执行器 stg 用 *_pull 命名（沿用 mdp_stg_ipqc_pull 惯例），与 legacy bespoke mdp_stg_outsource_issue(_detail) 区分；后者迁移后为死支路、不再消费、不动。
///
/// 双源：本库实体 S5_OUTSOURCE_ISSUE_MASTER/_DETAIL（AIDOPDEV_MYSQL, status=1）；
///   dopdemorq 第二源 S5_OUTSOURCE_ISSUE_MASTER_SQLSERVER/_DETAIL_SQLSERVER（DOPDEMORQ_SQLSERVER, status=0 就位不启用）。
///
/// 约束：
///   - 只读源/贴源，仅写 mdp_stg_outsource_issue_pull / mdp_std_outsource_issue(_detail)；绝不 INSERT/UPDATE/DELETE NbrMaster/NbrDetail。
///   - 过滤 NbrMaster.Type='CA' AND IsActive=1；NbrDetail.Type='CA'。
///   - status_desc 规则本批仅：Status='C' -> '关闭'，其他 -> ''。department_name 经 Domain+Department 关联 DepartmentMaster.Descr。
///   - 明细只转换已确认 9 列（ItemNum/ItemName/UM/QtyOrd/LocationFrom/LocationTo/Line/Status/Remark）；发料数量/已发数/批次号 3 候选列本批后置。
///   - tenant_id 从 raw_data 保留（本库源含该列 → std 租户不回归；SQL Server 源无此列 → 回落入站上下文 tenant）。
///   - CA 为 0 行时转换成功完成、处理数为 0，不报错。切源 FULL Replace 头/明细各一次单事务、仅按 tenant、Pull 成功后才 destructive。
/// </summary>
public class OutsourceIssueMdpSyncService : ITransient
{
    private const string JobCode = "S5_OUTSOURCE_ISSUE_MDP_SYNC";
    private const string InboundMasterEntityCode = "S5_OUTSOURCE_ISSUE_MASTER";
    private const string InboundDetailEntityCode = "S5_OUTSOURCE_ISSUE_DETAIL";

    private const string SqlServerSourceCode = "DOPDEMORQ_SQLSERVER";
    private const string SqlServerMasterEntityCode = "S5_OUTSOURCE_ISSUE_MASTER_SQLSERVER";
    private const string SqlServerDetailEntityCode = "S5_OUTSOURCE_ISSUE_DETAIL_SQLSERVER";

    private const string StdHeadTable = "mdp_std_outsource_issue";
    private const string StdDetailTable = "mdp_std_outsource_issue_detail";

    private readonly ISqlSugarClient _db;
    private readonly MdpSourcePullDispatcher _pullDispatcher;

    public OutsourceIssueMdpSyncService(ISqlSugarClient db, MdpSourcePullDispatcher pullDispatcher)
    {
        _db = db;
        _pullDispatcher = pullDispatcher;
    }

    /// <summary>全量：本地 DB 执行器灌 pull stg（头+明细） → 标准层头/明细（读 stg）。</summary>
    public async Task<OutsourceIssueMdpSyncResult> RunFullAsync(CancellationToken cancellationToken = default, string triggerType = "AUTO")
    {
        cancellationToken.ThrowIfCancellationRequested();
        await EnsureTablesAsync();
        await EnsureStgTableAsync();

        var now = DateTime.Now;
        var batchId = $"S5_OUTSRC_ISSUE_FULL_{now:yyyyMMddHHmmss}";
        var runLogId = await InsertRunLogAsync(batchId, now, triggerType);
        var result = new OutsourceIssueMdpSyncResult { BatchId = batchId, RunLogId = runLogId };

        try
        {
            var pullCtx = new MdpPullContext
            {
                TenantId = 0,
                FullRefresh = true,
                TaskCode = "S5_OUTSOURCE_ISSUE_INBOUND",
                BatchId = $"{batchId}_PULL"
            };
            var pull = await PopulateStgAsync(pullCtx, cancellationToken);
            result.HeadStageRows = pull.RowsWritten;
            result.DetailStageRows = 0;
            result.HeadStandardRows = await TransformHeadStandardAsync(batchId, now);
            result.DetailStandardRows = await TransformDetailStandardAsync(batchId, now);
            await MarkRunSuccessAsync(runLogId, now, result);
            return result;
        }
        catch (Exception ex)
        {
            await MarkRunFailedAsync(runLogId, now, ex.Message);
            throw;
        }
    }

    /// <summary>双模式入站：执行器抽主/明细 → pull stg，再跑 CA 标准层头/明细（读 stg）。</summary>
    public async Task<OutsourceIssueInboundResult> RunInboundAsync(
        long tenantId = 0,
        bool fullRefresh = false,
        CancellationToken cancellationToken = default)
    {
        cancellationToken.ThrowIfCancellationRequested();
        await EnsureTablesAsync();
        await EnsureStgTableAsync();

        var now = DateTime.Now;
        var pullCtx = new MdpPullContext
        {
            TenantId = tenantId,
            FullRefresh = fullRefresh,
            TaskCode = "S5_OUTSOURCE_ISSUE_INBOUND",
            BatchId = $"S5_OUTSRC_ISSUE_IN_{now:yyyyMMddHHmmss}"
        };
        var pull = await PopulateStgAsync(pullCtx, cancellationToken);

        var batchId = $"S5_OUTSRC_ISSUE_STD_{now:yyyyMMddHHmmss}";
        var runLogId = await InsertRunLogAsync(batchId, now, "INBOUND");
        var result = new OutsourceIssueMdpSyncResult { BatchId = batchId, RunLogId = runLogId };
        try
        {
            result.HeadStandardRows = await TransformHeadStandardAsync(batchId, now);
            result.DetailStandardRows = await TransformDetailStandardAsync(batchId, now);
            await MarkRunSuccessAsync(runLogId, now, result);
        }
        catch (Exception ex)
        {
            await MarkRunFailedAsync(runLogId, now, ex.Message);
            throw;
        }

        return new OutsourceIssueInboundResult
        {
            PullBatchId = pullCtx.BatchId,
            RowsPulled = pull.RowsPulled,
            RowsWrittenStg = pull.RowsWritten,
            NewCursor = pull.NewCursor,
            TransformBatchId = batchId,
            StdHeadRows = result.HeadStandardRows,
            StdDetailRows = result.DetailStandardRows
        };
    }

    /// <summary>
    /// 双源切换 FULL Replace：从指定 DB 源（默认 DOPDEMORQ_SQLSERVER）PullAll 全量灌 pull stg，
    /// 成功后头/明细各一次单事务 FULL 重建（按 tenant 精确隔离），消除旧源独有业务键残留。
    /// 顺序：先 head（写 std 头，供明细回填 std_head_id），再 detail。两次独立事务，Pull 成功后才 destructive。
    /// SQLSERVER 实体默认 status=0（就位不启用）；dopdemorq 六表当前空，Phase 1 不实际执行 destructive 切换。
    /// </summary>
    public async Task<OutsourceIssueInboundResult> RunSourceSwitchFullAsync(
        string sourceCode = SqlServerSourceCode,
        string masterEntityCode = SqlServerMasterEntityCode,
        string detailEntityCode = SqlServerDetailEntityCode,
        long tenantId = 0,
        CancellationToken cancellationToken = default)
    {
        cancellationToken.ThrowIfCancellationRequested();
        await EnsureTablesAsync();
        await EnsureStgTableAsync();

        var now = DateTime.Now;
        var pullCtx = new MdpPullContext
        {
            TenantId = tenantId,
            FullRefresh = true,
            TaskCode = "S5_OUTSOURCE_ISSUE_INBOUND",
            BatchId = $"S5_OUTSRC_ISSUE_SW_{now:yyyyMMddHHmmss}"
        };
        var master = await _pullDispatcher.PullAllByEntityCodeAsync(masterEntityCode, pullCtx, cancellationToken);
        var detail = await _pullDispatcher.PullAllByEntityCodeAsync(detailEntityCode, pullCtx, cancellationToken);

        var batchId = $"S5_OUTSRC_ISSUE_SWSTD_{now:yyyyMMddHHmmss}";
        var runLogId = await InsertRunLogAsync(batchId, now, "SOURCE_SWITCH");
        var result = new OutsourceIssueMdpSyncResult { BatchId = batchId, RunLogId = runLogId };
        try
        {
            result.HeadStandardRows = await MdpStdFullReplace.ReplaceAsync(
                _db, StdHeadTable, tenantId, extraWhere: null,
                insertScopedAsync: () => TransformHeadStandardAsync(batchId, now, sourceCode),
                cancellationToken);
            result.DetailStandardRows = await MdpStdFullReplace.ReplaceAsync(
                _db, StdDetailTable, tenantId, extraWhere: null,
                insertScopedAsync: () => TransformDetailStandardAsync(batchId, now, sourceCode),
                cancellationToken);
            await MarkRunSuccessAsync(runLogId, now, result);
        }
        catch (Exception ex)
        {
            await MarkRunFailedAsync(runLogId, now, ex.Message);
            throw;
        }

        return new OutsourceIssueInboundResult
        {
            PullBatchId = pullCtx.BatchId,
            RowsPulled = master.RowsPulled + detail.RowsPulled,
            RowsWrittenStg = master.RowsWritten + detail.RowsWritten,
            NewCursor = detail.NewCursor ?? master.NewCursor,
            TransformBatchId = batchId,
            StdHeadRows = result.HeadStandardRows,
            StdDetailRows = result.DetailStandardRows
        };
    }

    private async Task<(int RowsPulled, int RowsWritten, string? NewCursor)> PopulateStgAsync(
        MdpPullContext pullCtx, CancellationToken cancellationToken)
    {
        var master = await _pullDispatcher.PullByEntityCodeAsync(InboundMasterEntityCode, pullCtx, cancellationToken);
        var detail = await _pullDispatcher.PullByEntityCodeAsync(InboundDetailEntityCode, pullCtx, cancellationToken);
        return (
            master.RowsPulled + detail.RowsPulled,
            master.RowsWritten + detail.RowsWritten,
            detail.NewCursor ?? master.NewCursor);
    }

    private async Task EnsureStgTableAsync()
    {
        await _db.Ado.ExecuteCommandAsync(
            """
            CREATE TABLE IF NOT EXISTS mdp_stg_outsource_issue_pull (
                id BIGINT PRIMARY KEY AUTO_INCREMENT,
                tenant_id BIGINT NOT NULL,
                source_system VARCHAR(50) NULL,
                source_table VARCHAR(200),
                source_row_id VARCHAR(200),
                source_biz_key VARCHAR(300) NULL,
                raw_data JSON,
                sync_batch_id VARCHAR(100),
                sync_time DATETIME NULL DEFAULT CURRENT_TIMESTAMP,
                process_status VARCHAR(20) NOT NULL DEFAULT 'PENDING',
                process_message VARCHAR(500) NULL,
                create_time DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
                update_time DATETIME NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
                UNIQUE KEY uk_source_key (source_system, source_table, source_biz_key),
                KEY idx_batch (sync_batch_id),
                KEY idx_src (source_table, source_row_id),
                KEY idx_tenant (tenant_id)
            ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='S5委外发料执行器贴源层（头/明细共表，source_table 区分）'
            """);
    }

    /// <summary>防御式建表（与 UpdateScripts/1.0.206.sql 同构，幂等）。std 头/明细两专表。</summary>
    private async Task EnsureTablesAsync()
    {
        await _db.Ado.ExecuteCommandAsync(
            """
            CREATE TABLE IF NOT EXISTS mdp_std_outsource_issue (
                id BIGINT AUTO_INCREMENT PRIMARY KEY,
                tenant_id BIGINT NOT NULL DEFAULT 0,
                factory_id BIGINT NULL DEFAULT 1,
                source_system VARCHAR(50) NOT NULL DEFAULT 'AIDOP',
                bill_no VARCHAR(24) NOT NULL,
                issue_date DATETIME NULL,
                outsource_no VARCHAR(60) NULL,
                work_order VARCHAR(64) NULL,
                department_code VARCHAR(20) NULL,
                department_name VARCHAR(255) NULL,
                issuer VARCHAR(255) NULL,
                status VARCHAR(8) NULL,
                status_desc VARCHAR(20) NULL,
                remark VARCHAR(200) NULL,
                create_user VARCHAR(24) NULL,
                source_create_time DATETIME NULL,
                eff_date DATETIME NULL,
                source_biz_key VARCHAR(200) NULL,
                sync_batch_id VARCHAR(100) NOT NULL,
                sync_time DATETIME NOT NULL,
                update_time DATETIME DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
                UNIQUE KEY uk_mdp_std_outsrc_issue (tenant_id, bill_no),
                KEY idx_mdp_std_outsrc_issue_date (tenant_id, issue_date)
            ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci COMMENT='S5委外发料单头标准层'
            """);
        await _db.Ado.ExecuteCommandAsync(
            """
            CREATE TABLE IF NOT EXISTS mdp_std_outsource_issue_detail (
                id BIGINT AUTO_INCREMENT PRIMARY KEY,
                tenant_id BIGINT NOT NULL DEFAULT 0,
                std_head_id BIGINT NULL,
                bill_no VARCHAR(24) NOT NULL,
                line SMALLINT NOT NULL DEFAULT 0,
                item_num VARCHAR(24) NULL,
                item_name TEXT NULL,
                um VARCHAR(8) NULL,
                qty_ord DECIMAL(18,6) NULL DEFAULT 0,
                location_from VARCHAR(8) NULL,
                location_to VARCHAR(8) NULL,
                status VARCHAR(8) NULL,
                remark TEXT NULL,
                source_biz_key VARCHAR(200) NULL,
                sync_batch_id VARCHAR(100) NOT NULL,
                sync_time DATETIME NOT NULL,
                update_time DATETIME DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
                UNIQUE KEY uk_mdp_std_outsrc_issue_dtl (tenant_id, source_biz_key),
                KEY idx_mdp_std_outsrc_issue_dtl_head (std_head_id),
                KEY idx_mdp_std_outsrc_issue_dtl_bill (tenant_id, bill_no)
            ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci COMMENT='S5委外发料单明细标准层'
            """);
    }

    /// <summary>标准化头：pull stg(NbrMaster, CA) + DepartmentMaster(本库) → mdp_std_outsource_issue。返回处理头行数。</summary>
    private async Task<int> TransformHeadStandardAsync(string batchId, DateTime now, string? sourceSystem = null)
    {
        var srcClause = sourceSystem == null ? "" : " AND m.source_system=@Src";
        var mTenant = $"IFNULL({MdpJsonSql.Int("m", "tenant_id")}, IFNULL(m.tenant_id, 0))";
        var statusExpr = MdpJsonSql.Str("m", "Status");
        var headWhere =
            $"""
            m.source_table='NbrMaster'
              AND {MdpJsonSql.Str("m", "Type")}='CA'
              AND {MdpJsonSql.BoolTrue("m", "IsActive")}{srcClause}
            """;

        var countPars = new List<SugarParameter>();
        if (sourceSystem != null) countPars.Add(new SugarParameter("@Src", sourceSystem));
        var rows = await _db.Ado.GetIntAsync(
            $"SELECT COUNT(1) FROM mdp_stg_outsource_issue_pull m WHERE {headWhere}", countPars);

        var insertSql =
            $"""
            INSERT INTO mdp_std_outsource_issue
            (tenant_id, factory_id, source_system, bill_no, issue_date, outsource_no, work_order,
             department_code, department_name, issuer, status, status_desc, remark, create_user,
             source_create_time, eff_date, source_biz_key, sync_batch_id, sync_time)
            SELECT
                {mTenant}, 1, IFNULL(NULLIF(m.source_system,''), 'AIDOP'),
                {MdpJsonSql.Str("m", "Nbr")}, {MdpJsonSql.DateTimeSec("m", "Date")}, {MdpJsonSql.Str("m", "Address")}, {MdpJsonSql.Str("m", "WorkOrd")},
                {MdpJsonSql.Str("m", "Department")}, d.Descr, {MdpJsonSql.Str("m", "User1")}, {statusExpr},
                CASE WHEN {statusExpr}='C' THEN '关闭' ELSE '' END,
                {MdpJsonSql.Str("m", "Remark")}, {MdpJsonSql.Str("m", "CreateUser")}, {MdpJsonSql.DateTimeSec("m", "CreateTime")}, {MdpJsonSql.DateTimeSec("m", "EffDate")},
                {MdpJsonSql.Str("m", "Nbr")}, @BatchId, @Now
            FROM mdp_stg_outsource_issue_pull m
            LEFT JOIN DepartmentMaster d
              ON d.Domain = {MdpJsonSql.Str("m", "Domain")} AND d.Department = {MdpJsonSql.Str("m", "Department")}
            WHERE {headWhere}
            ON DUPLICATE KEY UPDATE
                issue_date=VALUES(issue_date), outsource_no=VALUES(outsource_no), work_order=VALUES(work_order),
                department_code=VALUES(department_code), department_name=VALUES(department_name), issuer=VALUES(issuer),
                status=VALUES(status), status_desc=VALUES(status_desc), remark=VALUES(remark), create_user=VALUES(create_user),
                source_create_time=VALUES(source_create_time), eff_date=VALUES(eff_date),
                sync_batch_id=VALUES(sync_batch_id), sync_time=VALUES(sync_time), update_time=CURRENT_TIMESTAMP
            """;
        var insPars = new List<SugarParameter> { new("@BatchId", batchId), new("@Now", now) };
        if (sourceSystem != null) insPars.Add(new SugarParameter("@Src", sourceSystem));
        await _db.Ado.ExecuteCommandAsync(insertSql, insPars);
        return rows;
    }

    /// <summary>标准化明细：pull stg(NbrDetail, CA) self-join stg(NbrMaster) by RecID↔NbrRecID → mdp_std_outsource_issue_detail（仅 9 列；回填 std_head_id）。</summary>
    private async Task<int> TransformDetailStandardAsync(string batchId, DateTime now, string? sourceSystem = null)
    {
        var srcClause = sourceSystem == null ? "" : " AND m.source_system=@Src AND d.source_system=@Src";
        var dTenant = $"IFNULL({MdpJsonSql.Int("d", "tenant_id")}, IFNULL(d.tenant_id, 0))";
        var fromJoinWhere =
            $"""
            FROM mdp_stg_outsource_issue_pull d
            JOIN mdp_stg_outsource_issue_pull m
              ON m.source_table='NbrMaster'
             AND {MdpJsonSql.Int("m", "RecID")} = {MdpJsonSql.Int("d", "NbrRecID")}
             AND {MdpJsonSql.Str("m", "Type")}='CA'
             AND {MdpJsonSql.BoolTrue("m", "IsActive")}
            LEFT JOIN mdp_std_outsource_issue h
              ON h.tenant_id = {dTenant} AND h.bill_no = {MdpJsonSql.Str("d", "Nbr")}
            WHERE d.source_table='NbrDetail' AND {MdpJsonSql.Str("d", "Type")}='CA'{srcClause}
            """;

        var countPars = new List<SugarParameter>();
        if (sourceSystem != null) countPars.Add(new SugarParameter("@Src", sourceSystem));
        var rows = await _db.Ado.GetIntAsync($"SELECT COUNT(1) {fromJoinWhere}", countPars);

        var insertSql =
            $"""
            INSERT INTO mdp_std_outsource_issue_detail
            (tenant_id, std_head_id, bill_no, line, item_num, item_name, um, qty_ord,
             location_from, location_to, status, remark, source_biz_key, sync_batch_id, sync_time)
            SELECT
                {dTenant}, h.id, {MdpJsonSql.Str("d", "Nbr")}, {MdpJsonSql.Int("d", "Line")}, {MdpJsonSql.Str("d", "ItemNum")}, {MdpJsonSql.Str("d", "ItemName")}, {MdpJsonSql.Str("d", "UM")}, {MdpJsonSql.Dec("d", "QtyOrd", 18, 6)},
                {MdpJsonSql.Str("d", "LocationFrom")}, {MdpJsonSql.Str("d", "LocationTo")}, {MdpJsonSql.Str("d", "Status")}, {MdpJsonSql.Str("d", "Remark")},
                CONCAT(IFNULL({MdpJsonSql.Str("d", "Nbr")},''), '#', IFNULL({MdpJsonSql.Int("d", "Line")},0)), @BatchId, @Now
            {fromJoinWhere}
            ON DUPLICATE KEY UPDATE
                std_head_id=VALUES(std_head_id), line=VALUES(line), item_num=VALUES(item_num), item_name=VALUES(item_name),
                um=VALUES(um), qty_ord=VALUES(qty_ord), location_from=VALUES(location_from), location_to=VALUES(location_to),
                status=VALUES(status), remark=VALUES(remark), sync_batch_id=VALUES(sync_batch_id), sync_time=VALUES(sync_time),
                update_time=CURRENT_TIMESTAMP
            """;
        var insPars = new List<SugarParameter> { new("@BatchId", batchId), new("@Now", now) };
        if (sourceSystem != null) insPars.Add(new SugarParameter("@Src", sourceSystem));
        await _db.Ado.ExecuteCommandAsync(insertSql, insPars);
        return rows;
    }

    private async Task<long> InsertRunLogAsync(string batchId, DateTime startedAt, string triggerType)
    {
        await _db.Ado.ExecuteCommandAsync(
            """
            INSERT INTO mdp_transform_run_log
            (tenant_id, job_code, job_name, trigger_type, batch_id, status, start_time)
            VALUES (0, @JobCode, 'S5委外发料单MDP同步与标准化转换', @TriggerType, @BatchId, 'RUNNING', @StartTime)
            """,
            new SugarParameter("@JobCode", JobCode),
            new SugarParameter("@TriggerType", NormalizeTriggerType(triggerType)),
            new SugarParameter("@BatchId", batchId),
            new SugarParameter("@StartTime", startedAt));
        return await _db.Ado.GetLongAsync(
            "SELECT id FROM mdp_transform_run_log WHERE batch_id=@BatchId ORDER BY id DESC LIMIT 1",
            new List<SugarParameter> { new("@BatchId", batchId) });
    }

    private async Task MarkRunSuccessAsync(long runLogId, DateTime startedAt, OutsourceIssueMdpSyncResult result)
    {
        var finishedAt = DateTime.Now;
        await _db.Ado.ExecuteCommandAsync(
            """
            UPDATE mdp_transform_run_log
            SET status='SUCCESS', end_time=@EndTime, duration_ms=@DurationMs,
                stage_rows=@StageRows, standard_rows=@StandardRows, dwd_rows=0, update_time=CURRENT_TIMESTAMP
            WHERE id=@Id
            """,
            new SugarParameter("@EndTime", finishedAt),
            new SugarParameter("@DurationMs", (int)(finishedAt - startedAt).TotalMilliseconds),
            new SugarParameter("@StageRows", result.HeadStageRows + result.DetailStageRows),
            new SugarParameter("@StandardRows", result.HeadStandardRows + result.DetailStandardRows),
            new SugarParameter("@Id", runLogId));
    }

    private async Task MarkRunFailedAsync(long runLogId, DateTime startedAt, string message)
    {
        var finishedAt = DateTime.Now;
        await _db.Ado.ExecuteCommandAsync(
            """
            UPDATE mdp_transform_run_log
            SET status='FAILED', end_time=@EndTime, duration_ms=@DurationMs,
                error_message=@ErrorMessage, update_time=CURRENT_TIMESTAMP
            WHERE id=@Id
            """,
            new SugarParameter("@EndTime", finishedAt),
            new SugarParameter("@DurationMs", (int)(finishedAt - startedAt).TotalMilliseconds),
            new SugarParameter("@ErrorMessage", message.Length > 2000 ? message[..2000] : message),
            new SugarParameter("@Id", runLogId));
    }

    private static string NormalizeTriggerType(string? triggerType)
        => string.IsNullOrWhiteSpace(triggerType) ? "AUTO" : triggerType.Trim().ToUpperInvariant();
}

/// <summary>委外发料单 MDP 同步转换结果。</summary>
public sealed class OutsourceIssueMdpSyncResult
{
    public long RunLogId { get; set; }
    public string BatchId { get; set; } = string.Empty;
    public int HeadStageRows { get; set; }
    public int DetailStageRows { get; set; }
    public int HeadStandardRows { get; set; }
    public int DetailStandardRows { get; set; }
}

/// <summary>S5 委外发料双模式入站结果。</summary>
public sealed class OutsourceIssueInboundResult
{
    public string PullBatchId { get; set; } = string.Empty;
    public int RowsPulled { get; set; }
    public int RowsWrittenStg { get; set; }
    public string? NewCursor { get; set; }
    public string TransformBatchId { get; set; } = string.Empty;
    public int StdHeadRows { get; set; }
    public int StdDetailRows { get; set; }
}