AiDOPWarehouse/server/Plugins/Admin.NET.Plugin.AiDOP/Production/ScheduleExceptionService.cs

using Yitter.IdGenerator;

namespace Admin.NET.Plugin.AiDOP.Production;

/// <summary>
/// 排产异常记录服务 🏭
/// 路由前缀：/api/Production/schedule-exception/...
///
/// 【租户安全边界】租户一律经 <see cref="AidopTenantScope.ResolveOrThrow"/> 从认证后 JWT 解析，
/// 无有效租户即拒绝，不读前端 tenantId、无默认回退（原实现：类级 <c>[AllowAnonymous]</c> + 宽松解析，
/// 未认证方可携带 <c>?tenantId=&lt;任意租户&gt;</c> 读写该租户数据）。
/// </summary>
[ApiDescriptionSettings(Order = 267, Description = "排产异常记录")]
[Route("api/Production")]
[NonUnify]
public class ScheduleExceptionService : IDynamicApiController, ITransient
{
    private const string C = "utf8mb4_general_ci";

    private readonly ISqlSugarClient _db;
    private readonly SqlSugarRepository<ScheduleExceptionMaster> _rep;
    private readonly UserManager _userManager;

    public ScheduleExceptionService(ISqlSugarClient db, SqlSugarRepository<ScheduleExceptionMaster> rep, UserManager userManager)
    {
        _db = db;
        _rep = rep;
        _userManager = userManager;
    }

    // ══════════════════════════════════════════════════════════════
    // 列表 GET /api/Production/schedule-exception/list
    // ══════════════════════════════════════════════════════════════
    /// <summary>排产异常分页列表（ScheduleExceptionMaster + ItemMaster.Descr1）</summary>
    [DisplayName("排产异常记录列表")]
    [HttpGet("schedule-exception/list")]
    public async Task<object> GetList([FromQuery] ScheduleExceptionListInput input)
    {
        var tenantId = AidopTenantScope.ResolveOrThrow(_userManager);
        var pars = new List<SugarParameter> { new("@TenantId", tenantId) };
        var inner = new List<string> { "sm.tenant_id = @TenantId" };

        if (!string.IsNullOrWhiteSpace(input.OptTime))
        {
            inner.Add($"(CAST(sm.OptTime AS CHAR(50)) COLLATE {C}) LIKE @OptTimeLike");
            pars.Add(new SugarParameter("@OptTimeLike", $"%{input.OptTime.Trim()}%"));
        }
        if (!string.IsNullOrWhiteSpace(input.WorkOrd))
        {
            inner.Add($"(sm.WorkOrd COLLATE {C}) LIKE @WorkOrd");
            pars.Add(new SugarParameter("@WorkOrd", $"%{input.WorkOrd.Trim()}%"));
        }
        if (!string.IsNullOrWhiteSpace(input.ItemNum))
        {
            inner.Add($"(sm.ItemNum COLLATE {C}) = @ItemNumEq");
            pars.Add(new SugarParameter("@ItemNumEq", input.ItemNum.Trim()));
        }

        var baseSql = BuildListBaseSql(string.Join(" AND ", inner));
        var offset = (input.Page - 1) * input.PageSize;

        var total = await _db.Ado.GetIntAsync($"SELECT COUNT(*) FROM ({baseSql}) AS t", pars);
        var list = await _db.Ado.SqlQueryAsync<ScheduleExceptionListRow>(
            $"SELECT * FROM ({baseSql}) AS t ORDER BY t.Id DESC LIMIT {input.PageSize} OFFSET {offset}", pars);

        return new { total, page = input.Page, pageSize = input.PageSize, list };
    }

    private static string BuildListBaseSql(string innerWhere)
    {
        const string coll = "utf8mb4_general_ci";
        return $"""
        SELECT
            sm.RecID       AS Id,
            sm.`Domain`    AS Domain,
            sm.OptTime     AS OptTime,
            sm.WorkOrd     AS WorkOrd,
            sm.ItemNum     AS ItemNum,
            im.Descr1      AS Descr1,
            sm.Remark      AS Remark,
            sm.Type        AS Type
        FROM ScheduleExceptionMaster sm
        LEFT JOIN ItemMaster im
            ON (sm.`Domain` COLLATE {coll}) = (im.`Domain` COLLATE {coll})
            AND (sm.ItemNum COLLATE {coll}) = (im.ItemNum COLLATE {coll})
            AND im.tenant_id = @TenantId
        WHERE {innerWhere}
        """;
    }

