AiDOPWarehouse/server/Plugins/Admin.NET.Plugin.AiDOP/FinishedWarehouse/FqcInspBillFlowService.cs

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

namespace Admin.NET.Plugin.AiDOP.FinishedWarehouse;

/// <summary>
/// S7 FQC 成品检验单 检验员+主管最小审批流服务（S7-FQC-INSPBILL-INSPECTOR-SUPERVISOR-FLOW-1）。
///
/// N1_INSPECT 检验员录入 pd/hgsl/bhgsl/clfs → 提交 → N2_SUP_REVIEW 检验主管审核（通过=Approved / 退回=回 N1）。
/// 复用 ApprovalFlow 引擎扩展点（StartFlow/Approve/ReturnToPrev + IFlowBizHandler），不改 ApprovalFlow 核心。
/// BizType=S7_FQC_INSPBILL，BizId=qms_qcpp_inspbill.id，BizCode=FBILLNO。反查用 ApprovalFlowInstance(BizType,BizId)，inspbill 不加列。
///
/// 状态归属（严格分离）：
///   - 检验业务结果 → qms_qcpp_inspbill.pd/hgsl/bhgsl/clfs（仅 submit-result 写）
///   - 检验任务执行进度 → qms_fqcbj.jyfzr/jykssj/jywcsj/FINSPECTSTATUS（经 lydjbh=FBILLNO 关联；仅执行状态未检验/检验中/检验完成）
///   - 审批节点/待办/审核状态 → ApprovalFlowInstance（绝不写入 FINSPECTSTATUS）
/// 不写 FBILLSTATUS/库存/仓储/生产状态；clfs 仅保存不触发任何后续动作。正常鉴权（非匿名）。
/// </summary>
[ApiDescriptionSettings(Order = 331, Description = "FQC检验单流程")]
[Route("api/S7FqcInspBillFlow")]
[NonUnify]
public class FqcInspBillFlowService : IDynamicApiController, ITransient
{
    private readonly ISqlSugarClient _db;
    private readonly FlowEngineService _flowEngine;
    private readonly UserManager _userManager;
    private readonly FqcMdpSyncService _fqcMdpSyncService;
    private readonly ILogger<FqcInspBillFlowService> _logger;

    public FqcInspBillFlowService(
        ISqlSugarClient db,
        FlowEngineService flowEngine,
        UserManager userManager,
        FqcMdpSyncService fqcMdpSyncService,
        ILoggerFactory loggerFactory)
    {
        _db = db;
        _flowEngine = flowEngine;
        _userManager = userManager;
        _fqcMdpSyncService = fqcMdpSyncService;
        _logger = loggerFactory.CreateLogger<FqcInspBillFlowService>();
    }

    /// <summary>
    /// 业务写入落库后，把本单据同步到数据中台标准层（result-list / detail / task-list 均读 std）。
    ///
    /// 必须放在业务事务<b>之外</b>（事务内跑同步会把 std 写入绑进业务事务，放大锁范围）；
    /// 走单据级 <see cref="FqcMdpSyncService.SyncBillAsync"/> 而非 12s 的全量 RunFullAsync。
    /// 同步失败只告警不抛：此刻业务事务已提交且流程已推进，让 API 失败会诱导用户重试，
    /// 而重试必然报"当前不在检验录入节点"——反而更难排查。std 可由下一次 targeted/全量刷新自愈。
    /// </summary>
    private async Task SyncBillToStdSafeAsync(long billId, string triggerType)
    {
        try
        {
            var tid = ResolveTenantOrThrow();
            await _fqcMdpSyncService.SyncBillAsync(billId, tid, triggerType);
        }
        catch (Exception ex)
        {
            _logger.LogWarning(ex, "[FqcFlow] 单据 {BillId} 业务写入已成功，但标准层 targeted 同步失败（{Trigger}），列表可能仍显示旧值", billId, triggerType);
        }
    }

    /// <summary>严格可信租户解析，见 <see cref="Infrastructure.AidopTenantScope.ResolveOrThrow"/>。</summary>
    private long ResolveTenantOrThrow() => Infrastructure.AidopTenantScope.ResolveOrThrow(_userManager);


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

