using Admin.NET.Core.Service;
|
using Admin.NET.Application.Entity;
|
using Microsoft.AspNetCore.Http;
|
using System.Data;
|
using System.Web;
|
using System.Text;
|
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>
|
/// 通用查询服务
|
/// </summary>
|
[ApiDescriptionSettings(ApplicationConst.WmsCommonnQueryGroupName, Order = 100)]
|
[AllowAnonymous]
|
public class WmsCommonnQueryService : IDynamicApiController, ITransient
|
{
|
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> 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;
|
_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>
|
/// 查询不齐套单据
|
/// </summary>
|
/// <param name="input"></param>
|
/// <returns></returns>
|
[HttpGet]
|
[ApiDescriptionSettings(Name = "QueryNoKittingList")]
|
[Description("WmsCommonnQuery/QueryNoKittingList")]
|
public async Task<List<Mes_Order_Gather>> QueryNoKittingList([FromQuery] KittingListInput input)
|
{
|
var list = await _mesOrderGatherRep.AsQueryable()
|
.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.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>
|
/// 查询 历史生产订单记录 （大屏使用）
|
/// </summary>
|
/// <returns></returns>
|
[HttpGet]
|
[ApiDescriptionSettings(Name = "QueryHistoryOrderList")]
|
[Description("WmsCommonnQuery/QueryHistoryOrderList")]
|
public async Task<List<Mes_Order_Gather>> QueryHistoryOrderList()
|
{
|
//获取上班时间。
|
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 == "无")
|
{
|
return null;
|
}
|
var unLineTime = Convert.ToDateTime(sysConfig_wms_unline_time.Value);
|
|
var list = await _mesOrderGatherRep.AsQueryable()
|
.Where(x => x.UnlineTime >= unLineTime)
|
.Where(x => x.IsUnline == true)
|
.OrderByDescending(g => g.Id)
|
.ToListAsync(); // 确保获取结果为 List
|
|
return list; // 结果
|
}
|
|
|
/// <summary>
|
/// 查询 当前生产订单记录 （大屏使用）
|
/// </summary>
|
/// <returns></returns>
|
[HttpGet]
|
[ApiDescriptionSettings(Name = "QueryCurrentOrder")]
|
[Description("WmsCommonnQuery/QueryCurrentOrder")]
|
public async Task<Mes_Order_Gather> QueryCurrentOrder()
|
{
|
////获取上班时间。
|
//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 packObj = await _mesPackageGatherRep.AsQueryable().FirstAsync(x => x.PackageCode == single_packageQueue.PackageCode);
|
if (packObj == null)
|
{
|
throw Oops.Oh($"没有找到包{single_packageQueue.PackageCode}的汇总数据");
|
}
|
|
var list = await _mesOrderGatherRep.AsQueryable()
|
.Where(x => x.Info5 == packObj.Info5)
|
.FirstAsync(); // 确保获取结果为 List
|
|
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()))
|
.Select(x => new { x.PackageCode })
|
.ToListAsync();
|
|
// 创建一个列表以存储 WmsPackListOutput
|
var resultList = new List<WmsPackListOutput>();
|
|
// 分组并计算每组信息
|
var groupedResult = list.GroupBy(x => x.PackageCode);
|
|
foreach (var g in groupedResult)
|
{
|
// 在这里计算每组的总数
|
var count = g.Count();
|
var mesTotalCount = await _mesBatchOrderUpiRep.AsQueryable().CountAsync(m => m.PackageCode == g.Key);
|
|
resultList.Add(new WmsPackListOutput
|
{
|
PackageCode = g.Key,
|
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 进行查找
|
{
|
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 = item.Info10,
|
Info11 = item.Info11,
|
Info12 = item.Info12,
|
Info13 = item.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;
|
}
|
|
}
|
