缓存岛需要加个批次号条件、可以选择某个批次出

schangxiang@126.com

2025-03-10 8893638de46547923e0684220df3d9782f7ec283

 LA24030_LuLiPackageLine_Wms/Admin.NET.Application/Service/WmsCommonnQuery/WmsCommonnQueryService.cs

@@ -7,6 +7,10 @@
using DocumentFormat.OpenXml.Office.CustomUI;
using Microsoft.CodeAnalysis.Operations;
using Admin.NET.Application.Service.WmsTask.WmsRbLineTask.Dto;
using Admin.NET.Application.Service.WmsCommonnQuery.Dto;
using System.Collections.Generic;
using Admin.NET.Application.CommonHelper;
using System.Globalization;

namespace Admin.NET.Application;
/// <summary>
@@ -16,26 +20,41 @@
[AllowAnonymous]
public class WmsCommonnQueryService : IDynamicApiController, ITransient
{
    private readonly SqlSugarRepository<WmsRbLineTask> _rep;
    private readonly SqlSugarRepository<WmsRbLineTask> _wmsRbLineTaskRep;
    private readonly SqlSugarRepository<WmsStockQuan> _wmsStockQuanRep;
    private readonly SqlSugarRepository<Mes_Package_Gather> _mesPackageGatherRep;
    private readonly SqlSugarRepository<SysConfig> _sysConfigRep;
    private readonly SqlSugarRepository<Mes_BatchOrderUPI_New> _mesBatchOrderUpiRep;
    private readonly SqlSugarRepository<Mes_Order_Gather> _mesOrderGatherRep;
    private readonly SqlSugarRepository<Mes_Package_UnLine_Record> _mesPackage_UnLine_RecordRep;
    private readonly SqlSugarRepository<Mes_Package_LineQueue> _mesPackage_LineQueueRep;
    private readonly SqlSugarRepository<WmsRecordUpiReplenish> _wmsRecordUpiReplenishRep;
    private readonly SqlSugarRepository<WmsRecordUpiProcess> _wmsRecordUpiProcessRep;
    private readonly SqlSugarRepository<V_Station_Quan> _V_Station_Quan;

    public WmsCommonnQueryService(SqlSugarRepository<WmsRbLineTask> rep, SqlSugarRepository<WmsStockQuan> wmsStockQuanRep
    public WmsCommonnQueryService(SqlSugarRepository<WmsRbLineTask> wmsRbLineTaskRep, SqlSugarRepository<WmsStockQuan> wmsStockQuanRep
        , SqlSugarRepository<Mes_Package_Gather> mesPackageGatherRep
        , SqlSugarRepository<SysConfig> sysConfigRep
        , SqlSugarRepository<Mes_BatchOrderUPI_New> mesBatchOrderUpiRep
        , SqlSugarRepository<Mes_Order_Gather> mesOrderGatherRep
        , SqlSugarRepository<Mes_Package_UnLine_Record> mesPackage_UnLine_RecordRep
        , SqlSugarRepository<Mes_Package_LineQueue> mesPackage_LineQueueRep
        , SqlSugarRepository<WmsRecordUpiReplenish> wmsRecordUpiReplenishRep
        , SqlSugarRepository<WmsRecordUpiProcess> wmsRecordUpiProcessRep
        , SqlSugarRepository<V_Station_Quan> V_Station_Quan_Rep
        )
    {
        _wmsRecordUpiReplenishRep = wmsRecordUpiReplenishRep;
        _sysConfigRep = sysConfigRep;
        _mesPackageGatherRep = mesPackageGatherRep;
        _rep = rep;
        _wmsRbLineTaskRep = wmsRbLineTaskRep;
        _wmsStockQuanRep = wmsStockQuanRep;
        _mesBatchOrderUpiRep = mesBatchOrderUpiRep;
        _mesOrderGatherRep = mesOrderGatherRep;
        _mesPackage_UnLine_RecordRep = mesPackage_UnLine_RecordRep;
        _mesPackage_LineQueueRep = mesPackage_LineQueueRep;
        _wmsRecordUpiProcessRep = wmsRecordUpiProcessRep;
        _V_Station_Quan = V_Station_Quan_Rep;
    }

    /// <summary>
@@ -52,13 +71,46 @@
            .WhereIF(!string.IsNullOrWhiteSpace(input.Info5), u => u.Info5.Contains(input.Info5.Trim()))
            .WhereIF(!string.IsNullOrWhiteSpace(input.Info5), u => u.Info5.Contains(input.Info5.Trim()))
            .Where(x => ((DateTime)x.CreateTime).ToString("yyyyMMdd") == DateTime.Now.ToString("yyyyMMdd"))
            .Where(x => x.IsKitting == false)
            .Where(x => x.IsUnline == null || x.IsUnline == false)
            .OrderBy(g => g.Id)
            .ToListAsync(); // 确保获取结果为 List

        return list; // 结果
    }