    /// <summary>
    /// 检验员提交检验结果（写 qms_qcpp_inspbill.pd/hgsl/bhgsl/clfs + qms_fqcbj 任务进度 + 推进 N1→N2）。
    /// </summary>
    [DisplayName("检验员提交检验结果")]
    [HttpPost("submit-result")]
    public async Task<FqcFlowStateOutput> SubmitResult([FromBody] FqcSubmitResultInput input)
    {
        var (billNo, sourceBillNo) = await EnsureBillAsync(input.Id);

        // 参数校验
        if (input.Pd != 0 && input.Pd != 1) throw Oops.Oh("判定 pd 只能为 0(合格) 或 1(不合格)");
        if (input.Hgsl < 0) throw Oops.Oh("合格数量不能为负");
        if (input.Bhgsl < 0) throw Oops.Oh("不合格数量不能为负");
        if (input.Pd == 0)
        {
            if (input.Bhgsl != 0) throw Oops.Oh("判定合格时不合格数量必须为 0");
        }
        else // pd == 1
        {
            if (input.Bhgsl <= 0) throw Oops.Oh("判定不合格时不合格数量必须大于 0");
            if (input.Clfs is not (0 or 1 or 2)) throw Oops.Oh("判定不合格时处理方式 clfs 必填且只能为 0(让步接收)/1(挑选)/2(报废)");
        }

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

        // 负责人业务门：当前用户必须是该检验单负责人(qms_fqcbj.jyfzr==UserId)。
        // Flow 引擎只校 N1 Assignee，业务层再校 jyfzr → 双重保证 jyfzr==当前用户==N1 Assignee 三者一致。
        var gateTenantId = ResolveTenantOrThrow();
        if (!string.IsNullOrWhiteSpace(sourceBillNo))
        {
            var jyfzrOwner = await _db.Ado.SqlQuerySingleAsync<string>(
                "SELECT jyfzr FROM qms_fqcbj WHERE FBILLNO=@bjbh AND tenant_id=@t LIMIT 1",
                new SugarParameter("@bjbh", sourceBillNo), new SugarParameter("@t", gateTenantId));
            if (!string.Equals((jyfzrOwner ?? "").Trim(), _userManager.UserId.ToString(), StringComparison.Ordinal))
                throw Oops.Oh("当前用户不是该检验单负责人，无权提交检验结果");
        }

        var now = DateTime.Now;
        // 检验人=本次实际提交检验结果的操作者姓名（RealName 空回退 Account）；语义区别于负责人 jyfzr(=SysUser.Id)，二者不混用
        var inspectorName = _userManager.RealName ?? _userManager.Account;

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

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

            var tid = ResolveTenantOrThrow();

            // ① 检验业务结果 → qms_qcpp_inspbill（pd/hgsl/bhgsl/clfs 结果；jyr=录入者、FINSPEENDDATE=检验完成时刻）
            //    FINSPEENDDATE 复用同一 now，与本事务内 qms_fqcbj.jywcsj 保持同一"检验完成"时刻；退回重提允许覆盖为最后一次有效提交
            await _db.Ado.ExecuteCommandAsync(
                "UPDATE qms_qcpp_inspbill SET pd=@pd, hgsl=@hgsl, bhgsl=@bhgsl, clfs=@clfs, jyr=@jyr, FINSPEENDDATE=@finsp WHERE id=@id AND tenant_id=@TenantFilter",
                new List<SugarParameter>
                {
                    new("@pd", input.Pd),
                    new("@hgsl", input.Hgsl),
                    new("@bhgsl", input.Bhgsl),
                    new("@clfs", input.Pd == 1 ? input.Clfs : null),
                    new("@jyr", inspectorName),
                    new("@finsp", now),
                    new("@id", input.Id),
                    new("@TenantFilter", tid),
                });

            // ② 检验任务执行进度 → qms_fqcbj（经 lydjbh=FBILLNO 关联；lydjbh 为空则跳过，防误伤）
            //    安全约束（§二）：先查关联数量 —— 0 条跳过、1 条更新、>1 条视为数据异常抛错整体回滚，
            //    杜绝无保护批量 UPDATE 一次误更新多条任务（即使未来真实数据出现重复 FBILLNO 也安全）。
            //    jykssj 若为空则补首次开始时间（IFNULL 保留既有）；jywcsj=本次提交时间；FINSPECTSTATUS=检验完成
            if (!string.IsNullOrWhiteSpace(sourceBillNo))
            {
                var taskCount = await _db.Ado.GetIntAsync(
                    "SELECT COUNT(1) FROM qms_fqcbj WHERE FBILLNO=@bjbh AND tenant_id=@TenantFilter",
                    new List<SugarParameter> { new("@bjbh", sourceBillNo), new("@TenantFilter", tid) });
                if (taskCount > 1)
                    throw Oops.Oh($"检验任务数据异常：来源单号 {sourceBillNo} 匹配到 {taskCount} 条报检任务(qms_fqcbj)，无法安全更新，已整体回滚");
                if (taskCount == 1)
                {
                    // 不覆写 jyfzr：保持 Claim/Assign 设定的 SysUser.Id 语义，禁止被姓名污染（负责人门/待办均按 id 比对）。
                    // 仅更新任务进度（开始/完成时间、检验完成状态）；如需展示姓名由 SysUser join 解析。
                    await _db.Ado.ExecuteCommandAsync(
                        "UPDATE qms_fqcbj SET jykssj=IFNULL(jykssj,@now), jywcsj=@now, FINSPECTSTATUS=@status WHERE FBILLNO=@bjbh AND tenant_id=@TenantFilter",
                        new List<SugarParameter>
                        {
                            new("@now", now),
                            new("@status", FqcInspBillFlowConst.InspectStatusDone),
                            new("@bjbh", sourceBillNo),
                            new("@TenantFilter", tid),
                        });
                }
            }

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

        // ④ 标准层同步（事务外）：①写的 pd/hgsl/bhgsl/jyr/FINSPEENDDATE → mdp_std_fqc_result，
        //    save-detail 已写的 qms_qcpp_inspbillst 明细 → mdp_std_fqc_result_detail（本单一次性全量收口，
        //    故 save-detail 逐项保存时不必同步），②写的 qms_fqcbj 进度 → mdp_std_fqc_task。
        await SyncBillToStdSafeAsync(input.Id, "SUBMIT_RESULT");

        return await BuildStateAsync(input.Id);
    }

