AiDOPWarehouse/server/Plugins/Admin.NET.Plugin.AiDOP/Manufacturing/IpqcInspectionFlowService.cs

using System.Text.Json;
using Admin.NET.Plugin.AiDOP.Entity;
using Admin.NET.Plugin.AiDOP.Entity.DataPlatform;
using Admin.NET.Plugin.AiDOP.Manufacturing.Dto;
using Admin.NET.Plugin.ApprovalFlow;
using Admin.NET.Plugin.ApprovalFlow.Service;
using Microsoft.Extensions.Logging;
using Yitter.IdGenerator;

namespace Admin.NET.Plugin.AiDOP.Manufacturing;

/// <summary>
/// S6 过程检验单（IPQC）检验员+主管流程服务（v2：含整批判定驱动的质量处置分流）。
///
/// N1_INSPECT 检验员录入 → 提交 → N2_SUP_REVIEW 主管整批审核：
///   整批合格(Qualified=true) → GW_RESULT(disposition_required=0) → end；
///   整批不合格(Qualified=false) → GW_RESULT(disposition_required=1) → N3_QUALITY_DISPOSITION（见 IpqcInspectionDispositionService）。
/// 退回：N2→N1。复用 ApprovalFlow 引擎（StartFlow/Approve/ReturnToPrev + IFlowBizHandler），不改核心。
/// 整批判定 jgpd 写 qms_gcjyd 白名单列（可空、不硬编码枚举）；disposition_required 落扩展表作网关判据（与 jgpd 整批判定一致）。
/// 项目级 pd（qms_gcjydzb）仅明细展示辅助，不驱动整批流程。不回写 qms_gcjyd.status；不写库存/生产/仓储。
/// 正常鉴权（非 AllowAnonymous）；权限以当前用户 pending task 归属为准。
/// </summary>
[ApiDescriptionSettings(Order = 312, Description = "过程检验单流程")]
[Route("api/IpqcInspectionFlow")]
[NonUnify]
public class IpqcInspectionFlowService : IDynamicApiController, ITransient
{
    /// <summary>主/系统租户哨兵：超管未选择目标租户时其 JWT TenantId 即此值，拒绝作为业务租户。</summary>
    private const long MainTenantId = 1300000000001L;

    private readonly ISqlSugarClient _db;
    private readonly FlowEngineService _flowEngine;
    private readonly UserManager _userManager;
    private readonly IpqcInspectionMdpSyncService _mdpSyncService;
    private readonly ILogger<IpqcInspectionFlowService> _logger;

    public IpqcInspectionFlowService(
        ISqlSugarClient db,
        FlowEngineService flowEngine,
        UserManager userManager,
        IpqcInspectionMdpSyncService mdpSyncService,
        ILoggerFactory loggerFactory)
    {
        _db = db;
        _flowEngine = flowEngine;
        _userManager = userManager;
        _mdpSyncService = mdpSyncService;
        _logger = loggerFactory.CreateLogger<IpqcInspectionFlowService>();
    }