    /// <summary>
    /// 查询 计划生产订单记录 （大屏使用）
    /// </summary>
    /// <returns></returns>
    [HttpGet]
    [ApiDescriptionSettings(Name = "QueryPlanOrderList")]
    [Description("WmsCommonnQuery/QueryPlanOrderList")]
    public async Task<List<Mes_Order_Gather>> QueryPlanOrderList()
    {
        var list = await _mesPackage_LineQueueRep.AsQueryable()
            .OrderBy(g => g.Id)
            .ToListAsync(); // 确保获取结果为 List
        List<Mes_Order_Gather> resultList = new List<Mes_Order_Gather>();
        foreach (var item in list)
        {
            if (resultList.Select(x => x.Info5).ToList().Contains(item.Info5))
            {

            }
            else
            {
                var mesOrderGather = await _mesOrderGatherRep.GetFirstAsync(x => x.Info5 == item.Info5);
                if (mesOrderGather != null)
                {
                    resultList.Add(mesOrderGather);
                }
            }
        }

        return resultList; // 结果
    }

    /// <summary>
    /// 查询 历史生产订单记录 （大屏使用）
@@ -96,18 +148,36 @@
    [Description("WmsCommonnQuery/QueryCurrentOrder")]
    public async Task<Mes_Order_Gather> QueryCurrentOrder()
    {
        //获取上班时间。
        var sysConfig_wms_wms_unline_oper = await _sysConfigRep.GetFirstAsync(x => x.Code == CommonConst.wms_unline_oper);
        if (sysConfig_wms_wms_unline_oper == null || sysConfig_wms_wms_unline_oper.Value == "无")
        ////获取上班时间。
        //var sysConfig_wms_wms_unline_oper = await _sysConfigRep.GetFirstAsync(x => x.Code == CommonConst.WmsBZ30_QiTao);
        //if (sysConfig_wms_wms_unline_oper == null || sysConfig_wms_wms_unline_oper.Value == "无")
        //{
        //    return null;
        //}
        //var arr = sysConfig_wms_wms_unline_oper.Value.Split('|');
        //var packagecode = arr[0];
        //var packObj = await _mesPackageGatherRep.AsQueryable().FirstAsync(x => x.PackageCode == packagecode);
        //if (packObj == null)
        //{
        //    throw Oops.Oh($"没有找到包{packagecode}的汇总数据");
        //}

        //var list = await _mesOrderGatherRep.AsQueryable()
        //    .Where(x => x.Info5 == packObj.Info5)
        //    .FirstAsync(); // 确保获取结果为 List

        //return list; // 结果

        var packageQueue = await _mesPackage_LineQueueRep.AsQueryable().Where(x => 1 == 1).ToListAsync();
        var single_packageQueue = packageQueue.OrderBy(x => x.Id).FirstOrDefault();
        if (single_packageQueue == null)
        {
            return null;
        }
        var arr = sysConfig_wms_wms_unline_oper.Value.Split('|');
        var packagecode = arr[0];
        var packObj = await _mesPackageGatherRep.AsQueryable().FirstAsync(x => x.PackageCode == packagecode);
        var packObj = await _mesPackageGatherRep.AsQueryable().FirstAsync(x => x.PackageCode == single_packageQueue.PackageCode);
        if (packObj == null)
        {
            throw Oops.Oh($"没有找到包{packagecode}的汇总数据");
            throw Oops.Oh($"没有找到包{single_packageQueue.PackageCode}的汇总数据");
        }

        var list = await _mesOrderGatherRep.AsQueryable()
@@ -116,5 +186,803 @@

        return list; // 结果
    }




    /// <summary>
    /// 大屏 - 登录人 登录时间 LS070700117B0005GS
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    [HttpGet]
    [ApiDescriptionSettings(Name = "ScreenLogin")]
    [Description("WmsCommonnQuery/ScreenLogin")]
    [AllowAnonymous]
    public async Task<ScreenLoginUserOutput> ScreenLogin([FromQuery] Mes_Package_LineQueueInput input)
    {
        // 基本查询
        var list = await _sysConfigRep.AsQueryable()
            .Where(x => x.Code == "wms_bz30_qitao" || x.Code == "wms_unline_oper" || x.Code == "wms_unline_time")
            .ToListAsync();
        // 检查list是否为空
        if (list == null || !list.Any())
        {
            // 返回默认值或者抛出异常
            return new ScreenLoginUserOutput
            {
                LoginUser = null,
                TimeLogin = null,
            };
        }

        //获取上班时间。
        DateTime unLineTime = Convert.ToDateTime(DateTime.Now.ToString("yyyy-MM-dd 00:00:00"));
        var sysConfig_wms_unline_time = await _sysConfigRep.GetFirstAsync(x => x.Code == CommonConst.wms_unline_time);
        if (sysConfig_wms_unline_time == null || sysConfig_wms_unline_time.Value == "无")
        {

        }
        else
        {
            unLineTime = Convert.ToDateTime(sysConfig_wms_unline_time.Value);
        }


        var recordList = await _mesPackage_UnLine_RecordRep.AsQueryable()
            .Where(x => x.CreateTime >= unLineTime)
            .ToListAsync(); // 确保获取结果为 List
                            //汇总数据 


        TimeSpan ts = DateTime.Now - unLineTime;

        // 返回结果
        return new ScreenLoginUserOutput
        {
            LoginUser = list.FirstOrDefault(x => x.Code == "wms_unline_oper")?.Value,
            TimeLogin = list.FirstOrDefault(x => x.Code == "wms_unline_time")?.Value,
            AllOrderNum = recordList.GroupBy(x => x.Info5).Count(),
            AllPackageArea = recordList.Sum(x => Convert.ToDecimal((x.Info13))),
            PackageNum = recordList.GroupBy(x => x.PackageCode).Count(),
            WorkTime = ts.TotalHours
        };
    }