    /// <summary>检验主管通过（N2 → 完成，不覆盖检验员业务结果）。</summary>
    [DisplayName("检验主管通过")]
    [HttpPost("supervisor-approve")]
    public async Task<FqcFlowStateOutput> SupervisorApprove([FromBody] FqcSupervisorApproveInput input)
    {
        await EnsureBillAsync(input.Id);
        var (_, myTask) = await RequireSupervisorTaskAsync(input.Id);

        var tran = await _db.AsTenant().UseTranAsync(async () =>
        {
            await _flowEngine.Approve(myTask.Id, input.Comment);
        });
        if (!tran.IsSuccess) throw tran.ErrorException;

        // 双模式出站：主管通过且判定合格时写入 Outbox（QMS_API 占位源，真实地址配置后由 Job 推送）
        await TryEnqueueFqcPassOutboxAsync(input.Id);

        return await BuildStateAsync(input.Id);
    }

    /// <summary>检验主管退回（N2 → 回 N1，意见必填；保留检验员业务结果与任务进度）。</summary>
    [DisplayName("检验主管退回")]
    [HttpPost("supervisor-reject")]
    public async Task<FqcFlowStateOutput> SupervisorReject([FromBody] FqcSupervisorRejectInput input)
    {
        if (string.IsNullOrWhiteSpace(input.Comment))
            throw Oops.Oh("退回必须填写意见");

        var (_, sourceBillNo) = await EnsureBillAsync(input.Id);
        var (_, myTask) = await RequireSupervisorTaskAsync(input.Id);
        var tid = ResolveTenantOrThrow();

        var tran = await _db.AsTenant().UseTranAsync(async () =>
        {
            // ReturnToPrev 回 N1（原流程回退，不重新起流/不改 Initiator/N1 Assignee/jyfzr）；
            // 保留已录检验明细与 pd/hgsl/bhgsl/clfs（不清结果），检验员在原数据上修改后重提。
            await _flowEngine.ReturnToPrev(myTask.Id, input.Comment);

            // 业务状态同步：退回后 Flow 回 N1 ⇔ FINSPECTSTATUS 恢复"检验中"（与生成时口径一致），
            // 与 ReturnToPrev 同一事务，杜绝"Flow回N1但状态仍检验完成"或"状态改了但Reject失败仍N2"的分叉。
            if (!string.IsNullOrWhiteSpace(sourceBillNo))
            {
                await _db.Ado.ExecuteCommandAsync(
                    "UPDATE qms_fqcbj SET FINSPECTSTATUS='检验中' WHERE FBILLNO=@bjbh AND tenant_id=@t",
                    new SugarParameter("@bjbh", sourceBillNo), new SugarParameter("@t", tid));
            }
        });
        if (!tran.IsSuccess) throw tran.ErrorException;

        // 退回改写了 qms_fqcbj.FINSPECTSTATUS，该列即检验任务列表的「检验进度」(mdp_std_fqc_task.inspect_progress)，
        // 不同步则任务列表停留在"检验完成"。检验结果 pd/hgsl/bhgsl 本动作不改，同步对其为幂等重写。
        await SyncBillToStdSafeAsync(input.Id, "SUP_REJECT");

        return await BuildStateAsync(input.Id);
    }

