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

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

namespace Admin.NET.Plugin.AiDOP.Manufacturing;

/// <summary>
/// S6 过程检验单（IPQC）不合格质量处置服务（N3_QUALITY_DISPOSITION）。
///
/// 整批不合格检验单经主管 N2 判定后进入 N3；质量工程师提交处置方案 → 写 ado_s6_ipqc_quality_disposition + 推进 N3→end。
/// 仅"记录处置结论"（disposition_type=REWORK/CONCESSION/SCRAP/OTHER）；
/// 不写 qms_gcjyd/qms_gcjydzb、不写库存/生产/仓储、不产生返工/报废/入出库实际动作、不做附件上传。
/// 一单一有效处置（inspection_id 唯一 + status=1 校验）；正常鉴权，权限以当前用户 N3 pending task 归属为准。
/// 职责分离：本服务管处置数据；N1/N2 流程见 IpqcInspectionFlowService。
/// </summary>
[ApiDescriptionSettings(Order = 313, Description = "过程检验单质量处置")]
[Route("api/IpqcInspectionDisposition")]
[NonUnify]
public class IpqcInspectionDispositionService : IDynamicApiController, ITransient
{
    private static readonly string[] DispositionTypes =
    {
        IpqcInspectionFlowConst.DispTypeRework,
        IpqcInspectionFlowConst.DispTypeConcession,
        IpqcInspectionFlowConst.DispTypeScrap,
        IpqcInspectionFlowConst.DispTypeOther,
    };

    /// <summary>主/系统租户哨兵：超管未选择目标租户时其 JWT TenantId 即此值，拒绝作为业务租户。</summary>
    private const long MainTenantId = 1300000000001L;

    private readonly ISqlSugarClient _db;
    private readonly FlowEngineService _flowEngine;
    private readonly UserManager _userManager;

    public IpqcInspectionDispositionService(ISqlSugarClient db, FlowEngineService flowEngine, UserManager userManager)
    {
        _db = db;
        _flowEngine = flowEngine;
        _userManager = userManager;
    }

    /// <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>
    /// 质量处置详情（只读，供前端展示已提交处置）。查不到返回 null。
    /// </summary>
    [DisplayName("过程检验单质量处置详情")]
    [HttpGet("state")]
    public async Task<IpqcDispositionOutput?> GetState([FromQuery] long id)
    {
        if (id <= 0) return null;
        // 严格租户隔离：ClearFilter 移除框架租户过滤器后，必须补 TenantId 谓词，防止跨租户读他租户处置。
        var tid = ResolveTenantOrThrow();
        return await _db.Queryable<AdoS6IpqcQualityDisposition>()
            .ClearFilter()
            .Where(x => x.InspectionId == id && x.TenantId == tid && x.Status == 1)
            .OrderByDescending(x => x.Id)
            .Select(x => new IpqcDispositionOutput
            {
                Id = x.Id,
                InspectionId = x.InspectionId,
                InspectionNo = x.InspectionNo,
                DispositionNo = x.DispositionNo,
                DispositionType = x.DispositionType,
                DispositionQty = x.DispositionQty,
                ReworkQty = x.ReworkQty,
                ConcessionQty = x.ConcessionQty,
                ScrapQty = x.ScrapQty,
                DispositionOpinion = x.DispositionOpinion,
                ResponsibilityDept = x.ResponsibilityDept,
                ResponsibleUser = x.ResponsibleUser,
                Status = x.Status,
                SubmittedByName = x.SubmittedByName,
                SubmittedAt = x.SubmittedAt,
            })
            .FirstAsync();
    }

    /// <summary>
    /// 质量工程师提交处置方案（写处置表 + 推进 N3→end）。仅记录方案，不触发库存/生产/仓储动作。
    /// </summary>
    [DisplayName("质量工程师提交处置")]
    [HttpPost("submit")]
    public async Task<IpqcDispositionOutput?> Submit([FromBody] IpqcSubmitDispositionInput input)
    {
        var billNo = await EnsureBillExistsAsync(input.Id);
        // 写库前严格解析可信租户（无 Token / 超管未选主租户 → 抛错，不落库、不查他租户）。
        var tid = ResolveTenantOrThrow();

        // 参数校验
        var type = (input.DispositionType ?? string.Empty).Trim().ToUpperInvariant();
        if (!DispositionTypes.Contains(type))
            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 sub = (input.ReworkQty ?? 0) + (input.ConcessionQty ?? 0) + (input.ScrapQty ?? 0);
        if (input.DispositionQty.HasValue && sub > input.DispositionQty.Value)
            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("当前用户没有待处理的质量处置任务（需质量工程师角色成员）");
        if (myTask.NodeId != IpqcInspectionFlowConst.NodeDisposition) throw Oops.Oh("当前不在质量处置节点");

        // 一单一有效处置（ClearFilter 后显式补 TenantId 谓词，防止跨租户误判/命中）
        var hasEffective = await _db.Queryable<AdoS6IpqcQualityDisposition>()
            .ClearFilter()
            .AnyAsync(x => x.InspectionId == input.Id && x.TenantId == tid && x.Status == 1);
        if (hasEffective) throw Oops.Oh("该检验单已有有效质量处置，不可重复提交");

        var now = DateTime.Now;
        var userName = _userManager.RealName ?? _userManager.Account;
        var disposition = new AdoS6IpqcQualityDisposition
        {
            Id = YitIdHelper.NextId(),
            TenantId = tid,
            OrgId = inst.OrgId,
            InspectionId = input.Id,
            InspectionNo = billNo,
            BizType = IpqcInspectionFlowConst.BizType,
            FlowInstanceId = inst.Id,
            DispositionNo = $"IPQCDISP-{billNo}-{now:yyyyMMddHHmmss}",
            DispositionType = type,
            DispositionQty = input.DispositionQty,
            ReworkQty = input.ReworkQty,
            ConcessionQty = input.ConcessionQty,
            ScrapQty = input.ScrapQty,
            DispositionOpinion = input.DispositionOpinion,
            ResponsibilityDept = input.ResponsibilityDept,
            ResponsibleUser = input.ResponsibleUser,
            Status = 1,
            SubmittedBy = _userManager.UserId,
            SubmittedByName = userName,
            SubmittedAt = now,
            RowVersion = 1,
            CreateTime = now,
        };

        var tran = await _db.AsTenant().UseTranAsync(async () =>
        {
            await _db.Insertable(disposition).ExecuteCommandAsync();
            // 更新扩展表业务状态 DISPOSED（不回写 qms_gcjyd.status）
            await _db.Ado.ExecuteCommandAsync(
                "UPDATE ado_s6_ipqc_inspection_flow_state SET business_status=@st, current_node=NULL, UpdateTime=@now WHERE inspection_id=@id AND tenant_id=@tid AND IsDelete=0",
                new List<SugarParameter>
                {
                    new("@st", IpqcInspectionFlowConst.StatusDisposed),
                    new("@now", now),
                    new("@id", input.Id),
                    new("@tid", tid),
                });
            // 推进 N3 → end
            await _flowEngine.Approve(myTask.Id, input.Comment);
        });
        if (!tran.IsSuccess) throw tran.ErrorException;

        return await GetState(input.Id);
    }

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

    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();
    }

    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();
    }

    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();
    }
}