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

using Admin.NET.Plugin.AiDOP.Manufacturing.Dto;

namespace Admin.NET.Plugin.AiDOP.Manufacturing;

/// <summary>
/// S6 过程检验单 服务（Phase 1B）：生产指令 → 自动唯一解析过程检规 → 生成检验单 + 检规快照 → 只读详情。
///
/// prepare：入参仅 workOrderNo。后端自解析 CurrentTenant（AidopTenantScope）+ 加载生产指令（mdp_std_work_order_schedule）
///   → S6ProcessSpecResolver 按 (tenant, item_code, order_date) 唯一解析。
///   仅 MATCHED 才幂等生成/复用检验单 + 冻结检规快照（同一事务）；NO_MATCH/AMBIGUOUS/INVALID 一律不写库、原样返回状态。
/// 无人工检规选择；全程 tenant 显式过滤；快照生成后详情只读快照，不再回查 S0。
/// FACTORY_SCOPE = PARTIAL（S0 检规无 factory_id，安全边界为 Tenant；factory 仅随单据承载不做过滤）。
/// </summary>
[ApiDescriptionSettings(Order = 304, Description = "过程检验单")]
[Route("api/S6ProcessInspection")]
[NonUnify]
public class S6ProcessInspectionService : IDynamicApiController, ITransient
{
    private readonly ISqlSugarClient _db;
    private readonly UserManager _userManager;
    private readonly S6ProcessSpecResolver _resolver;

    public S6ProcessInspectionService(ISqlSugarClient db, UserManager userManager, S6ProcessSpecResolver resolver)
    {
        _db = db;
        _userManager = userManager;
        _resolver = resolver;
    }

    private long ResolveTenantOrThrow() => Infrastructure.AidopTenantScope.ResolveOrThrow(_userManager);

    /// <summary>
    /// 准备过程检验单：解析检规，MATCHED 则幂等生成/复用检验单 + 快照，返回 billId + status。
    /// </summary>
    [DisplayName("准备过程检验单")]
    [HttpPost("prepare")]
    public async Task<S6ProcessInspectionPrepareResult> Prepare([FromBody] S6ProcessInspectionPrepareInput input)
    {
        var res = new S6ProcessInspectionPrepareResult();
        if (input == null || string.IsNullOrWhiteSpace(input.WorkOrderNo))
        {
            res.Status = S6SpecResolveStatus.NoMatch;
            res.Message = "缺少工单编号。";
            return res;
        }

        var tid = ResolveTenantOrThrow();
        var wo = input.WorkOrderNo.Trim();

        // 加载生产指令（严格租户；跨租户/不存在 → 明确拒绝，不泄漏）
        var pi = await _db.Ado.SqlQuerySingleAsync<ProdInstrRow>(
            """
            SELECT work_order AS WorkOrder, lot_serial AS LotSerial, item_code AS ItemCode, item_name AS ItemName,
                   specification AS Specification, factory_id AS FactoryId, order_date AS OrderDate
            FROM mdp_std_work_order_schedule
            WHERE tenant_id=@TenantId AND work_order=@Wo LIMIT 1
            """,
            new List<SugarParameter> { new("@TenantId", tid), new("@Wo", wo) });
        if (pi == null)
        {
            res.Status = S6SpecResolveStatus.NoMatch;
            res.Message = "未找到该工单的生产指令。";
            return res;
        }

        // ReferenceDate 取检验时点(now)：过程检验在当前执行，应采用"检验时点当前有效"的检规；
        // 生产指令 OrderDate 是下单时点，可能早于检规生效日(sxrj)，用它会漏掉当前有效检规。（§9 明确说明）
        var refDate = DateTime.Now;
        var resolve = await _resolver.ResolveAsync(tid, pi.ItemCode, refDate);
        res.Status = resolve.Status;
        res.Message = resolve.Message;
        res.SpecCode = resolve.SpecCode;
        res.SpecVersion = resolve.SpecVersion;
        res.CandidateCount = resolve.CandidateCount;

        if (resolve.Status != S6SpecResolveStatus.Matched || resolve.CandidateCount != 1 || resolve.MatchedSpecId is not { } specId)
            return res; // 非唯一解析：不写库

        // 幂等：已有 active(DRAFT/ACTIVE) 检验单 → 复用
        var existingId = await _db.Ado.SqlQuerySingleAsync<long?>(
            """
            SELECT id FROM ado_s6_process_inspection_bill
            WHERE tenant_id=@TenantId AND work_order_no=@Wo AND inspection_status IN ('DRAFT','ACTIVE')
            ORDER BY id DESC LIMIT 1
            """,
            new List<SugarParameter> { new("@TenantId", tid), new("@Wo", wo) });
        if (existingId is { } eid && eid > 0)
        {
            res.BillId = eid;
            res.Reused = true;
            return res;
        }

        // 生成：检验单 + 快照头 + 快照明细（同一事务，任一失败全回滚）
        var uid = _userManager.UserId;
        var uname = _userManager.RealName ?? _userManager.Account;
        try
        {
            _db.Ado.BeginTran();

            await _db.Ado.ExecuteCommandAsync(
                """
                INSERT INTO ado_s6_process_inspection_bill
                (tenant_id, factory_id, work_order_no, lot_serial, item_code, item_name, specification,
                 spec_id, spec_code, spec_version, inspection_status, created_by, created_by_name)
                VALUES (@TenantId, @FactoryId, @Wo, @Lot, @ItemCode, @ItemName, @Spec,
                        @SpecId, @SpecCode, @SpecVersion, 'DRAFT', @Uid, @Uname)
                """,
                new List<SugarParameter>
                {
                    new("@TenantId", tid),
                    new("@FactoryId", (object?)pi.FactoryId ?? DBNull.Value),
                    new("@Wo", wo),
                    new("@Lot", (object?)pi.LotSerial ?? DBNull.Value),
                    new("@ItemCode", (object?)pi.ItemCode ?? DBNull.Value),
                    new("@ItemName", (object?)pi.ItemName ?? DBNull.Value),
                    new("@Spec", (object?)pi.Specification ?? DBNull.Value),
                    new("@SpecId", specId),
                    new("@SpecCode", (object?)resolve.SpecCode ?? DBNull.Value),
                    new("@SpecVersion", (object?)resolve.SpecVersion ?? DBNull.Value),
                    new("@Uid", (object?)uid ?? DBNull.Value),
                    new("@Uname", (object?)uname ?? DBNull.Value),
                });

            var billId = await _db.Ado.GetLongAsync("SELECT LAST_INSERT_ID()");

            await _db.Ado.ExecuteCommandAsync(
                """
                INSERT INTO ado_s6_process_inspection_snapshot_head
                (tenant_id, bill_id, spec_id, spec_code, spec_version, effective_date, item_code, specification, source_tenant_id)
                VALUES (@TenantId, @BillId, @SpecId, @SpecCode, @SpecVersion, @Eff, @ItemCode, @Spec, @TenantId)
                """,
                new List<SugarParameter>
                {
                    new("@TenantId", tid),
                    new("@BillId", billId),
                    new("@SpecId", specId),
                    new("@SpecCode", (object?)resolve.SpecCode ?? DBNull.Value),
                    new("@SpecVersion", (object?)resolve.SpecVersion ?? DBNull.Value),
                    new("@Eff", (object?)resolve.EffectiveDate ?? DBNull.Value),
                    new("@ItemCode", (object?)pi.ItemCode ?? DBNull.Value),
                    new("@Spec", (object?)pi.Specification ?? DBNull.Value),
                });

            var lineCount = await _db.Ado.ExecuteCommandAsync(
                """
                INSERT INTO ado_s6_process_inspection_snapshot_line
                (tenant_id, bill_id, source_line_id, inspection_item, process_code, process_name, method,
                 spec_value, tech_standard, lower_limit, upper_limit, inspection_frequency, result_type, sort_no)
                SELECT @TenantId, @BillId, z.id, z.jyxm, z.gxdh, z.gxmc, z.jyff,
                       z.jygg, z.jsbz, z.xx, z.sx, z.jypc, z.lrlx, NULL
                FROM qms_gcjygfzb z
                WHERE z.tenant_id=@TenantId AND z.glid=@SpecId
                """,
                new List<SugarParameter> { new("@TenantId", tid), new("@BillId", billId), new("@SpecId", specId) });

            if (lineCount <= 0)
                throw Oops.Oh("过程检验规范无有效明细，无法生成检验单。");

            _db.Ado.CommitTran();
            res.BillId = billId;
            res.Reused = false;
            return res;
        }
        catch
        {
            _db.Ado.RollbackTran();
            throw;
        }
    }

