AiDOPWarehouse/server/Plugins/Admin.NET.Plugin.AiDOP/WorkOrder/WorkOrderBomUploadService.cs

using System.Globalization;
using Admin.NET.Plugin.AiDOP.Infrastructure;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Options;
using Yitter.IdGenerator;

namespace Admin.NET.Plugin.AiDOP.WorkOrder;

/// <summary>
/// 工单 BOM 上传服务 — 从 Excel 解析结果按（订单号+父物料号）匹配未下达工单，
/// 批量写入 ItemMaster + WorkOrdDetail。
/// 路由前缀：/api/WorkOrder/dispatch/bom/...
///
/// 【自动建单开关】当 <see cref="AidopBomUploadOptions.AutoCreateWhenUnmatched"/> = true（测试阶段）时，
/// 匹配不到订单/工单的组会自动创建销售订单(crm_seorder)与工单(WorkOrdMaster+mes_morder)后继续写入；
/// false（生产阶段，缺省）时只返回未匹配提示，不写入任何数据。
///
/// 【租户安全边界】需认证访问；租户一律经
/// <c>AidopTenantScope.ResolveOrThrow</c> 从认证后 JWT 解析。
/// </summary>
[ApiDescriptionSettings(Order = 258, Description = "工单BOM上传")]
[Route("api/WorkOrder")]
[NonUnify]
public class WorkOrderBomUploadService : IDynamicApiController, ITransient
{
    private readonly ISqlSugarClient _db;
    private readonly UserManager _userManager;
    private readonly ILogger<WorkOrderBomUploadService> _logger;
    private readonly IOptionsMonitor<AidopBomUploadOptions> _bomUploadOpt;

    public WorkOrderBomUploadService(
        ISqlSugarClient db,
        UserManager userManager,
        ILogger<WorkOrderBomUploadService> logger,
        IOptionsMonitor<AidopBomUploadOptions> bomUploadOpt)
    {
        _db = db;
        _userManager = userManager;
        _logger = logger;
        _bomUploadOpt = bomUploadOpt;
    }

    private long ResolveTenantId() => AidopTenantScope.ResolveOrThrow(_userManager);

    // ══════════════════════════════════════════════════════════════
    // POST /api/WorkOrder/dispatch/bom/check-materials
    // ══════════════════════════════════════════════════════════════
    /// <summary>校验 BOM 子物料是否在 ItemMaster 中存在。</summary>
    [DisplayName("BOM物料存在性校验")]
    [ApiDescriptionSettings(Name = "BomCheckMaterials"), HttpPost("dispatch/bom/check-materials")]
    public async Task<BomCheckResult> CheckMaterials([FromBody] BomCheckMaterialsInput input)
    {
        var tid = ResolveTenantId();
        if (input.Items == null || input.Items.Count == 0)
            throw Oops.Oh("BOM 物料列表为空");

        var itemNums = input.Items
            .Where(x => !string.IsNullOrWhiteSpace(x.ItemNum))
            .Select(x => x.ItemNum.Trim())
            .Distinct()
            .ToList();

        if (itemNums.Count == 0)
            throw Oops.Oh("BOM 中无有效的物料编码");

        // 查询本租户下已存在的物料编码
        var existingSet = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
        var pars = new List<SugarParameter> { new("@TenantId", tid) };
        for (var i = 0; i < itemNums.Count; i++)
            pars.Add(new SugarParameter($"@IN{i}", itemNums[i]));
        var inClause = string.Join(", ", Enumerable.Range(0, itemNums.Count).Select(i => $"@IN{i}"));

        var existing = await _db.Ado.SqlQueryAsync<string>(
            $"""
            SELECT DISTINCT ItemNum FROM ItemMaster
            WHERE tenant_id = @TenantId AND ItemNum IN ({inClause})
            """,
            pars);
        foreach (var e in existing)
            existingSet.Add(e);

        return new BomCheckResult
        {
            Existing = existingSet.ToList(),
            Missing = input.Items
                .Where(x => !string.IsNullOrWhiteSpace(x.ItemNum) && !existingSet.Contains(x.ItemNum.Trim()))
                .GroupBy(x => x.ItemNum.Trim())
                .Select(g => g.First())
                .ToList()
        };
    }