    /// <summary>
    /// 不分页查询缓存岛齐包管理
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    [HttpGet]
    [ApiDescriptionSettings(Name = "packList")]
    [Description("WmsCommonnQuery/packList")]
    public async Task<List<WmsPackListOutput>> PackList([FromQuery] PackListInput input)
    {
        // 获取符合条件的记录，并提取所需信息
        var list = await _wmsStockQuanRep.AsQueryable()
            .WhereIF(!string.IsNullOrWhiteSpace(input.PackageCode), u => u.PackageCode.Contains(input.PackageCode.Trim()))
            .WhereIF(!string.IsNullOrWhiteSpace(input.PlanNo), u => u.PlanNo.Contains(input.PlanNo.Trim()))
            .WhereIF(!string.IsNullOrWhiteSpace(input.OrderId), u => u.OrderId.Contains(input.OrderId.Trim()))
            .Select(x => new { x.PackageCode, x.PlanNo, x.OrderId })
            .ToListAsync();

        // 创建一个列表以存储 WmsPackListOutput
        var resultList = new List<WmsPackListOutput>();

        // 分组并计算每组信息
        var groupedResult = list.GroupBy(x => new { x.PackageCode, x.PlanNo, x.OrderId });

        foreach (var g in groupedResult)
        {
            // 在这里计算每组的总数
            var count = g.Count();
            var mesTotalCount = await _mesBatchOrderUpiRep.AsQueryable().CountAsync(m => m.PackageCode == g.Key.PackageCode);

            resultList.Add(new WmsPackListOutput
            {
                PackageCode = g.Key.PackageCode,
                PlanNo = g.Key.PlanNo,
                OrderId = g.Key.OrderId,
                Count = count,
                MesTotalCount = mesTotalCount,
                IsPack = count >= mesTotalCount, // 检查是否打包
                LackCount = mesTotalCount - count
            });
        }

        // 过滤、排序并返回最终结果
        var finalResult = resultList
            .WhereIF(input.IsPack.HasValue, u => u.IsPack == input.IsPack)
            .OrderBy(g => g.PackageCode)
            .ToList();

        return finalResult;
    }



    /// <summary>
    /// 不分页查询齐套管理
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    [HttpGet]
    [ApiDescriptionSettings(Name = "KittingList")]
    [Description("WmsCommonnQuery/KittingList")]
    public async Task<List<WmsKittingListOutput>> KittingList([FromQuery] KittingListInput input)
    {
        var list = await _wmsStockQuanRep.AsQueryable()
            .WhereIF(!string.IsNullOrWhiteSpace(input.DetailName), u => u.PlaceCode.Contains(input.DetailName.Trim()))
            .Select(x => new WmsKittingListOutput
            {
                OrderId = x.OrderId
            })
            .ToListAsync(); // 确保获取结果为 List

        // 分组并返回分组信息
        var groupedResult = list
            .GroupBy(x => x.OrderId) // 按 PackageCode 分组
            .Select(g => new WmsKittingListOutput
            {
                OrderId = g.Key, // 获取分组的键
                Count = g.Count(), // 统计每组的数量
                IsKitting = 1 == 1 ? true : false // 如果 Count 为 5 则 IsKitting 为 1，否则为 0  
            })
            .WhereIF(input.IsKitting.HasValue, u => u.IsKitting == input.IsKitting)
            .OrderBy(g => g.OrderId) // 根据 PackageCode 排序
            .ToList(); // 转换为 List
        return groupedResult; // 返回分组结果
    }