    /// <summary>
    /// QE 提交处置方案（N3_QE_DISPOSITION → end）。写 ado_s7_fqc_qe_disposition + 推进 N3→end，同事务。
    /// 仅记录处置结论；不覆盖 qms_qcpp_inspbill.pd/hgsl/bhgsl/clfs、不写 qms_fqcbj/库存/仓储/生产。一单一有效处置。
    /// </summary>
    [DisplayName("QE提交处置方案")]
    [HttpPost("qe-submit-disposition")]
    public async Task<FqcFlowStateOutput> QeSubmitDisposition([FromBody] FqcQeSubmitDispositionInput input)
    {
        var (billNo, sourceBillNo) = await EnsureBillAsync(input.Id);

        // 参数校验
        var dt = input.DispositionType?.Trim().ToUpperInvariant();
        if (dt is not (FqcInspBillFlowConst.DispTypeRework or FqcInspBillFlowConst.DispTypeConcession
            or FqcInspBillFlowConst.DispTypeScrap or FqcInspBillFlowConst.DispTypeOther))
            throw Oops.Oh("处置类型只能为 REWORK(返工)/CONCESSION(让步放行)/SCRAP(报废)/OTHER(其它)");
        if (string.IsNullOrWhiteSpace(input.DispositionOpinion)) throw Oops.Oh("处置意见必填");
        foreach (var q in new[] { input.DispositionQty, input.ReworkQty, input.ConcessionQty, input.ScrapQty })
            if (q is < 0) throw Oops.Oh("处置数量不能为负");

        var inst = await GetLatestInstanceAsync(input.Id);
        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("当前用户没有待处理的 QE 处置任务（需质量工程师角色成员）");
        if (myTask.NodeId != FqcInspBillFlowConst.NodeDisposition) throw Oops.Oh("当前不在 QE 处置节点");

        // 一单一有效处置（唯一索引 inspbill_id + status==1 双保险）
        var hasEffective = await _db.Queryable<AdoS7FqcQeDisposition>()
            .Where(x => x.InspbillId == input.Id && x.Status == 1)
            .AnyAsync();
        if (hasEffective) throw Oops.Oh("该检验单已有有效 QE 处置，不可重复提交");

        // 写库前严格解析可信租户（无 Token / 超管未选主租户 → 抛错，不落库）
        var tid = ResolveTenantOrThrow();
        var now = DateTime.Now;
        var disposition = new AdoS7FqcQeDisposition
        {
            Id = YitIdHelper.NextId(),
            TenantId = tid,
            OrgId = inst.OrgId,
            InspbillId = input.Id,
            InspbillNo = billNo,
            SourceBillNo = sourceBillNo,
            BizType = FqcInspBillFlowConst.BizType,
            FlowInstanceId = inst.Id,
            DispositionNo = $"FQCQE-{billNo}-{now:yyyyMMddHHmmss}",
            DispositionType = dt!,
            DispositionQty = input.DispositionQty,
            ReworkQty = input.ReworkQty,
            ConcessionQty = input.ConcessionQty,
            ScrapQty = input.ScrapQty,
            DispositionOpinion = input.DispositionOpinion!.Trim(),
            ResponsibilityDept = input.ResponsibilityDept,
            ResponsibleUser = input.ResponsibleUser,
            AttachmentJson = input.AttachmentJson,
            SubmittedBy = _userManager.UserId,
            SubmittedByName = _userManager.RealName ?? _userManager.Account,
            Status = 1,
            SubmittedAt = now,
        };

        var tran = await _db.AsTenant().UseTranAsync(async () =>
        {
            await _db.Insertable(disposition).ExecuteCommandAsync();
            // 推进 N3 → end
            await _flowEngine.Approve(myTask.Id, input.Comment);
        });
        if (!tran.IsSuccess) throw tran.ErrorException;

        return await BuildStateAsync(input.Id);
    }

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

    /// <summary>校验检验单存在并返回 FBILLNO。</summary>
    private async Task<string> EnsureBillExistsAsync(long id)
    {
        var (billNo, _) = await EnsureBillAsync(id);
        return billNo;
    }