    /// <summary>
    /// 源表 qms_gcjyd 写入落库后，把本单据同步到标准层（list/detail 只读 mdp_std_ipqc_inspection，无 live 回退）。
    ///
    /// 必须放在业务事务<b>之外</b>：源表是权威数据，同步只是派生物，不能让派生失败回滚已成立的检验结果。
    /// 走单据级 <see cref="IpqcInspectionMdpSyncService.SyncInspectionAsync"/>，不调 RunFullAsync/RunInboundAsync
    /// （二者为全表扫描，且 RunFullAsync 的租户写死为 pbxfxp 账套映射，对其他租户捞不到行）。
    /// 失败只记 Error 日志不抛：此刻业务事务已提交且流程已推进，让 API 失败会诱导用户重试，
    /// 而重试必然报"当前不在检验录入节点"。标准层可由下一次 targeted / 手动 inbound 自愈。
    /// </summary>
    private async Task SyncInspectionToStdSafeAsync(long inspectionId, long tenantId, string triggerType)
    {
        try
        {
            await _mdpSyncService.SyncInspectionAsync(inspectionId, tenantId, triggerType);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex,
                "[IpqcFlow] 检验单 {InspectionId}(租户 {TenantId}) 业务写入已提交，但标准层 targeted 同步失败（{Trigger}），列表/详情可能仍显示旧值",
                inspectionId, tenantId, triggerType);
        }
    }

    /// <summary>严格可信租户解析：只来自认证后 JWT；无 Token(&lt;=0) 或超管未选主租户 → 拒绝；不读前端 tenantId、无默认回退。</summary>
    private long ResolveTenantOrThrow()
    {
        var tid = _userManager.TenantId;
        if (tid <= 0)
            throw Oops.Oh("无法确定当前租户，请重新登录或选择目标租户");
        if (_userManager.SuperAdmin && tid == MainTenantId)
            throw Oops.Oh("超级管理员操作前必须选择目标租户");
        return tid;
    }

    /// <summary>
    /// 检验单流程状态（只读，供前端按钮控制）。
    /// </summary>
    [DisplayName("过程检验单流程状态")]
    [HttpGet("state")]
    public async Task<IpqcFlowStateOutput> GetState([FromQuery] long id)
    {
        await EnsureBillExistsAsync(id);
        return await BuildStateAsync(id);
    }

    /// <summary>
    /// 检验员提交检验结果（写 qms_gcjyd 白名单列 + 推进 N1→N2）。
    /// </summary>
    [DisplayName("检验员提交检验结果")]
    [HttpPost("submit-inspection")]
    public async Task<IpqcFlowStateOutput> SubmitInspection([FromBody] IpqcSubmitInspectionInput input)
    {
        var billNo = await EnsureBillExistsAsync(input.Id);

        // 参数校验（不合格数不得为负、不得大于样本量；合格数不得为负）
        if (input.Jyhgsl < 0) throw Oops.Oh("检验合格数量不能为负");
        if (input.Jybhgsl < 0) throw Oops.Oh("检验不合格数量不能为负");
        if (input.Ybl is < 0) throw Oops.Oh("样本量不能为负");
        if (input.Ybl is > 0 && input.Jybhgsl > input.Ybl.Value)
            throw Oops.Oh("不合格数量不能大于样本量（检验数）");

        var inst = await GetLatestInstanceAsync(input.Id);
        if (inst != null && inst.Status != FlowInstanceStatusEnum.Running)
            throw Oops.Oh("该检验单流程已结束，无法再提交检验结果");

        var now = DateTime.Now;
        var inspectorName = _userManager.RealName ?? _userManager.Account;

        var tran = await _db.AsTenant().UseTranAsync(async () =>
        {
            // 无运行中实例 → 起流程（自动生成 N1 任务给检验员角色成员）
            long instanceId;
            if (inst == null)
            {
                instanceId = await _flowEngine.StartFlow(new StartFlowInput
                {
                    BizType = IpqcInspectionFlowConst.BizType,
                    BizId = input.Id,
                    BizNo = billNo,
                    Title = $"过程检验单 {billNo}",
                    Comment = input.Comment,
                });
            }
            else
            {
                instanceId = inst.Id;
            }

            var myTask = await GetMyPendingTaskAsync(instanceId);
            if (myTask == null)
                throw Oops.Oh("当前用户没有待处理的检验任务（需检验员角色成员）");
            if (myTask.NodeId != IpqcInspectionFlowConst.NodeInspect)
                throw Oops.Oh("当前不在检验录入节点，无法提交检验结果");

            // 写检验结果（仅 qms_gcjyd 白名单列 jgpd/jyhgsl/jybhgsl/ybl/jyr/bz；jgpd 可空不强写）
            var tid = ResolveTenantOrThrow();
            await _db.Ado.ExecuteCommandAsync(
                "UPDATE qms_gcjyd SET jgpd=@jgpd, jyhgsl=@jyhgsl, jybhgsl=@jybhgsl, ybl=@ybl, jyr=@jyr, bz=@bz WHERE id=@id AND tenant_id=@tid",
                new List<SugarParameter>
                {
                    new("@jgpd", input.Jgpd.HasValue ? input.Jgpd.Value : (object?)null),
                    new("@jyhgsl", input.Jyhgsl),
                    new("@jybhgsl", input.Jybhgsl),
                    new("@ybl", input.Ybl.HasValue ? input.Ybl.Value : (object?)null),
                    new("@jyr", inspectorName),
                    new("@bz", input.Bz),
                    new("@id", input.Id),
                    new("@tid", tid),
                });

            // 落轻量扩展表（提交人/提交时间/业务状态，不回写 qms_gcjyd.status）
            await UpsertFlowStateAsync(input.Id, billNo, instanceId, IpqcInspectionFlowConst.StatusPendingReview,
                IpqcInspectionFlowConst.NodeSupervisor, now, isSubmit: true, inspectorName: inspectorName);

            // 推进 N1 → N2
            await _flowEngine.Approve(myTask.Id, input.Comment);
        });
        if (!tran.IsSuccess) throw tran.ErrorException;

        // 事务外 targeted 同步：本动作写了 qms_gcjyd 的 jgpd/jyhgsl/jybhgsl/ybl/jyr/bz，
        // 其中 jgpd/jyr/ybl/bz 由 list/detail 投影渲染，不同步则页面停留在上一次快照。
        await SyncInspectionToStdSafeAsync(input.Id, ResolveTenantOrThrow(), "SUBMIT_INSPECTION");

        return await BuildStateAsync(input.Id);
    }

    /// <summary>
    /// 检验主管通过（整批判定）：Qualified=true 整批合格→end；Qualified=false 整批不合格→N3 质量处置。
    /// 写整批 jgpd（可空、不硬编码枚举）+ disposition_required（网关判据），再 Approve→GW_RESULT 分流。
    /// </summary>
    [DisplayName("检验主管通过")]
    [HttpPost("supervisor-approve")]
    public async Task<IpqcFlowStateOutput> SupervisorApprove([FromBody] IpqcSupervisorApproveInput input)
    {
        var billNo = await EnsureBillExistsAsync(input.Id);
        var (inst, myTask) = await RequireSupervisorTaskAsync(input.Id);
        var now = DateTime.Now;
        var supervisorName = _userManager.RealName ?? _userManager.Account;
        var dispositionRequired = input.Qualified ? 0 : 1;
        var businessStatus = input.Qualified ? IpqcInspectionFlowConst.StatusApproved : IpqcInspectionFlowConst.StatusPendingDisposition;
        var nextNode = input.Qualified ? null : IpqcInspectionFlowConst.NodeDisposition;

        var tran = await _db.AsTenant().UseTranAsync(async () =>
        {
            // 整批判定 jgpd 写 qms_gcjyd 白名单列（可空，不硬编码枚举；由前端传测试/已确认合法值）
            if (input.Jgpd.HasValue)
            {
                var tid = ResolveTenantOrThrow();
                await _db.Ado.ExecuteCommandAsync(
                    "UPDATE qms_gcjyd SET jgpd=@jgpd WHERE id=@id AND tenant_id=@tid",
                    new List<SugarParameter> { new("@jgpd", input.Jgpd.Value), new("@id", input.Id), new("@tid", tid) });
            }

            // 先写 disposition_required（GW_RESULT 网关判据，Approve 时 GetBizData 读取）再推进
            await UpsertFlowStateAsync(input.Id, billNo, inst.Id, businessStatus, nextNode, now,
                isSubmit: false, reviewResult: input.Qualified ? "APPROVED" : "TO_DISPOSITION",
                supervisorName: supervisorName, dispositionRequired: dispositionRequired);
            await _flowEngine.Approve(myTask.Id, input.Comment);
        });
        if (!tran.IsSuccess) throw tran.ErrorException;

        // 事务外 targeted 同步：**仅当本次确实改写了源表 jgpd 时**才同步。
        // 主管未传 jgpd 时本动作只动 flow_state（流程状态由 live 的 /state 接口读），标准层内容不变，
        // 无条件同步等于每次审批都做一次无意义写入。
        if (input.Jgpd.HasValue)
            await SyncInspectionToStdSafeAsync(input.Id, ResolveTenantOrThrow(), "SUPERVISOR_APPROVE");

        // 双模式出站：整批合格结束时写 Outbox（QMS_API 占位；任务书 action=S6_REPORT_PUSH）
        if (input.Qualified)
            await TryEnqueueIpqcPassOutboxAsync(input.Id, billNo);

        return await BuildStateAsync(input.Id);
    }

    /// <summary>
    /// 检验主管退回（N2 → 回 N1，意见必填）。
    /// </summary>
    [DisplayName("检验主管退回")]
    [HttpPost("supervisor-return")]
    public async Task<IpqcFlowStateOutput> SupervisorReturn([FromBody] IpqcSupervisorReturnInput input)
    {
        if (string.IsNullOrWhiteSpace(input.Comment))
            throw Oops.Oh("退回必须填写意见");

        var billNo = await EnsureBillExistsAsync(input.Id);
        var (inst, myTask) = await RequireSupervisorTaskAsync(input.Id);
        var now = DateTime.Now;
        var supervisorName = _userManager.RealName ?? _userManager.Account;

        var tran = await _db.AsTenant().UseTranAsync(async () =>
        {
            await UpsertFlowStateAsync(input.Id, billNo, inst.Id, IpqcInspectionFlowConst.StatusReturned,
                IpqcInspectionFlowConst.NodeInspect, now, isSubmit: false, reviewResult: "RETURNED",
                supervisorName: supervisorName, returnReason: input.Comment);
            await _flowEngine.ReturnToPrev(myTask.Id, input.Comment);
        });
        if (!tran.IsSuccess) throw tran.ErrorException;

        return await BuildStateAsync(input.Id);
    }

    // ───────────────────────── helpers ─────────────────────────

    /// <summary>校验检验单存在并返回 djbh（无 djbh 用 id 兜底）。</summary>
    private async Task<string> EnsureBillExistsAsync(long id)
    {
        if (id <= 0) throw Oops.Oh("检验单 id 非法");
        // 强制租户隔离：qms_gcjyd 全库共享无框架租户过滤器，裸 SQL 必须显式按当前用户租户校验，
        // 防止跨租户读到/操作他租户检验单。严格解析租户（无 Token / 超管未选主租户 → 拒绝，不回退默认）。
        var tid = ResolveTenantOrThrow();
        var rows = await _db.Ado.SqlQueryAsync<string>(
            "SELECT djbh FROM qms_gcjyd WHERE id=@id AND tenant_id=@tid LIMIT 1",
            new List<SugarParameter> { new("@id", id), new("@tid", tid) });
        if (rows.Count == 0) throw Oops.Oh("检验单不存在");
        return rows[0] ?? id.ToString();
    }

    /// <summary>取该检验单最新流程实例（BizType+BizId，跨数据范围）。</summary>
    private async Task<ApprovalFlowInstance?> GetLatestInstanceAsync(long bizId)
    {
        return await _db.Queryable<ApprovalFlowInstance>()
            .ClearFilter()
            .Where(x => x.BizType == IpqcInspectionFlowConst.BizType && x.BizId == bizId)
            .OrderByDescending(x => x.Id)
            .FirstAsync();
    }

    /// <summary>取当前用户在指定实例下的待办任务。</summary>
    private async Task<ApprovalFlowTask?> GetMyPendingTaskAsync(long instanceId)
    {
        var userId = _userManager.UserId;
        return await _db.Queryable<ApprovalFlowTask>()
            .ClearFilter()
            .Where(x => x.InstanceId == instanceId && x.AssigneeId == userId && x.Status == FlowTaskStatusEnum.Pending)
            .FirstAsync();
    }

    /// <summary>校验并返回主管 N2 待办任务。</summary>
    private async Task<(ApprovalFlowInstance inst, ApprovalFlowTask task)> RequireSupervisorTaskAsync(long bizId)
    {
        var inst = await GetLatestInstanceAsync(bizId);
        if (inst == null) throw Oops.Oh("该检验单尚未发起流程");
        if (inst.Status != FlowInstanceStatusEnum.Running) throw Oops.Oh("该检验单流程已结束");
        var myTask = await GetMyPendingTaskAsync(inst.Id);
        if (myTask == null) throw Oops.Oh("当前用户没有待处理的审核任务（需检验主管角色成员）");
        if (myTask.NodeId != IpqcInspectionFlowConst.NodeSupervisor) throw Oops.Oh("当前不在主管审核节点");
        return (inst, myTask);
    }

    /// <summary>当前用户是否具备指定角色（跨数据范围）。</summary>
    private async Task<bool> HasRoleAsync(long roleId)
    {
        var userId = _userManager.UserId;
        return await _db.Queryable<SysUserRole>()
            .ClearFilter()
            .AnyAsync(x => x.UserId == userId && x.RoleId == roleId);
    }

    /// <summary>Upsert 流程状态扩展表（不回写 qms_gcjyd.status）。dispositionRequired 非空时更新网关判据。</summary>
    private async Task UpsertFlowStateAsync(long inspectionId, string billNo, long instanceId, string businessStatus,
        string? currentNode, DateTime now, bool isSubmit, string? inspectorName = null, string? supervisorName = null,
        string? reviewResult = null, string? returnReason = null, int? dispositionRequired = null)
    {
        // 显式租户隔离：ClearFilter 移除框架租户过滤器后，必须补 TenantId 谓词，防止跨租户命中他租户流程状态行。
        var tid = ResolveTenantOrThrow();
        var existing = await _db.Queryable<AdoS6IpqcInspectionFlowState>()
            .ClearFilter()
            .Where(x => x.InspectionId == inspectionId && x.TenantId == tid)
            .FirstAsync();

        if (existing == null)
        {
            var row = new AdoS6IpqcInspectionFlowState
            {
                Id = YitIdHelper.NextId(),
                TenantId = tid,
                InspectionId = inspectionId,
                InspectionNo = billNo,
                BizType = IpqcInspectionFlowConst.BizType,
                FlowInstanceId = instanceId,
                BusinessStatus = businessStatus,
                CurrentNode = currentNode,
                DispositionRequired = dispositionRequired,
                RowVersion = 1,
                CreateTime = now,
            };
            if (isSubmit)
            {
                row.InspectorUserId = _userManager.UserId;
                row.InspectorName = inspectorName;
                row.SubmittedAt = now;
            }
            else
            {
                row.SupervisorUserId = _userManager.UserId;
                row.SupervisorName = supervisorName;
                row.ReviewedAt = now;
                row.ReviewResult = reviewResult;
                row.ReturnReason = returnReason;
            }
            await _db.Insertable(row).ExecuteCommandAsync();
            return;
        }

        existing.FlowInstanceId = instanceId;
        existing.BusinessStatus = businessStatus;
        existing.CurrentNode = currentNode;
        if (dispositionRequired.HasValue) existing.DispositionRequired = dispositionRequired;
        existing.RowVersion = (existing.RowVersion ?? 0) + 1;
        existing.UpdateTime = now;
        if (isSubmit)
        {
            existing.InspectorUserId = _userManager.UserId;
            existing.InspectorName = inspectorName;
            existing.SubmittedAt = now;
        }
        else
        {
            existing.SupervisorUserId = _userManager.UserId;
            existing.SupervisorName = supervisorName;
            existing.ReviewedAt = now;
            existing.ReviewResult = reviewResult;
            existing.ReturnReason = returnReason;
        }
        await _db.Updateable(existing).ExecuteCommandAsync();
    }

    /// <summary>
    /// 完成态解释文案。IPQC 有两个合法完成终态，业务语义不同，不能都说"主管审核通过"：
    /// <list type="bullet">
    /// <item>APPROVED = 整批合格、主管审核通过后直接结束；</item>
    /// <item>DISPOSED = 整批不合格，经 N3 质量处置完成后结束（ApprovalFlow 实例同样是 Approved）。</item>
    /// </list>
    /// 仅生成给 UI 的解释性文字，<b>不参与任何状态判定、不影响状态机</b>。
    /// 业务状态缺失时返回中性文案，不臆断"审核通过"。
    /// </summary>
    private static string BuildCompletedMessage(string? businessStatus) => businessStatus switch
    {
        IpqcInspectionFlowConst.StatusApproved => "流程已完成（整批合格·主管审核通过）",
        IpqcInspectionFlowConst.StatusDisposed => "流程已完成（整批不合格·已处置）",
        _ => "流程已完成",
    };

    /// <summary>组装流程状态输出。</summary>
    private async Task<IpqcFlowStateOutput> BuildStateAsync(long bizId)
    {
        var output = new IpqcFlowStateOutput { BizId = bizId };
        var inst = await GetLatestInstanceAsync(bizId);

        // 显式租户隔离：ClearFilter 移除框架租户过滤器后，必须补 TenantId 谓词，防止跨租户读到他租户流程状态/处置。
        var tid = ResolveTenantOrThrow();
        var state = await _db.Queryable<AdoS6IpqcInspectionFlowState>()
            .ClearFilter()
            .Where(x => x.InspectionId == bizId && x.TenantId == tid)
            .FirstAsync();
        if (state != null)
        {
            output.BusinessStatus = state.BusinessStatus;
            output.InspectorName = state.InspectorName;
            output.SupervisorName = state.SupervisorName;
            output.DispositionRequired = state.DispositionRequired;
        }
        output.HasDisposition = await _db.Queryable<AdoS6IpqcQualityDisposition>()
            .ClearFilter().AnyAsync(x => x.InspectionId == bizId && x.TenantId == tid && x.Status == 1);

        if (inst == null)
        {
            output.FlowStatus = "NotStarted";
            output.CanSubmitResult = await HasRoleAsync(IpqcInspectionFlowConst.RoleInspectorId);
            output.Message = output.CanSubmitResult ? "待检验员录入结果" : "尚未发起流程";
            return output;
        }

        output.InstanceId = inst.Id;
        output.FlowStatus = inst.Status.ToString();
        output.UpdatedAt = inst.EndTime ?? inst.StartTime;

        if (inst.Status != FlowInstanceStatusEnum.Running)
        {
            output.IsCompleted = true;
            output.Message = inst.Status == FlowInstanceStatusEnum.Approved
                ? BuildCompletedMessage(output.BusinessStatus)
                : $"流程已结束（{inst.Status}）";
            return output;
        }

        output.CurrentNodeCode = inst.CurrentNodeId;
        var myTask = await GetMyPendingTaskAsync(inst.Id);
        if (myTask != null)
        {
            output.CurrentNodeName = myTask.NodeName;
            if (myTask.NodeId == IpqcInspectionFlowConst.NodeInspect)
            {
                output.CurrentAssigneeRole = IpqcInspectionFlowConst.RoleInspectorCode;
                output.CanSubmitResult = true;
                output.Message = "待当前用户录入检验结果";
            }
            else if (myTask.NodeId == IpqcInspectionFlowConst.NodeSupervisor)
            {
                output.CurrentAssigneeRole = IpqcInspectionFlowConst.RoleSupervisorCode;
                output.CanSupervisorApprove = true;
                output.CanSupervisorReturn = true;
                output.Message = "待当前用户主管审核";
            }
            else if (myTask.NodeId == IpqcInspectionFlowConst.NodeDisposition)
            {
                output.CurrentAssigneeRole = IpqcInspectionFlowConst.RoleQualityEngineerCode;
                output.CanSubmitDisposition = true;
                output.Message = "待当前用户提交质量处置";
            }
        }
        else
        {
            output.CurrentAssigneeRole = inst.CurrentNodeId switch
            {
                IpqcInspectionFlowConst.NodeInspect => IpqcInspectionFlowConst.RoleInspectorCode,
                IpqcInspectionFlowConst.NodeDisposition => IpqcInspectionFlowConst.RoleQualityEngineerCode,
                _ => IpqcInspectionFlowConst.RoleSupervisorCode,
            };
            output.Message = "流程进行中（当前用户无待办）";
        }
        return output;
    }

    /// <summary>
    /// 整批合格闭环时写 mdp_outbox（幂等）；失败不阻断主流程。
    /// </summary>
    private async Task TryEnqueueIpqcPassOutboxAsync(long billId, string billNo)
    {
        try
        {
            // 严格租户隔离：裸 SQL 读 qms_gcjyd 必须显式按当前用户租户校验，防止跨租户读他租户单据。
            long tenantId = ResolveTenantOrThrow();
            var row = await _db.Ado.SqlQuerySingleAsync<IpqcOutboxBillRow>(
                "SELECT id AS Id, djbh AS BillNo, jgpd AS Jgpd, jyhgsl AS Jyhgsl, jybhgsl AS Jybhgsl FROM qms_gcjyd WHERE id=@id AND tenant_id=@tid LIMIT 1",
                new List<SugarParameter> { new("@id", billId), new("@tid", tenantId) });
            if (row == null) return;

            string idem = string.IsNullOrWhiteSpace(billNo) ? billId.ToString() : billNo;
            var payload = JsonSerializer.Serialize(new
            {
                path = "/ipqc/result",
                method = "POST",
                body = new
                {
                    billId,
                    billNo = idem,
                    jgpd = row.Jgpd,
                    jyhgsl = row.Jyhgsl,
                    jybhgsl = row.Jybhgsl,
                    action = "S6_REPORT_PUSH"
                }
            });

            var exists = await _db.Ado.GetIntAsync(
                "SELECT COUNT(1) FROM mdp_outbox WHERE tenant_id=@tid AND target_source_code='QMS_API' AND action_code='S6_REPORT_PUSH' AND idem_key=@idem",
                new List<SugarParameter>
                {
                    new("@tid", tenantId),
                    new("@idem", idem)
                }) > 0;
            if (exists) return;

            await _db.Insertable(new MdpOutbox
            {
                TenantId = tenantId,
                TargetSourceCode = "QMS_API",
                ActionCode = "S6_REPORT_PUSH",
                IdemKey = idem,
                PayloadJson = payload,
                Status = 0,
                RetryCount = 0,
                CreateTime = DateTime.Now,
                UpdateTime = DateTime.Now
            }).ExecuteCommandAsync();
        }
        catch
        {
            // Outbox 写入失败不影响检验闭环
        }
    }

    private sealed class IpqcOutboxBillRow
    {
        public long Id { get; set; }
        public string? BillNo { get; set; }
        public int? Jgpd { get; set; }
        public decimal? Jyhgsl { get; set; }
        public decimal? Jybhgsl { get; set; }
    }
}