    /// <summary>
    /// 人工补板动作
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    ///  [HttpGet]
    [ApiDescriptionSettings(Name = "ShortageList")]
    [Description("WmsCommonnQuery/ShortageList")]
    public async Task<WmsShortageListOutput> ShortageList(KittingListInput input)
    {
        var listRes = await GetShortageListCore(input);
        var resJson = new WmsShortageListOutput();
        if (!string.IsNullOrWhiteSpace(input.UPI))
        {
            resJson = listRes.FirstOrDefault(u => u.UPI == input.UPI);
            //var filteredResult = listRes.FirstOrDefault(u => u.UPI == input.UPI);
        }
        var _cretaorName = App.User.FindFirst(ClaimConst.RealName)?.Value;
        if (resJson != null)
        {
            //执行人工补板动作
            var client = await WCFServiceHelper.GetWCFService_SAPCC_Client(_sysConfigRep);
            var res = await client.WriteStation_AllowInAsync();
            if (res.result == false)
            {
                throw Oops.Oh("补板工位允许进板请求失败:" + res.resMsg);
            }
            //*/

            //记录补板记录和板件履历
            var singleUpi = await _mesBatchOrderUpiRep.AsQueryable().Where(x => x.UPI == input.UPI).FirstAsync();
            if (singleUpi == null)
            {
                throw Oops.Oh($"没有找到部件条码{input.UPI}的数据");
            }
            WmsRecordUpiProcess wmsRecordUpi = new WmsRecordUpiProcess();
            wmsRecordUpi = singleUpi.Adapt<WmsRecordUpiProcess>();
            wmsRecordUpi.Id = Yitter.IdGenerator.YitIdHelper.NextId();
            wmsRecordUpi.CreateTime = DateTime.Now;
            wmsRecordUpi.CreateUserName = _cretaorName;
            wmsRecordUpi.Location = "";
            wmsRecordUpi.OperRemark = "人工补板";
            await _wmsRecordUpiProcessRep.InsertAsync(wmsRecordUpi);

            WmsRecordUpiReplenish wmsRecordUpiNg = new WmsRecordUpiReplenish();
            wmsRecordUpiNg = singleUpi.Adapt<WmsRecordUpiReplenish>();
            wmsRecordUpiNg.Id = Yitter.IdGenerator.YitIdHelper.NextId();
            wmsRecordUpiNg.CreateTime = DateTime.Now;
            wmsRecordUpiNg.CreateUserName = _cretaorName;
            wmsRecordUpiNg.OperRemark = "人工补板";
            await _wmsRecordUpiReplenishRep.InsertAsync(wmsRecordUpiNg);
        }
        else
        {
            throw Oops.Oh($"板件'{input.UPI}'不在缺包清单中");
        }

        return resJson;
    }

    /// <summary>
    /// 分页查询批次缺料清单 不齐包 
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    [HttpPost]
    [ApiDescriptionSettings(Name = "ShortagePage")]
    [Description("WmsCommonnQuery/ShortagePage")]
    public async Task<SqlSugarPagedList<WmsShortageListOutput>> ShortagePage(KittingListInput input)
    {
        var listRes = await GetShortageListCore(input);
        if (listRes?.Count > 0)
        {
            listRes = listRes.WhereIF(!string.IsNullOrWhiteSpace(input.Info5), u => u.Info5 == input.Info5).ToList();
            listRes = listRes.WhereIF(!string.IsNullOrWhiteSpace(input.DetailName), u => u.DetailName == input.DetailName).ToList();
        }
        // 进行分页处理
        var totalCount = listRes.Count; // 获取总数
        var pagedList = listRes
            //.OrderBy(x => x.Id) // 根据需要进行排序
            .Skip((input.Page - 1) * input.PageSize)
            .Take(input.PageSize)
            .ToList();

        // 构造并返回分页结果
        return new SqlSugarPagedList<WmsShortageListOutput>
        {
            Page = input.Page,
            PageSize = input.PageSize,
            Total = totalCount,
            TotalPages = (int)Math.Ceiling((double)totalCount / input.PageSize),
            Items = pagedList,
            HasPrevPage = input.Page > 1,
            HasNextPage = input.Page < ((int)Math.Ceiling((double)totalCount / input.PageSize))
        };
    }


    /// <summary>
    /// 分页查询缺料清单 不齐包 -按照生产单号分组 
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    [HttpPost]
    [ApiDescriptionSettings(Name = "ShortagePageGroupByInfo5")]
    [Description("WmsCommonnQuery/ShortagePageGroupByInfo5")]
    public async Task<SqlSugarPagedList<WmsShortageListOutput>> ShortagePageGroupByInfo5(KittingListInput input)
    {
        var listRes = await GetShortageListCore(input);

        // 按照字段 Info5 分组
        var groupedList = listRes
            .GroupBy(x => x.Info5) // 根据 Info5 字段进行分组
            .Select(g => new WmsShortageListOutput // 假设您将分组后的结果转换为 WmsShortageListOutput
            {
                Info5 = g.Key,
                ShortageCount = g.Count(),
            })
            .ToList();

        // 进行分页处理
        var totalCount = groupedList.Count; // 获取总数
        var pagedList = groupedList
            //.OrderBy(x => x.Id) // 根据需要进行排序
            .Skip((input.Page - 1) * input.PageSize)
            .Take(input.PageSize)
            .ToList();

        // 构造并返回分页结果
        return new SqlSugarPagedList<WmsShortageListOutput>
        {
            Page = input.Page,
            PageSize = input.PageSize,
            Total = totalCount,
            TotalPages = (int)Math.Ceiling((double)totalCount / input.PageSize),
            Items = pagedList,
            HasPrevPage = input.Page > 1,
            HasNextPage = input.Page < ((int)Math.Ceiling((double)totalCount / input.PageSize))
        };
    }