    /// <summary>校验检验单存在并返回 (FBILLNO, lydjbh来源单号)。</summary>
    private async Task<(string billNo, string? sourceBillNo)> EnsureBillAsync(long id)
    {
        if (id <= 0) throw Oops.Oh("检验单 id 非法");
        var tid = ResolveTenantOrThrow();
        var rows = await _db.Ado.SqlQueryAsync<FqcBillKey>(
            "SELECT FBILLNO AS BillNo, lydjbh AS SourceBillNo FROM qms_qcpp_inspbill WHERE id=@id AND tenant_id=@TenantFilter LIMIT 1",
            new List<SugarParameter> { new("@id", id), new("@TenantFilter", tid) });
        var r = rows.FirstOrDefault();
        if (r == null) throw Oops.Oh("检验单不存在");
        return (r.BillNo ?? id.ToString(), r.SourceBillNo);
    }

    /// <summary>取该检验单最新流程实例（BizType+BizId，跨数据范围）。</summary>
    private async Task<ApprovalFlowInstance?> GetLatestInstanceAsync(long bizId)
    {
        return await _db.Queryable<ApprovalFlowInstance>()
            .ClearFilter()
            .Where(x => x.BizType == FqcInspBillFlowConst.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 != FqcInspBillFlowConst.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>组装流程状态输出。</summary>
    private async Task<FqcFlowStateOutput> BuildStateAsync(long bizId)
    {
        var output = new FqcFlowStateOutput { BizId = bizId };
        var inst = await GetLatestInstanceAsync(bizId);

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

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

        // QE 处置摘要（任何状态都展示已提交处置）+ 网关判据 disposition_required（由 pd 计算，供展示/调试）
        var disp = await _db.Queryable<AdoS7FqcQeDisposition>()
            .Where(x => x.InspbillId == bizId && x.Status == 1)
            .OrderByDescending(x => x.Id)
            .FirstAsync();
        if (disp != null)
        {
            output.HasDisposition = true;
            output.DispositionType = disp.DispositionType;
            output.DispositionOpinion = disp.DispositionOpinion;
        }
        var tid = ResolveTenantOrThrow();
        var pdRows = await _db.Ado.SqlQueryAsync<string>(
            "SELECT pd FROM qms_qcpp_inspbill WHERE id=@id AND tenant_id=@TenantFilter LIMIT 1",
            new List<SugarParameter> { new("@id", bizId), new("@TenantFilter", tid) });
        output.DispositionRequired = (pdRows.FirstOrDefault()?.Trim() == "1") ? 1 : 0;

        if (inst.Status != FlowInstanceStatusEnum.Running)
        {
            output.IsCompleted = true;
            output.Message = inst.Status == FlowInstanceStatusEnum.Approved ? "流程已完成（审批通过）" : $"流程已结束（{inst.Status}）";
            return output;
        }

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

    /// <summary>
    /// 合格闭环时写 mdp_outbox（幂等）；失败不阻断主流程。
    /// </summary>
    private async Task TryEnqueueFqcPassOutboxAsync(long billId)
    {
        try
        {
            long tenantId = ResolveTenantOrThrow();
            var row = await _db.Ado.SqlQuerySingleAsync<FqcOutboxBillRow>(
                "SELECT id AS Id, FBILLNO AS BillNo, pd AS Pd, hgsl AS Hgsl, bhgsl AS Bhgsl FROM qms_qcpp_inspbill WHERE id=@id AND tenant_id=@tid LIMIT 1",
                new List<SugarParameter> { new("@id", billId), new("@tid", tenantId) });
            if (row == null || row.Pd != 0) return; // 仅合格回写

            string billNo = string.IsNullOrWhiteSpace(row.BillNo) ? billId.ToString() : row.BillNo!;
            var payload = JsonSerializer.Serialize(new
            {
                path = "/fqc/result",
                method = "POST",
                body = new
                {
                    billId,
                    billNo,
                    pd = row.Pd,
                    hgsl = row.Hgsl,
                    bhgsl = row.Bhgsl,
                    action = "S7_FQC_RESULT_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='S7_FQC_RESULT_PUSH' AND idem_key=@idem",
                new List<SugarParameter>
                {
                    new("@tid", tenantId),
                    new("@idem", billNo)
                }) > 0;
            if (exists) return;

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

    private sealed class FqcOutboxBillRow
    {
        public long Id { get; set; }
        public string? BillNo { get; set; }
        public int? Pd { get; set; }
        public decimal? Hgsl { get; set; }
        public decimal? Bhgsl { get; set; }
    }

    private class FqcBillKey
    {
        public string? BillNo { get; set; }
        public string? SourceBillNo { get; set; }
    }
}