    // ══════════════════════════════════════════════════════════════
    // POST /api/WorkOrder/dispatch/bom/upload
    // ══════════════════════════════════════════════════════════════
    /// <summary>
    /// 写入 BOM：按（订单号+父物料号）匹配未下达工单，可选新建 ItemMaster 缺失物料，
    /// 然后 Upsert WorkOrdDetail。
    /// </summary>
    [DisplayName("BOM写入工单物料明细")]
    [ApiDescriptionSettings(Name = "BomUpload"), HttpPost("dispatch/bom/upload")]
    public async Task<BomUploadResult> Upload([FromBody] BomUploadInput input)
    {
        var tid = ResolveTenantId();
        if (input.Items == null || input.Items.Count == 0)
            throw Oops.Oh("BOM 物料列表为空");

        var account = _userManager.Account ?? "system";
        var factoryRefId = await ResolveFactoryRefIdAsync(tid);

        // 1) 查找哪些子物料需要新建（ItemMaster 存在性检查）
        var itemNums = input.Items
            .Where(x => !string.IsNullOrWhiteSpace(x.ItemNum))
            .Select(x => x.ItemNum.Trim())
            .Distinct()
            .ToList();

        var existingSet = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
        if (itemNums.Count > 0)
        {
            var pars = new List<SugarParameter> { new("@TenantId", tid) };
            for (var i = 0; i < itemNums.Count; i++)
                pars.Add(new SugarParameter($"@IN{i}", itemNums[i]));
            var inClause = string.Join(", ", Enumerable.Range(0, itemNums.Count).Select(i => $"@IN{i}"));
            var existing = await _db.Ado.SqlQueryAsync<string>(
                $"SELECT DISTINCT ItemNum FROM ItemMaster WHERE tenant_id = @TenantId AND ItemNum IN ({inClause})",
                pars);
            foreach (var e in existing)
                existingSet.Add(e);
        }

        var newItemsCount = 0;

        // 2) 按（SalesOrderNo, ParentItemNum）分组 → 每组对应一个工单
        var groups = input.Items
            .Where(x => !string.IsNullOrWhiteSpace(x.ItemNum)
                        && !string.IsNullOrWhiteSpace(x.SalesOrderNo)
                        && !string.IsNullOrWhiteSpace(x.ParentItemNum))
            .GroupBy(x => (SalesOrderNo: x.SalesOrderNo!.Trim(), ParentItemNum: x.ParentItemNum!.Trim()))
            .ToList();

        // 没有有效分组 key 的行视为无法匹配
        var unmatched = new List<string>();
        var noKeyItems = input.Items
            .Where(x => !string.IsNullOrWhiteSpace(x.ItemNum)
                        && (string.IsNullOrWhiteSpace(x.SalesOrderNo) || string.IsNullOrWhiteSpace(x.ParentItemNum)))
            .ToList();
        if (noKeyItems.Count > 0)
            unmatched.Add($"缺少订单号或父物料号：{noKeyItems.Count} 行");

        // 3) 预匹配：在写入之前先将所有分组匹配到工单，有未匹配则整体中止
        //    开关打开时，未匹配组转入 pendingCreate（事务内自动创建订单+工单后继续写入）
        var autoCreateWhenUnmatched = _bomUploadOpt.CurrentValue.AutoCreateWhenUnmatched;
        var matchedGroups = new List<(IGrouping<(string SalesOrderNo, string ParentItemNum), BomItemDto> Grp, WoInfo Wo)>();
        var pendingCreate = new List<(IGrouping<(string SalesOrderNo, string ParentItemNum), BomItemDto> Grp, string ContractNo, string ParentDescr)>();
        foreach (var grp in groups)
        {
            var woRow = await _db.Ado.SqlQuerySingleAsync<WoInfo>(
                """
                SELECT RecID AS RecId, WorkOrd, `Domain`, LOWER(TRIM(IFNULL(Status,''))) AS Status
                FROM WorkOrdMaster
                WHERE tenant_id = @TenantId
                  AND TRIM(IFNULL(SalesJob,'')) = @SalesOrderNo
                  AND TRIM(IFNULL(ItemNum,'')) = @ParentItemNum
                  AND LOWER(TRIM(IFNULL(Status,''))) = 'p'
                LIMIT 1
                """,
                new SugarParameter("@TenantId", tid),
                new SugarParameter("@SalesOrderNo", grp.Key.SalesOrderNo),
                new SugarParameter("@ParentItemNum", grp.Key.ParentItemNum));

            if (woRow == null)
            {
                if (autoCreateWhenUnmatched)
                {
                    // 提取组内首个非空的合同号/父物料描述，用于自动建单
                    var contractNo = grp.Select(x => x.ContractNo).FirstOrDefault(x => !string.IsNullOrWhiteSpace(x)) ?? string.Empty;
                    var parentDescr = grp.Select(x => x.ParentDescr).FirstOrDefault(x => !string.IsNullOrWhiteSpace(x)) ?? string.Empty;
                    pendingCreate.Add((grp, contractNo, parentDescr));
                }
                else
                {
                    unmatched.Add($"订单[{grp.Key.SalesOrderNo}] + 物料[{grp.Key.ParentItemNum}]");
                }
            }
            else
            {
                matchedGroups.Add((grp, woRow));
            }
        }

        // 有未匹配组（且开关关闭无法自动建单）→ 整体中止，不写入任何数据
        if (unmatched.Count > 0)
        {
            return new BomUploadResult
            {
                Inserted = 0, Updated = 0, NewItems = 0, Total = input.Items.Count,
                MatchedWorkOrders = 0, Unmatched = unmatched
            };
        }

        await _db.Ado.BeginTranAsync();
        try
        {
            // 3.5) 自动建单：开关打开时，为未匹配组创建销售订单+工单，纳入写入队列
            var createdOrders = 0;
            var createdWorkOrders = 0;
            foreach (var pc in pendingCreate)
            {
                var (woRow, orderCreated) = await EnsureOrderAndWorkOrderAsync(
                    tid, pc.Grp.Key.SalesOrderNo, pc.Grp.Key.ParentItemNum,
                    pc.ContractNo, pc.ParentDescr, factoryRefId, account);
                if (orderCreated) createdOrders++;
                createdWorkOrders++;
                matchedGroups.Add((pc.Grp, woRow));
            }
            // 4) 创建缺失物料到 ItemMaster
            if (input.CreateMissingItems)
            {
                var missingItems = input.Items
                    .Where(x => !string.IsNullOrWhiteSpace(x.ItemNum) && !existingSet.Contains(x.ItemNum.Trim()))
                    .GroupBy(x => x.ItemNum.Trim())
                    .Select(g => g.First())
                    .ToList();

                var now = DateTime.Now;
                // 获取一个默认 Domain（取第一个匹配工单的，或兜底 8010）
                var defaultDomain = "8010";
                foreach (var item in missingItems)
                {
                    var itemNum = item.ItemNum.Trim();
                    await _db.Ado.ExecuteCommandAsync(
                        """
                        INSERT IGNORE INTO ItemMaster (
                            tenant_id, ItemNum, Descr, Descr1, UM,
                            Status, IsActive, Domain, factory_ref_id,
                            CreateTime, CreateUser, UpdateTime, UpdateUser
                        ) VALUES (
                            @TenantId, @ItemNum, @Descr, @Descr1, @UM,
                            '', 1, @Domain, @FactoryRefId,
                            @Now, @User, @Now, @User
                        )
                        """,
                        new SugarParameter("@TenantId", tid),
                        new SugarParameter("@ItemNum", itemNum),
                        new SugarParameter("@Descr", item.Descr ?? string.Empty),
                        new SugarParameter("@Descr1", item.Descr1 ?? (object)DBNull.Value),
                        new SugarParameter("@UM", item.UM ?? (object)DBNull.Value),
                        new SugarParameter("@Domain", defaultDomain),
                        new SugarParameter("@FactoryRefId", factoryRefId),
                        new SugarParameter("@Now", now),
                        new SugarParameter("@User", account));
                    newItemsCount++;
                    existingSet.Add(itemNum);
                }
            }

            // 5) 逐组写入 WorkOrdDetail（已预匹配，无需再查）
            var inserted = 0;
            var updated = 0;
            var matchedWorkOrders = 0;

            foreach (var (grp, woRow) in matchedGroups)
            {
                var domain = string.IsNullOrWhiteSpace(woRow.Domain) ? "8010" : woRow.Domain;

                // 加载该工单已有的 WorkOrdDetail
                var existingDetails = await _db.Ado.SqlQueryAsync<ExistingDetailRow>(
                    """
                    SELECT RecID, ItemNum, QtyRequired
                    FROM WorkOrdDetail
                    WHERE tenant_id = @TenantId AND WorkOrd = @WorkOrd AND IFNULL(IsActive, 0) = 1
                    """,
                    new SugarParameter("@TenantId", tid),
                    new SugarParameter("@WorkOrd", woRow.WorkOrd));
                var existingMap = existingDetails.ToDictionary(x => x.ItemNum, x => x, StringComparer.OrdinalIgnoreCase);

                var line = existingDetails.Count + 1;
                var now2 = DateTime.Now;

                // 按子物料 ItemNum 去重（同一物料累加需求数量）
                var groupedItems = grp
                    .GroupBy(x => x.ItemNum.Trim())
                    .Select(g => new
                    {
                        ItemNum = g.Key,
                        Descr = g.First().Descr,
                        Descr1 = g.First().Descr1,
                        UM = g.First().UM,
                        QtyRequired = g.Sum(x => x.QtyRequired),
                        Op = g.First().Op
                    })
                    .ToList();

                foreach (var item in groupedItems)
                {
                    var itemNum = item.ItemNum.Trim();
                    if (existingMap.TryGetValue(itemNum, out var ex))
                    {
                        // 已有 → UPDATE QtyRequired
                        await _db.Ado.ExecuteCommandAsync(
                            """
                            UPDATE WorkOrdDetail
                            SET QtyRequired = @QtyRequired, UpdateUser = @User, UpdateTime = @Now
                            WHERE RecID = @RecID AND tenant_id = @TenantId
                            """,
                            new SugarParameter("@QtyRequired", item.QtyRequired),
                            new SugarParameter("@User", account),
                            new SugarParameter("@Now", now2),
                            new SugarParameter("@RecID", ex.RecID),
                            new SugarParameter("@TenantId", tid));
                        updated++;
                    }
                    else
                    {
                        // 新增 → INSERT
                        await _db.Ado.ExecuteCommandAsync(
                            """
                            INSERT INTO WorkOrdDetail (
                                WorkOrdMasterRecID, `Domain`, WorkOrd, LineNum, ItemNum, Op,
                                Location, QtyRequired, QtyPosted, UM, IsActive, IsConfirm,
                                CreateUser, CreateTime, UpdateUser, UpdateTime, tenant_id
                            ) VALUES (
                                @MasterRecId, @Domain, @WorkOrd, @LineNum, @ItemNum, @Op,
                                @Location, @QtyRequired, 0, @UM, 1, 0,
                                @User, @Now, @User, @Now, @TenantId
                            )
                            """,
                            new SugarParameter("@MasterRecId", woRow.RecId),
                            new SugarParameter("@Domain", domain),
                            new SugarParameter("@WorkOrd", woRow.WorkOrd),
                            new SugarParameter("@LineNum", line),
                            new SugarParameter("@ItemNum", itemNum),
                            new SugarParameter("@Op", item.Op),
                            new SugarParameter("@Location", DBNull.Value),
                            new SugarParameter("@QtyRequired", item.QtyRequired),
                            new SugarParameter("@UM", item.UM ?? (object)DBNull.Value),
                            new SugarParameter("@User", account),
                            new SugarParameter("@Now", now2),
                            new SugarParameter("@TenantId", tid));
                        inserted++;
                        line++;
                    }
                }

                matchedWorkOrders++;
                _logger.LogInformation(
                    "[BomUpload] workOrd={WorkOrd} salesOrderNo={SalesOrderNo} parentItem={ParentItem} items={Items}",
                    woRow.WorkOrd, grp.Key.SalesOrderNo, grp.Key.ParentItemNum, groupedItems.Count);
            }

            await _db.Ado.CommitTranAsync();

            _logger.LogInformation(
                "[BomUpload] tenantId={TenantId} matched={Matched} inserted={Inserted} updated={Updated} newItems={NewItems} createdOrders={CreatedOrders} createdWorkOrders={CreatedWorkOrders} unmatched={Unmatched}",
                tid, matchedWorkOrders, inserted, updated, newItemsCount, createdOrders, createdWorkOrders, unmatched.Count);

            return new BomUploadResult
            {
                Inserted = inserted,
                Updated = updated,
                NewItems = newItemsCount,
                Total = input.Items.Count,
                MatchedWorkOrders = matchedWorkOrders,
                Unmatched = unmatched,
                CreatedOrders = createdOrders,
                CreatedWorkOrders = createdWorkOrders
            };
        }
        catch
        {
            await _db.Ado.RollbackTranAsync();
            throw;
        }
    }