    /// <summary>
    /// 缺包数据
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    private async Task<List<WmsShortageListOutput>> GetShortageListCore(KittingListInput input)
    {
        var listRes = new List<WmsShortageListOutput>();
        // 缓存岛数据
        var queryHcdList = _wmsStockQuanRep.AsQueryable().WhereIF(!string.IsNullOrWhiteSpace(input.PackageCode), u => u.PackageCode == input.PackageCode);

        var listDao = await queryHcdList.ToListAsync();
        var packageCodes = listDao.Select(x => x.PackageCode).ToList();
        // 获取 mes 所有相关记录
        var allRecords = await _mesBatchOrderUpiRep.AsQueryable()
            .Where(m => packageCodes.Contains(m.PackageCode))
            .ToListAsync();
        // 遍历记录，对比 listDao
        var listDaoUbi = listDao.Select(u => u.Upi).ToHashSet(); // 将 UPI 转换为 HashSet，提高查找效率
        foreach (var item in allRecords)
        {
            if (!listDaoUbi.Contains(item.UPI)) // 使用 HashSet 进行查找
            {
                var pc = await _mesPackageGatherRep.GetFirstAsync(x => x.PackageCode == item.PackageCode);
                listRes.Add(new WmsShortageListOutput
                {
                    UPI = item.UPI,
                    PackageCode = item.PackageCode,
                    DetailName = item.DetailName,
                    OrderId = item.OrderId,
                    PlanNo = item.PlanNo,
                    Info5 = item.Info5,
                    Info4 = item.Info4,
                    Info10 = pc.Info10,
                    Info11 = pc.Info11,
                    Info12 = pc.Info12,
                    Info13 = pc.Info13,
                    //Info14 = item.Info14,
                    Info15 = item.Info15,
                    Info16 = item.Info16,
                    Info18 = item.Info18,
                    Length = item.Length,
                    Width = item.Width,
                    Thk = item.Thk
                });
            }
        }

        return listRes;
    }

    /// <summary>
    /// 分页查询批次缺料清单 不齐包 -暂时不用
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    [HttpPost]
    [ApiDescriptionSettings(Name = "ShortagePage2")]
    [Description("WmsCommonnQuery/ShortagePage2")]
    public async Task<SqlSugarPagedList<WmsShortageListOutput>> ShortagePage2(KittingListInput input)
    {
        // 获取基础数据
        var list = await _wmsStockQuanRep.AsQueryable()
            .WhereIF(!string.IsNullOrWhiteSpace(input.DetailName), u => u.PlaceCode.Contains(input.DetailName.Trim()))
            .Select(x => new WmsShortageListOutput
            {
                OrderId = x.OrderId,
                PlanNo = x.PlanNo,
                PackageCode = x.PackageCode
            })
            .ToListAsync(); // 确保获取结果为 List

        // 分组并返回分组信息
        var groupedResult = list
            .GroupBy(x => x.OrderId) // 按 OrderId 分组
            .Select(g => new WmsShortageListOutput
            {
                OrderId = g.Key, // 获取分组的键
                PlanNo = g.FirstOrDefault().PlanNo, // 获取组内的第一个 PlanNo
                PackageCode = g.FirstOrDefault().PackageCode, // 获取组内的第一个 PackageCode
                HasCount = g.Count(), // 统计每组的数量
                TotalCount = 0, // 初始化 TotalCount
                ShortageCount = 0 // 初始化 ShortageCount
            })
            .OrderBy(g => g.OrderId) // 根据 OrderId 排序
            .ToList(); // 转换为 List

        // 循环 groupedResult 给每一条加上总数量 TotalCount
        foreach (var item in groupedResult)
        {
            item.TotalCount = await _mesBatchOrderUpiRep.AsQueryable().CountAsync(m => m.PackageCode == item.PackageCode); // 根据 PackageCode 统计总条数
            item.ShortageCount = item.TotalCount - item.HasCount > 0 ? item.TotalCount - item.HasCount : 0;
        }

        // 分页处理
        var pagedResult = groupedResult.AsQueryable() // 将分组结果转换为可查询的集合
            .OrderBy(g => g.OrderId) // 进行排序
            .Skip((input.Page - 1) * input.PageSize) // 跳过前面的页数
            .Take(input.PageSize) // 取出当前页的数据
            .ToList(); // 转换为 List

        var totalCount = groupedResult.Count; // 获取总数
        var totalPages = (int)Math.Ceiling((double)totalCount / input.PageSize); // 计算总页数

        // 构造并返回分页结果
        return new SqlSugarPagedList<WmsShortageListOutput>
        {
            Page = input.Page,
            PageSize = input.PageSize,
            Total = totalCount,
            TotalPages = totalPages,
            Items = pagedResult,
            HasPrevPage = input.Page > 1,
            HasNextPage = input.Page < totalPages
        };
    }


