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

using Admin.NET.Plugin.AiDOP.Entity;
using Admin.NET.Plugin.AiDOP.MaterialWarehouse.Dto;
using Admin.NET.Plugin.ApprovalFlow;
using Admin.NET.Plugin.ApprovalFlow.Service;
using Yitter.IdGenerator;

namespace Admin.NET.Plugin.AiDOP.MaterialWarehouse;

/// <summary>
/// S5 来料检验单 检验员+主管最小审批流服务（S5-IQC-INSPBILL-INSPECTOR-SUPERVISOR-FLOW-1）。
///
/// N1_INSPECT 检验员录入 pd/dhsl/bhgsl/clfs → 提交 → N2_SUP_REVIEW 检验主管审核（通过=CLOSED / 退回=回 N1）。
/// 复用 ApprovalFlow 引擎扩展点（StartFlow/Approve/ReturnToPrev + IFlowBizHandler），不改 ApprovalFlow 核心。
/// BizType=S5_IQC_INSPBILL，BizId=qms_qcp_inspbill.id，BizCode=FBILLNO。反查用 ApprovalFlowInstance(BizType,BizId)，inspbill 不加列。
/// submit-result 写 qms_qcp_inspbill.pd/dhsl/bhgsl/clfs 并推进 N1→N2；
/// Q5：提交结果即推 165（IqcWmsResultPushService），主管审核不再碰 165。
/// approve/reject 不写 qms。不写库存、不入库。
/// </summary>
[ApiDescriptionSettings(Order = 310, Description = "来料检验单流程")]
[Route("api/S5IqcInspBillFlow")]
[NonUnify]
public class IqcInspBillFlowService : 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 IqcWmsResultPushService _wmsPush;

    public IqcInspBillFlowService(
        ISqlSugarClient db,
        FlowEngineService flowEngine,
        UserManager userManager,
        IqcWmsResultPushService wmsPush)
    {
        _db = db;
        _flowEngine = flowEngine;
        _userManager = userManager;
        _wmsPush = wmsPush;
    }

    /// <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<IqcFlowStateOutput> GetState([FromQuery] long id)
    {
        await EnsureBillExistsAsync(id);
        return await BuildStateAsync(id);
    }

    /// <summary>
    /// 检验员提交检验结果（写 pd/dhsl/bhgsl/clfs + 推进 N1→N2）。
    /// </summary>
    [DisplayName("检验员提交检验结果")]
    [HttpPost("submit-result")]
    public async Task<IqcFlowStateOutput> SubmitResult([FromBody] IqcSubmitResultInput input)
    {
        var billNo = await EnsureBillExistsAsync(input.Id);

        // 参数校验
        if (input.Pd != 0 && input.Pd != 1) throw Oops.Oh("判定 pd 只能为 0(合格) 或 1(不合格)");
        if (input.Dhsl < 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("该检验单流程已结束，无法再提交检验结果");

        var tran = await _db.AsTenant().UseTranAsync(async () =>
        {
            // 无运行中实例 → 起流程（自动生成 N1 任务给检验员角色成员）
            long instanceId;
            if (inst == null)
            {
                instanceId = await _flowEngine.StartFlow(new StartFlowInput
                {
                    BizType = IqcInspBillFlowConst.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 != IqcInspBillFlowConst.NodeInspect)
                throw Oops.Oh("当前不在检验录入节点，无法提交检验结果");

            // 写库前严格解析可信租户（无 Token / 超管未选主租户 → 抛错，不落库）
            var tid = ResolveTenantOrThrow();

            // 写检验结果（仅 pd/dhsl/bhgsl/clfs）
            await _db.Ado.ExecuteCommandAsync(
                "UPDATE qms_qcp_inspbill SET pd=@pd, dhsl=@dhsl, bhgsl=@bhgsl, clfs=@clfs WHERE id=@id AND tenant_id=@TenantId",
                new List<SugarParameter>
                {
                    new("@pd", input.Pd),
                    new("@dhsl", input.Dhsl),
                    new("@bhgsl", input.Bhgsl),
                    new("@clfs", input.Pd == 1 ? input.Clfs : null),
                    new("@id", input.Id),
                    new("@TenantId", tid),
                });

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

        // Q5：检验员提交即推 165（对齐旧 DOP submitAfter）；失败不阻断主流程
        try
        {
            var tid = ResolveTenantOrThrow();
            await _wmsPush.TryEnqueueAfterSubmitAsync(input.Id, tid);
        }
        catch
        {
            // 推送失败不影响提交结果本身
        }

        return await BuildStateAsync(input.Id);
    }

    /// <summary>
    /// 检验主管通过（N2 → 完成）。仅走 Ai-DOP 内部审批，不再写 165。
    /// </summary>
    [DisplayName("检验主管通过")]
    [HttpPost("supervisor-approve")]
    public async Task<IqcFlowStateOutput> SupervisorApprove([FromBody] IqcSupervisorApproveInput input)
    {
        await EnsureBillExistsAsync(input.Id);
        var (inst, 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;

        return await BuildStateAsync(input.Id);
    }

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

        await EnsureBillExistsAsync(input.Id);
        var (inst, myTask) = await RequireSupervisorTaskAsync(input.Id);

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

        return await BuildStateAsync(input.Id);
    }

    /// <summary>
    /// SQE 提交处置方案（N3 → 完成）。写 ado_s5_iqc_sqe_disposition + 推进 N3→end。不写 qms.clfs/库存/仓储。
    /// </summary>
    [DisplayName("SQE提交处置方案")]
    [HttpPost("sqe-submit-disposition")]
    public async Task<IqcFlowStateOutput> SqeSubmitDisposition([FromBody] IqcSqeSubmitDispositionInput input)
    {
        var billNo = await EnsureBillExistsAsync(input.Id);

        // 参数校验
        if (input.DispositionType is not (0 or 1 or 2)) throw Oops.Oh("处置方式只能为 0(让步接收)/1(挑选)/2(报废)");
        if (string.IsNullOrWhiteSpace(input.DispositionOpinion)) throw Oops.Oh("处置意见必填");
        foreach (var q in new[] { input.DispositionQty, input.ConcessionQty, input.SelectionQty, input.ScrapQty })
            if (q.HasValue && q.Value < 0) throw Oops.Oh("处置数量不能为负");

        // 写库前严格解析可信租户（无 Token / 超管未选主租户 → 抛错，不落库）
        var tid = ResolveTenantOrThrow();

        // 检验单必须不合格（合格单无 SQE 节点）
        var pdRows = await _db.Ado.SqlQueryAsync<int?>(
            "SELECT pd FROM qms_qcp_inspbill WHERE id=@id AND tenant_id=@TenantId LIMIT 1",
            new List<SugarParameter> { new("@id", input.Id), new("@TenantId", tid) });
        if (pdRows.FirstOrDefault() != 1) throw Oops.Oh("仅不合格检验单(pd=1)可做 SQE 处置");

        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("当前用户没有待处理的 SQE 处置任务（需 SQE 角色成员）");
        if (myTask.NodeId != IqcInspBillFlowConst.NodeSqe) throw Oops.Oh("当前不在 SQE 处置节点");

        // 一单一有效处置
        var hasEffective = await _db.Queryable<AdoS5IqcSqeDisposition>()
            .Where(x => x.InspbillId == input.Id && x.Status == 1)
            .AnyAsync();
        if (hasEffective) throw Oops.Oh("该检验单已有有效 SQE 处置，不可重复提交");

        // 来源单号
        var srcRows = await _db.Ado.SqlQueryAsync<string>(
            "SELECT lydjbh FROM qms_qcp_inspbill WHERE id=@id AND tenant_id=@TenantId LIMIT 1",
            new List<SugarParameter> { new("@id", input.Id), new("@TenantId", tid) });

        var now = DateTime.Now;
        var disposition = new AdoS5IqcSqeDisposition
        {
            Id = YitIdHelper.NextId(),
            TenantId = tid,
            OrgId = inst.OrgId,
            InspbillId = input.Id,
            InspbillNo = billNo,
            SourceBillNo = srcRows.FirstOrDefault(),
            BizType = IqcInspBillFlowConst.BizType,
            FlowInstanceId = inst.Id,
            DispositionNo = $"SQE-{billNo}-{now:yyyyMMddHHmmss}",
            DispositionType = input.DispositionType,
            DispositionQty = input.DispositionQty,
            ConcessionQty = input.ConcessionQty,
            SelectionQty = input.SelectionQty,
            ScrapQty = input.ScrapQty,
            SupplierResponse = input.SupplierResponse,
            DispositionOpinion = input.DispositionOpinion,
            AttachmentJson = input.AttachmentJson,
            SqeUserId = _userManager.UserId,
            SqeUserName = _userManager.RealName ?? _userManager.Account,
            Status = 1,
            SubmittedAt = now,
            CreateTime = 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)
    {
        if (id <= 0) throw Oops.Oh("检验单 id 非法");
        var tid = ResolveTenantOrThrow();
        var rows = await _db.Ado.SqlQueryAsync<string>(
            "SELECT FBILLNO FROM qms_qcp_inspbill WHERE id=@id AND tenant_id=@TenantId LIMIT 1",
            new List<SugarParameter> { new("@id", id), new("@TenantId", 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 == IqcInspBillFlowConst.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 != IqcInspBillFlowConst.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<IqcFlowStateOutput> BuildStateAsync(long bizId)
    {
        var output = new IqcFlowStateOutput { BizId = bizId };
        var inst = await GetLatestInstanceAsync(bizId);

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

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

        // SQE 处置摘要（不合格单可能已有处置记录，任何状态都可展示）
        var disp = await _db.Queryable<AdoS5IqcSqeDisposition>()
            .Where(x => x.InspbillId == bizId)
            .OrderByDescending(x => x.Id)
            .FirstAsync();
        if (disp != null)
        {
            output.HasSqeDisposition = true;
            output.SqeDispositionId = disp.Id;
            output.SqeDispositionStatus = disp.Status;
            output.SqeDispositionType = disp.DispositionType;
        }

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

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

}