    /// <summary>获取租户的 factory_ref_id（取 ItemMaster 中已有的最小 factory_ref_id，缺省 1）。</summary>
    private async Task<long> ResolveFactoryRefIdAsync(long tenantId)
    {
        var val = await _db.Ado.GetIntAsync(
            """
            SELECT IFNULL(MIN(factory_ref_id), 1) FROM ItemMaster
            WHERE tenant_id = @TenantId AND factory_ref_id > 0
            LIMIT 1
            """,
            new SugarParameter("@TenantId", tenantId));
        return val <= 0 ? 1 : val;
    }

    /// <summary>
    /// 自动建单（测试阶段开关）：销售订单不存在则创建 crm_seorder，
    /// 随后创建未下达工单（WorkOrdMaster Status='p' + mes_morder），返回新工单信息。
    /// </summary>
    private async Task<(WoInfo Wo, bool OrderCreated)> EnsureOrderAndWorkOrderAsync(
        long tenantId,
        string salesOrderNo,
        string parentItemNum,
        string contractNo,
        string parentDescr,
        long factoryRefId,
        string account)
    {
        var now = DateTime.Now;

        // 1) 销售订单存在性检查（已存在只建工单，不重建订单）
        var orderId = await _db.Ado.GetLongAsync(
            """
            SELECT Id FROM crm_seorder
            WHERE tenant_id = @TenantId
              AND TRIM(IFNULL(bill_no,'')) = @BillNo
              AND IFNULL(IsDeleted,0) = 0
            LIMIT 1
            """,
            new List<SugarParameter>
            {
                new("@TenantId", tenantId),
                new("@BillNo", salesOrderNo)
            });

        var orderCreated = false;
        if (orderId <= 0)
        {
            orderId = YitIdHelper.NextId();
            await _db.Ado.ExecuteCommandAsync(
                """
                INSERT INTO crm_seorder (
                    Id, bill_no, order_type, urgent, bill_from, flowstate,
                    create_by_name, create_time, update_by_name, update_time,
                    tenant_id, factory_id, IsDeleted, closed
                ) VALUES (
                    @Id, @BillNo, 1, 0, @BillFrom, 'BOM导入',
                    @User, @Now, @User, @Now,
                    @TenantId, @FactoryId, 0, 0
                )
                """,
                new SugarParameter("@Id", orderId),
                new SugarParameter("@BillNo", salesOrderNo),
                new SugarParameter("@BillFrom", string.IsNullOrWhiteSpace(contractNo) ? (object)DBNull.Value : contractNo.Trim()),
                new SugarParameter("@User", account),
                new SugarParameter("@Now", now),
                new SugarParameter("@TenantId", tenantId),
                new SugarParameter("@FactoryId", factoryRefId));
            orderCreated = true;
        }

        // 2) 生成工单号并创建未下达工单（Status='p'，与 BOM 匹配口径一致）
        var workOrd = await GenerateWorkOrdNoAsync(tenantId);
        var domain = await ResolveDomainAsync(tenantId);
        await _db.Ado.ExecuteCommandAsync(
            """
            INSERT INTO WorkOrdMaster (
                `Domain`, WorkOrd, ItemNum, ItemName, Status, Typed,
                QtyOrded, QtyCompleted, LbrVar, OrdDate, Priority, Urgent,
                SalesJob, BusinessID, CreateUser, CreateTime, UpdateUser, UpdateTime,
                IsActive, IsConfirm, tenant_id, Remark
            ) VALUES (
                @Domain, @WorkOrd, @ItemNum, @ItemName, 'p', 'M',
                1, 0, 0, @OrdDate, 0, 0,
                @SalesJob, @BusinessId, @User, @Now, @User, @Now,
                1, 0, @TenantId, @Remark
            )
            """,
            new SugarParameter("@Domain", domain),
            new SugarParameter("@WorkOrd", workOrd),
            new SugarParameter("@ItemNum", parentItemNum),
            new SugarParameter("@ItemName", string.IsNullOrWhiteSpace(parentDescr) ? string.Empty : parentDescr.Trim()),
            new SugarParameter("@OrdDate", now.Date),
            new SugarParameter("@SalesJob", salesOrderNo),
            new SugarParameter("@BusinessId", orderId),
            new SugarParameter("@User", account),
            new SugarParameter("@Now", now),
            new SugarParameter("@TenantId", tenantId),
            new SugarParameter("@Remark", "BOM上传自动建单"));

        var recId = await _db.Ado.GetLongAsync(
            "SELECT RecID FROM WorkOrdMaster WHERE tenant_id = @TenantId AND WorkOrd = @WorkOrd LIMIT 1",
            new List<SugarParameter>
            {
                new("@TenantId", tenantId),
                new("@WorkOrd", workOrd)
            });

        // 3) 同步创建 mes_morder（齐套检查/下达流程依赖）
        await _db.Ado.ExecuteCommandAsync(
            """
            INSERT INTO mes_morder (
                Id, morder_no, morder_type, morder_date, morder_state,
                product_code, product_name, need_number, morder_production_number,
                MaterialSituation, urgent, create_by_name, create_time, update_by_name, update_time,
                tenant_id, factory_id, company_id, IsDeleted
            ) VALUES (
                @Id, @MorderNo, '生产工单', @Now, '新建',
                @ProductCode, @ProductName, 1, 1,
                '待检查', 0, @User, @Now, @User, @Now,
                @TenantId, @FactoryId, @FactoryId, 0
            )
            """,
            new SugarParameter("@Id", YitIdHelper.NextId()),
            new SugarParameter("@MorderNo", workOrd),
            new SugarParameter("@Now", now),
            new SugarParameter("@ProductCode", parentItemNum),
            new SugarParameter("@ProductName", string.IsNullOrWhiteSpace(parentDescr) ? string.Empty : parentDescr.Trim()),
            new SugarParameter("@User", account),
            new SugarParameter("@TenantId", tenantId),
            new SugarParameter("@FactoryId", factoryRefId));

        return (new WoInfo { RecId = recId, WorkOrd = workOrd, Domain = domain, Status = "p" }, orderCreated);
    }