    /// <summary>
    /// 不分页查询批次缺料清单 不齐包-暂时不用
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    [HttpGet]
    [ApiDescriptionSettings(Name = "ShortageList2")]
    [Description("WmsCommonnQuery/ShortageList2")]
    public async Task<List<WmsShortageListOutput>> ShortageList2([FromQuery] KittingListInput input)
    {
        var list = await _wmsStockQuanRep.AsQueryable()
            .WhereIF(!string.IsNullOrWhiteSpace(input.DetailName), u => u.PlaceCode.Contains(input.DetailName.Trim()))
            .Select(x => new WmsShortageListOutput
            {
                OrderId = x.OrderId,
                PlanNo = x.PlanNo,
                PackageCode = x.PackageCode
            })
            .ToListAsync(); // 确保获取结果为 List

        // 分组并返回分组信息
        var groupedResult = list
            .GroupBy(x => x.OrderId) // 按 OrderId 分组
            .Select(g => new WmsShortageListOutput
            {
                OrderId = g.Key, // 获取分组的键
                PlanNo = g.FirstOrDefault().PlanNo, // 获取组内的第一个 PlanNo
                PackageCode = g.FirstOrDefault().PackageCode, // 获取组内的第一个 PackageCode
                HasCount = g.Count(), // 统计每组的数量
                TotalCount = 0, // 初始化 TotalCount
                ShortageCount = 0 // 初始化 ShortageCount
            })
            .OrderBy(g => g.OrderId) // 根据 OrderId 排序
            .ToList(); // 转换为 List

        // 循环 groupedResult 给每一条加上总数量 CountTotal
        foreach (var item in groupedResult)
        {
            item.TotalCount = await _mesBatchOrderUpiRep.AsQueryable().CountAsync(m => m.PackageCode == item.PackageCode); // 根据 PackageCode 统计总条数
            item.ShortageCount = item.TotalCount - item.HasCount > 0 ? item.TotalCount - item.HasCount : 0;
        }

        return groupedResult; // 返回分组结果
    }


    /// <summary>
    /// 查询包数据
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    [HttpPost]
    [ApiDescriptionSettings(Name = "QueryPackage")]
    [Description("WmsCommonnQuery/QueryPackage")]
    public async Task<Mes_Package_Gather> QueryPackage(QueryPackageInput input)
    {
        if (input == null || input.PackageCode == null)
        {
            throw Oops.Oh("参数不能为空");
        }

        var package = await _mesPackageGatherRep.AsQueryable().Where(x => x.PackageCode == input.PackageCode).FirstAsync();
        if (package == null)
        {
            throw Oops.Oh($"没有找到包号{input.PackageCode}的汇总数据");
        }
        return package;
    }


    /// <summary>
    /// 根据包号，查询某个包下的板件数据
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    [HttpPost]
    [ApiDescriptionSettings(Name = "QueryUpiListByPackage")]
    [Description("WmsCommonnQuery/QueryUpiListByPackage")]
    public async Task<List<Mes_BatchOrderUPI_New>> QueryUpiListByPackage(QueryPackageInput input)
    {
        if (input == null || input.PackageCode == null)
        {
            throw Oops.Oh("参数不能为空");
        }

        var package = await _mesPackageGatherRep.AsQueryable().Where(x => x.PackageCode == input.PackageCode).FirstAsync();
        if (package == null)
        {
            throw Oops.Oh($"没有找到包号{input.PackageCode}的汇总数据");
        }

        var upiList = await _mesBatchOrderUpiRep.AsQueryable().Where(x => x.PackageCode == input.PackageCode).ToListAsync();

        return upiList;
    }

    /// <summary>
    /// 根据某个Upi，查询某个包下的板件数据
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    [HttpPost]
    [ApiDescriptionSettings(Name = "QueryUpiListByUpi")]
    [Description("WmsCommonnQuery/QueryUpiListByUpi")]
    public async Task<List<Mes_BatchOrderUPI_New>> QueryUpiListByUpi(QueryUpiListByUpiInput input)
    {
        if (input == null || input.Upi == null)
        {
            throw Oops.Oh("参数不能为空");
        }

        var singleUpi = await _mesBatchOrderUpiRep.AsQueryable().Where(x => x.UPI == input.Upi || x.PackageCode == input.Upi).FirstAsync();
        if (singleUpi == null)
        {
            throw Oops.Oh($"没有找到部件条码{input.Upi}的数据");
        }

        var package = await _mesPackageGatherRep.AsQueryable().Where(x => x.PackageCode == singleUpi.PackageCode).FirstAsync();
        if (package == null)
        {
            throw Oops.Oh($"没有找到包号{singleUpi.PackageCode}的汇总数据");
        }

        var upiList = await _mesBatchOrderUpiRep.AsQueryable().Where(x => x.PackageCode == singleUpi.PackageCode).ToListAsync();
        upiList = upiList.OrderBy(x => x.Shelf).ToList();

        return upiList;
    }


