AiDOPWarehouse/server/Plugins/Admin.NET.Plugin.AiDOP/Order/LinkagePlanService.cs

namespace Admin.NET.Plugin.AiDOP.Order;

/// <summary>
/// 计划联动看板服务
/// 路由前缀：/api/Order/linkageplan/...
/// </summary>
[ApiDescriptionSettings(Order = 250, Description = "计划联动看板")]
[Route("api/Order")]
[AllowAnonymous]
[NonUnify]
public class LinkagePlanService : IDynamicApiController, ITransient
{
    private readonly ISqlSugarClient _db;
    private readonly SqlSugarRepository<LinkagePlan> _linkagePlanRep;
    private readonly UserManager _userManager;
    private readonly S1MdpSyncTransformService _s1MdpSyncTransformService;

    public LinkagePlanService(
        ISqlSugarClient db,
        SqlSugarRepository<LinkagePlan> linkagePlanRep,
        UserManager userManager,
        S1MdpSyncTransformService s1MdpSyncTransformService)
    {
        _db = db;
        _linkagePlanRep = linkagePlanRep;
        _userManager = userManager;
        _s1MdpSyncTransformService = s1MdpSyncTransformService;
    }

    [DisplayName("获取计划联动看板列表")]
    [HttpGet("linkageplan/list")]
    public async Task<object> GetLinkagePlanList([FromQuery] LinkagePlanListInput input)
    {
        var tenantId = _userManager.TenantId;
        var q = _db.Queryable<LinkagePlan>()
            .Where(u => u.TenantId == tenantId)
            .WhereIF(!string.IsNullOrWhiteSpace(input.BillNo), u => u.BillNo != null && u.BillNo.Contains(input.BillNo!.Trim()))
            .WhereIF(!string.IsNullOrWhiteSpace(input.CustomNo), u => u.CustomNo != null && u.CustomNo.Contains(input.CustomNo!.Trim()))
            .WhereIF(!string.IsNullOrWhiteSpace(input.OrderType), u => u.OrderType == input.OrderType!.Trim())
            .WhereIF(!string.IsNullOrWhiteSpace(input.ItemNumber), u => u.ItemNumber == input.ItemNumber!.Trim());

        var paged = await q
            .OrderBy(u => u.BillNo)
            .OrderBy(u => u.ItemNumber)
            .OrderBy(u => u.LevelNum)
            .OrderBy("CASE WHEN type='计划' THEN 1 WHEN type='实际' THEN 2 WHEN type='偏差' THEN 3 ELSE 4 END")
            .ToPagedListAsync(input.Page, input.PageSize);

        var list = paged.Items.Select(u => new
        {
            id = u.Id,
            billNo = u.BillNo,
            customNo = u.CustomNo,
            orderType = u.OrderType,
            itemNumber = u.ItemNumber,
            descr = u.Descr,
            descr1 = u.Descr1,
            itemType = u.ItemType,
            qty = u.Qty,
            updateTime = u.UpdateTime?.ToString("yyyy-MM-dd"),
            sysCapacityDate = u.SysCapacityDate?.ToString("yyyy-MM-dd"),
            type = u.Type,
            bomStart = u.BomStart,
            bomEnd = u.BomEnd,
            lineStart = u.LineStart,
            lineEnd = u.LineEnd,
            productStart = u.ProductStart,
            productEnd = u.ProductEnd,
            needTime = u.NeedTime,
            sysMaterialDate = u.SysMaterialDate,
            cgNeedTime = u.CgNeedTime,
            cgEnd = u.CgEnd,
            blStart = u.BlStart,
            blEnd = u.BlEnd,
            startTime = u.StartTime,
            endTime = u.EndTime,
            ipqcJyStart = u.IpqcJyStart,
            ipqcJyEnd = u.IpqcJyEnd,
            fqcJyStart = u.FqcJyStart,
            fqcJyEnd = u.FqcJyEnd,
            rkStart = u.RkStart,
            rkEnd = u.RkEnd,
            fyStartTime = u.FyStartTime,
            fyEndTime = u.FyEndTime,
            levelNum = u.LevelNum,
            background = u.Background,
            businessId = u.BusinessId,
        }).ToList();

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

    [DisplayName("获取计划联动看板详情")]
    [HttpGet("linkageplan/{id:long}")]
    public async Task<object> GetLinkagePlanDetail(long id)
    {
        var tenantId = _userManager.TenantId;
        var m = await _linkagePlanRep.GetFirstAsync(u => u.Id == id && u.TenantId == tenantId)
                ?? throw Oops.Oh("计划联动记录不存在");

        return new
        {
            id = m.Id,
            billNo = m.BillNo,
            customNo = m.CustomNo,
            orderType = m.OrderType,
            itemNumber = m.ItemNumber,
            descr = m.Descr,
            descr1 = m.Descr1,
            itemType = m.ItemType,
            qty = m.Qty,
            updateTime = m.UpdateTime?.ToString("yyyy-MM-dd HH:mm:ss"),
            sysCapacityDate = m.SysCapacityDate?.ToString("yyyy-MM-dd HH:mm:ss"),
            type = m.Type,
            bomStart = m.BomStart,
            bomEnd = m.BomEnd,
            lineStart = m.LineStart,
            lineEnd = m.LineEnd,
            productStart = m.ProductStart,
            productEnd = m.ProductEnd,
            needTime = m.NeedTime,
            sysMaterialDate = m.SysMaterialDate,
            cgNeedTime = m.CgNeedTime,
            cgEnd = m.CgEnd,
            blStart = m.BlStart,
            blEnd = m.BlEnd,
            startTime = m.StartTime,
            endTime = m.EndTime,
            ipqcJyStart = m.IpqcJyStart,
            ipqcJyEnd = m.IpqcJyEnd,
            fqcJyStart = m.FqcJyStart,
            fqcJyEnd = m.FqcJyEnd,
            rkStart = m.RkStart,
            rkEnd = m.RkEnd,
            fyStartTime = m.FyStartTime,
            fyEndTime = m.FyEndTime,
            levelNum = m.LevelNum,
            background = m.Background,
        };
    }

    [DisplayName("刷新计划联动数据")]
    [HttpPost("linkageplan/refresh")]
    public async Task<object> RefreshLinkagePlanData()
    {
        try
        {
            var result = await _s1MdpSyncTransformService.RunFullAsync(triggerType: "MANUAL");

            return new
            {
                message = "数据刷新成功",
                batchId = result.BatchId,
                result.StageRows,
                result.StandardRows,
                result.DwdRows
            };
        }
        catch (Exception ex)
        {
            throw Oops.Oh($"刷新数据失败: {ex.Message}");
        }
    }

    [DisplayName("执行计划联动存储过程")]
    [HttpPost("linkageplan/run")]
    public async Task<object> RunLinkagePlanProcedure()
    {
        try
        {
            await _db.Ado.ExecuteCommandAsync("CALL pr_Mes_LinkagePlan('')");
            return new { message = "计划联动刷新成功" };
        }
        catch (Exception ex)
        {
            throw Oops.Oh($"执行存储过程失败: {ex.Message}");
        }
    }
}