    /// <summary>过程检验单只读详情（单据 + 快照头 + 快照明细）。跨租户/不存在返回 null。</summary>
    [DisplayName("过程检验单详情")]
    [HttpGet("detail")]
    public async Task<S6ProcessInspectionDetailDto?> GetDetail([FromQuery] long billId)
    {
        if (billId <= 0) return null;
        var tid = ResolveTenantOrThrow();
        var pars = new List<SugarParameter> { new("@TenantId", tid), new("@BillId", billId) };

        var dto = await _db.Ado.SqlQuerySingleAsync<S6ProcessInspectionDetailDto>(
            """
            SELECT b.id AS BillId, b.work_order_no AS WorkOrderNo, b.lot_serial AS LotSerial, b.item_code AS ItemCode,
                   b.item_name AS ItemName, b.specification AS Specification, b.spec_id AS SpecId, b.spec_code AS SpecCode,
                   b.spec_version AS SpecVersion, h.effective_date AS EffectiveDate, b.inspection_status AS InspectionStatus,
                   b.created_by_name AS CreatedByName, b.create_time AS CreateTime
            FROM ado_s6_process_inspection_bill b
            LEFT JOIN ado_s6_process_inspection_snapshot_head h ON h.bill_id=b.id AND h.tenant_id=@TenantId
            WHERE b.tenant_id=@TenantId AND b.id=@BillId LIMIT 1
            """, pars);
        if (dto == null) return null;

        dto.Lines = await _db.Ado.SqlQueryAsync<S6ProcessInspectionSnapshotLineDto>(
            """
            SELECT id AS Id, inspection_item AS InspectionItem, process_code AS ProcessCode, process_name AS ProcessName,
                   method AS Method, spec_value AS SpecValue, tech_standard AS TechStandard, lower_limit AS LowerLimit,
                   upper_limit AS UpperLimit, inspection_frequency AS InspectionFrequency, result_type AS ResultType, sort_no AS SortNo
            FROM ado_s6_process_inspection_snapshot_line
            WHERE tenant_id=@TenantId AND bill_id=@BillId ORDER BY id
            """, pars);
        return dto;
    }

    private sealed class ProdInstrRow
    {
        public string? WorkOrder { get; set; }
        public string? LotSerial { get; set; }
        public string? ItemCode { get; set; }
        public string? ItemName { get; set; }
        public string? Specification { get; set; }
        public long? FactoryId { get; set; }
        public DateTime? OrderDate { get; set; }
    }
}