    /// <summary>
    /// 根据某个Upi，查询板件数据
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    [HttpPost]
    [ApiDescriptionSettings(Name = "QuerySingleUpiByUpi")]
    [Description("WmsCommonnQuery/QuerySingleUpiByUpi")]
    public async Task<List<Mes_BatchOrderUPI_New>> QuerySingleUpiByUpi(QueryUpiListByUpiInput input)
    {
        if (input == null || input.Upi == null)
        {
            throw Oops.Oh("参数不能为空");
        }

        var singleUpi = await _mesBatchOrderUpiRep.AsQueryable().Where(x => x.UPI == input.Upi).FirstAsync();
        if (singleUpi == null)
        {
            throw Oops.Oh($"没有找到部件条码{input.Upi}的数据");
        }

        List<Mes_BatchOrderUPI_New> upiList = new List<Mes_BatchOrderUPI_New>();
        upiList.Add(singleUpi);
        return upiList;
    }



    /// <summary>
    /// 首页 本周下线物料信息
    /// </summary>
    /// <returns></returns>
    [HttpGet]
    [ApiDescriptionSettings(Name = "HomeOffOrderList")]
    [Description("WmsCommonnQuery/HomeOffOrderList")]
    public async Task<List<Home_Order_Info>> HomeOffOrderList()
    {
        List<Home_Order_Info> resultList = new List<Home_Order_Info>();
        // 获取当前时间
        DateTime currentDate = DateTime.Now;
        // 计算一周之前的时间
        //DateTime oneWeekAgo = currentDate.AddDays(-7);

        // 获取当前文化信息
        CultureInfo cultureInfo = CultureInfo.CurrentCulture;

        // DayOfWeek.Monday 表示一周的第一天是周一
        int diff = (int)cultureInfo.DateTimeFormat.FirstDayOfWeek - (int)DateTime.Now.DayOfWeek;

        // 如果需要，对差值进行调整以确保是过去的日期
        if (diff < 0) diff += 7;
        DateTime oneWeekAgo = DateTime.Now.AddDays(diff).Date;
        //*/

        // 查询最近一周的下线订单数
        var dataList = await _mesPackage_UnLine_RecordRep.AsQueryable().Where(x => x.CreateTime >= oneWeekAgo && x.CreateTime <= currentDate).ToListAsync();

        var packageList = dataList.GroupBy(x => x.PackageCode);//下线包

        var orderCount = dataList.GroupBy(x => x.Info5).Count();//下线订单数
        var packageCount = packageList.Count();//下线包数
        var upiCount = 0;
        foreach (var item in packageList)
        {
            upiCount += Convert.ToInt32(item.ToList().First().Info12);
        }

        resultList.Add(new Home_Order_Info
        {
            Name = "本周生产订单数",
            Value = orderCount
        });
        resultList.Add(new Home_Order_Info
        {
            Name = "本周下线包数",
            Value = packageCount
        });
        resultList.Add(new Home_Order_Info
        {
            Name = "本周下线板数",
            Value = upiCount
        });
        return resultList; // 结果
    }