    /// <summary>生成 M5 流水工单号（与 OrderWorkOrderGenerationService 同规则）。</summary>
    private async Task<string> GenerateWorkOrdNoAsync(long tenantId)
    {
        const string sql = """
            SELECT IFNULL(MAX(CAST(SUBSTRING(TRIM(WorkOrd), 3) AS UNSIGNED)), 0)
            FROM WorkOrdMaster
            WHERE tenant_id = @TenantId
              AND TRIM(WorkOrd) REGEXP '^M5[0-9]+$'
            """;
        var maxSeq = await _db.Ado.GetIntAsync(sql, new SugarParameter("@TenantId", tenantId));
        for (var attempt = 0; attempt < 5; attempt++)
        {
            var next = maxSeq + 1 + attempt;
            var candidate = "M5" + next.ToString("D8", CultureInfo.InvariantCulture);
            var dup = await _db.Ado.GetIntAsync(
                "SELECT COUNT(*) FROM WorkOrdMaster WHERE tenant_id = @TenantId AND WorkOrd = @WorkOrd",
                new SugarParameter("@TenantId", tenantId),
                new SugarParameter("@WorkOrd", candidate));
            if (dup == 0)
                return candidate;
        }

        throw Oops.Oh("生成工单号失败：流水号冲突，请重试");
    }

    /// <summary>解析 Domain：取本租户现有工单中出现次数最多的 Domain，缺省 8010。</summary>
    private async Task<string> ResolveDomainAsync(long tenantId)
    {
        var fallback = await _db.Ado.GetStringAsync(
            """
            SELECT `Domain` FROM WorkOrdMaster
            WHERE tenant_id = @TenantId
              AND `Domain` IS NOT NULL AND TRIM(`Domain`) <> ''
            GROUP BY `Domain`
            ORDER BY COUNT(*) DESC
            LIMIT 1
            """,
            new SugarParameter("@TenantId", tenantId));
        if (!string.IsNullOrWhiteSpace(fallback))
            return fallback.Trim();

        return "8010";
    }

    private sealed class WoInfo
    {
        public long RecId { get; set; }
        public string WorkOrd { get; set; } = string.Empty;
        public string? Domain { get; set; }
        public string? Status { get; set; }
    }

    private sealed class ExistingDetailRow
    {
        public long RecID { get; set; }
        public string ItemNum { get; set; } = string.Empty;
        public decimal QtyRequired { get; set; }
    }
}