    // ══════════════════════════════════════════════════════════════
    // 详情 GET /api/Production/schedule-exception/{id}
    // ══════════════════════════════════════════════════════════════
    /// <summary>排产异常详情</summary>
    [DisplayName("排产异常记录详情")]
    [HttpGet("schedule-exception/{id:long}")]
    public async Task<object> GetDetail(long id)
    {
        var tenantId = AidopTenantScope.ResolveOrThrow(_userManager);
        var e = await _rep.GetFirstAsync(u => u.RecID == id && u.TenantId == tenantId)
                ?? throw Oops.Oh("记录不存在");
        return new
        {
            id = e.RecID,
            domain = e.Domain,
            workOrd = e.WorkOrd,
            itemNum = e.ItemNum,
            remark = e.Remark,
            type = e.Type,
            optTime = e.OptTime,
            createTime = e.CreateTime
        };
    }

    // ══════════════════════════════════════════════════════════════
    // 保存 POST /api/Production/schedule-exception/save
    // ══════════════════════════════════════════════════════════════
    /// <summary>保存排产异常（新增或编辑）</summary>
    [DisplayName("保存排产异常记录")]
    [ApiDescriptionSettings(Name = "SaveScheduleException"), HttpPost("schedule-exception/save")]
    public async Task<object> Save([FromBody] ScheduleExceptionSaveInput input)
    {
        var tenantId = AidopTenantScope.ResolveOrThrow(_userManager);
        if (input.Id is null or 0)
        {
            var entity = new ScheduleExceptionMaster
            {
                RecID = YitIdHelper.NextId(),
                Domain = input.Domain.Trim(),
                WorkOrd = input.WorkOrd.Trim(),
                ItemNum = input.ItemNum.Trim(),
                Remark = input.Remark?.Trim(),
                Type = input.Type?.Trim(),
                OptTime = input.OptTime ?? DateTime.Now,
                CreateTime = input.CreateTime ?? DateTime.Now,
                TenantId = tenantId
            };
            await _rep.InsertAsync(entity);
            return new { id = entity.RecID, message = "新增成功" };
        }

        var exist = await _rep.GetFirstAsync(u => u.RecID == input.Id!.Value && u.TenantId == tenantId)
                    ?? throw Oops.Oh("记录不存在");
        exist.Domain = input.Domain.Trim();
        exist.WorkOrd = input.WorkOrd.Trim();
        exist.ItemNum = input.ItemNum.Trim();
        exist.Remark = input.Remark?.Trim();
        exist.Type = input.Type?.Trim();
        if (input.OptTime.HasValue) exist.OptTime = input.OptTime;
        if (input.CreateTime.HasValue) exist.CreateTime = input.CreateTime;
        await _rep.UpdateAsync(exist);
        return new { id = exist.RecID, message = "编辑成功" };
    }

    // ══════════════════════════════════════════════════════════════
    // 删除 POST /api/Production/schedule-exception/delete/{id}
    // ══════════════════════════════════════════════════════════════
    /// <summary>删除排产异常</summary>
    [DisplayName("删除排产异常记录")]
    [HttpPost("schedule-exception/delete/{id:long}")]
    public async Task<object> Delete(long id)
    {
        var tenantId = AidopTenantScope.ResolveOrThrow(_userManager);
        var n = await _db.Ado.ExecuteCommandAsync(
            "DELETE FROM ScheduleExceptionMaster WHERE RecID = @Id AND tenant_id = @TenantId",
            new List<SugarParameter> { new("@Id", id), new("@TenantId", tenantId) });
        if (n == 0)
            throw Oops.Oh("记录不存在");
        return new { message = "删除成功" };
    }

    private sealed class ScheduleExceptionListRow
    {
        public long Id { get; set; }
        public string? Domain { get; set; }
        public DateTime? OptTime { get; set; }
        public string? WorkOrd { get; set; }
        public string? ItemNum { get; set; }
        public string? Descr1 { get; set; }
        public string? Remark { get; set; }
        public string? Type { get; set; }
    }
}