    /// <summary>
    /// 上下架推移图
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    [HttpGet]
    [ApiDescriptionSettings(Name = "HomeTytPage")]
    [Description("WmsCommonnQuery/HomeTytPage")]
    public async Task<List<WmsStockPassMapOutput>> HomeTytPage([FromQuery] WmsStockPassMapInput input)
    {
        List<WmsStockPassMapOutput> outputlist = new List<WmsStockPassMapOutput>();
        DateTime currentDate = DateTime.Today;

        //选择为12日的情况
        if (input.DayOrWeekOrMonth == 1)
        {
            //总的数据
            DateTime all_startDate = currentDate.AddDays(-11);
            DateTime all_endDate = currentDate.Date.AddDays(1).AddTicks(-1);
            var all_recordsOfDay = await _mesPackage_UnLine_RecordRep.AsQueryable()
                .Where(r => r.CreateTime >= all_startDate && r.CreateTime <= all_endDate
               ).ToListAsync();


            for (int i = 0; i < 12; i++)
            {
                DateTime startDate = currentDate.AddDays(-i);
                DateTime endDate = startDate.Date.AddDays(1).AddTicks(-1);

                // 查询在这一天内的记录
                var recordsOfDay = all_recordsOfDay.Where(r => r.CreateTime >= startDate && r.CreateTime <= endDate
                ).ToList();


                var summary = new WmsStockPassMapOutput
                {
                    Time = 12 - i,
                    //InWare = recordsOfDay
                    //.ToList().Count(),
                    OutWare = recordsOfDay
                    .ToList().GroupBy(x => x.Info5).Count(),
                    StockNum = 0,
                    AveStockNum = 0,
                    Date = startDate.Date.ToString("yyyy-MM-dd")
                };

                outputlist.Add(summary);
            }
        }
        //选择12周
        else if (input.DayOrWeekOrMonth == 2)
        {
            //总的数据
            DateTime all_startDate = GetStartOfWeek(currentDate).AddDays(-7 * 11);
            DateTime all_endDate = GetEndOfWeek(currentDate);
            var all_recordsOfDay = await _mesPackage_UnLine_RecordRep.AsQueryable().Where(r => r.CreateTime >= all_startDate && r.CreateTime <= all_endDate
               ).ToListAsync();

            for (int i = 0; i < 12; i++)
            {
                // 计算当前周的起始日期
                DateTime startDate = GetStartOfWeek(currentDate).AddDays(-7 * i);
                DateTime endDate = GetEndOfWeek(startDate);

                // 查询在这一周内的出入库记录
                var recordsOfWeek = all_recordsOfDay.Where(r => r.CreateTime >= startDate && r.CreateTime <= endDate).ToList();

                // 汇总出入库记录
                var summary = new WmsStockPassMapOutput
                {
                    Time = 12 - i,
                    //InWare = recordsOfWeek
                    //.ToList().Count(),
                    OutWare = recordsOfWeek
                      .ToList().GroupBy(x => x.Info5).Count(),
                    StockNum = 0,
                    AveStockNum = 0,
                    Date = startDate.Date.ToString("MMdd") + "～" + endDate.Date.ToString("MMdd")
                };

                outputlist.Add(summary);
            }
        }
        //选择12个月
        else if (input.DayOrWeekOrMonth == 3)
        {
            //总的数据
            DateTime all_startDate = currentDate.AddMonths(-11).AddDays(1 - currentDate.Day);
            DateTime all_endDate = currentDate.AddMonths(1).AddDays(-1);
            var all_recordsOfDay = await _mesPackage_UnLine_RecordRep.AsQueryable().Where(r => r.CreateTime >= all_startDate && r.CreateTime <= all_endDate
               ).ToListAsync();

            for (int i = 0; i < 12; i++)
            {
                DateTime startDate = currentDate.AddMonths(-i).AddDays(1 - currentDate.Day);
                DateTime endDate = startDate.AddMonths(1).AddDays(-1);

                // 查询在这个月内的出入库记录
                var recordsOfMonth = all_recordsOfDay.Where(r => r.CreateTime >= startDate && r.CreateTime <= endDate).ToList();

                // 汇总出入库记录
                var summary = new WmsStockPassMapOutput
                {
                    Time = 12 - i,
                    //InWare = recordsOfMonth
                    // .ToList().Count(),
                    OutWare = recordsOfMonth
                     .ToList().GroupBy(x => x.Info5).Count(),
                    StockNum = 0,
                    AveStockNum = 0,
                    Date = startDate.ToString("yyyy-MM")
                };

                outputlist.Add(summary);
            }
        }

        //排序
        outputlist = outputlist.OrderBy(x => x.Time).ToList();

        return outputlist;
    }
    // 获取当前日期所在周的起始日期（周一）
    private DateTime GetStartOfWeek(DateTime currentDate)
    {
        int diff = currentDate.DayOfWeek - DayOfWeek.Monday;
        if (diff < 0) diff += 7; // 处理周日的情况
        return currentDate.AddDays(-1 * diff).Date;
    }

    // 获取当前日期所在周的结束日期（周日）
    private DateTime GetEndOfWeek(DateTime startDate)
    {
        return startDate.AddDays(6); // 因为起始日期已经是周一，所以直接加6天即可得到周日
    }




    /// <summary>
    /// 不分页查询库位信息
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    [HttpGet]
    [ApiDescriptionSettings(Name = "ListView")]
    [Description("WmsCommonnQuery/ListView")]
    public async Task<List<LocationViewOutput>> ListView([FromQuery] WmsBasePlaceInput input)
    {
        var query = await _V_Station_Quan.AsQueryable()
        .WhereIF(!string.IsNullOrWhiteSpace(input.SearchKey), u =>
        u.PlaceCode.Contains(input.SearchKey.Trim())
        //  || u.WareContainerCode.Contains(input.SearchKey.Trim())
        //|| u.Lane==input.Lane
        //|| u.Row==input.Row  
        )
        .OrderBy(u => u.LaneNo)
        //.OrderBy(u => u.Row)
        .OrderBy(u => u.LayerNo)
        .OrderBy(u => u.ColumnNo)
        .Select<LocationViewOutput>().ToListAsync();
        return query;
    }

}