namespace WIDESEA_StorageOutBasicServices;
|
|
public class Dt_BillGroupStockService : ServiceBase<Dt_BillGroupStock, IDt_BillGroupStockRepository>, IDt_BillGroupStockService
|
{
|
private readonly IUnitOfWorkManage _unitOfWorkManage;
|
private readonly IDt_OutOrderService _outOrderService;
|
private readonly IDt_TaskService _taskService;
|
private readonly IDt_OutOrderAndStockRepository _OutOrderAndStockRepository;
|
private readonly IDt_OutOrderAndStock_HtyService _OutOrderAndStock_HtyService;
|
private readonly IDt_Task_HtyService _Task_HtyService;
|
private readonly IMapper _mapper;
|
|
public Dt_BillGroupStockService(IDt_BillGroupStockRepository baseDal,
|
IUnitOfWorkManage unitOfWorkManage,
|
IDt_OutOrderService outOrderService,
|
IDt_TaskService taskService,
|
IDt_OutOrderAndStockRepository outOrderAndStockRepository,
|
IMapper mapper,
|
IDt_OutOrderAndStock_HtyService outOrderAndStock_HtyService,
|
IDt_Task_HtyService task_HtyService) : base(baseDal)
|
{
|
_unitOfWorkManage = unitOfWorkManage;
|
_outOrderService = outOrderService;
|
_taskService = taskService;
|
_OutOrderAndStockRepository = outOrderAndStockRepository;
|
_mapper = mapper;
|
_OutOrderAndStock_HtyService = outOrderAndStock_HtyService;
|
_Task_HtyService = task_HtyService;
|
}
|
|
#region 外部接口
|
|
/// <summary>
|
/// 根据特定条件获取库存
|
/// </summary>
|
/// <param name="palletCode">托盘号</param>
|
/// <param name="locationID">货位ID</param>
|
/// <param name="materialNo">物料编号</param>
|
/// <returns>特定库存</returns>
|
public async Task<Dt_BillGroupStock> GetStocks(string palletCode = null, string locationID = null, string materialNo = null)
|
{
|
return await Db.Queryable<Dt_BillGroupStock>()
|
.WhereIF(palletCode != null, x => x.PalletCode == palletCode)
|
.WhereIF(locationID != null, x => x.LocationCode == locationID)
|
.WhereIF(materialNo != null, x => x.MaterialNo == materialNo)
|
.Includes(x => x.LocationInfo)
|
.Includes(x => x.StockDetailList)
|
.FirstAsync();
|
}
|
|
/// <summary>
|
/// 获取所有可出库库存，不包括已经出库的或已经分配的。
|
/// </summary>
|
/// <returns>出库库存列表</returns>
|
public async Task<WebResponseContent> GetOutboundStock()
|
{
|
WebResponseContent content = new WebResponseContent();
|
try
|
{
|
#region 前期没数据临时开发使用，后期更换根据订单进行筛选库存
|
|
// 获取所有可出库库存
|
var stocks = BaseDal.GetOutboundStockList();
|
|
// 获取订单
|
var order = GetOrder("2");
|
|
// 检查订单是否获取成功
|
if (order == null)
|
{
|
return content.Error("获取订单失败");
|
}
|
// 获取订单中的第一个物料号
|
var materialNo = order.OrderDetailList.MaterialId;
|
|
// 筛选并排序库存
|
var filteredStocks = stocks.Where(x => x.MaterialNo == materialNo.ToString())
|
.OrderBy(x => x.CreateDate)
|
.ToList();
|
|
#endregion 前期没数据临时开发使用，后期更换根据订单进行筛选库存
|
|
// 创建任务列表
|
var (tasks, updateOrder) = CreateTasks(order, filteredStocks);
|
|
// 更新库存状态
|
var stockList = UpdateStocks(filteredStocks, updateOrder);
|
|
// 创建订单库存列表
|
var orderStocks = CreateOrderStock(filteredStocks, updateOrder, tasks);
|
|
// 开始事务
|
_unitOfWorkManage.BeginTran();
|
|
// 更新库存
|
var isStockUpdated = BaseDal.UpdateNavStock(stockList);
|
|
// 更新订单
|
var isOrderUpdated = await _outOrderService.OutOrderUpdated(updateOrder);
|
|
//添加订单库存
|
var isOrderStockCread = _OutOrderAndStockRepository.AddData(orderStocks) > 0;
|
|
// 创建任务
|
var isTaskCreated = await _taskService.Create(tasks);
|
|
// 提交或回滚事务
|
if (isStockUpdated && isTaskCreated && isOrderUpdated && isOrderStockCread)
|
{
|
_unitOfWorkManage.CommitTran();
|
}
|
else
|
{
|
_unitOfWorkManage.RollbackTran();
|
}
|
|
return content.OK(data: stocks);
|
}
|
catch (Exception ex)
|
{
|
_unitOfWorkManage.RollbackTran();
|
return content.Error(ex.Message);
|
}
|
}
|
|
#endregion 外部接口
|
|
#region 内部调用方法
|
|
/// <summary>
|
/// 更新库存集合
|
/// </summary>
|
/// <param name="stocks">库存集合</param>
|
/// <returns>成功/失败</returns>
|
public bool UpdateNavStock(List<Dt_BillGroupStock> stocks)
|
{
|
return BaseDal.UpdateNavStock(stocks);
|
}
|
|
/// <summary>
|
/// 更新单个库存
|
/// </summary>
|
/// <param name="stocks">库存</param>
|
/// <returns>成功/失败</returns>
|
public bool UpdateNavStock(Dt_BillGroupStock stocks)
|
{
|
return BaseDal.UpdateNavStock(stocks);
|
}
|
|
#endregion 内部调用方法
|
|
#region private内部方法
|
|
/// <summary>
|
/// 根据订单号获取订单
|
/// </summary>
|
/// <param name="orderNumber">订单号</param>
|
/// <returns>订单对象</returns>
|
private Dt_OutOrder GetOrder(string orderNumber)
|
{
|
// 获取订单信息
|
var content = _outOrderService.GetOutOrderByNumber(orderNumber);
|
|
// 检查订单是否获取成功
|
if (!content.Status)
|
{
|
return null;
|
}
|
|
// 反序列化订单对象
|
return (Dt_OutOrder)content.Data;
|
}
|
|
/// <summary>
|
/// 创建任务列表
|
/// </summary>
|
/// <param name="order">订单对象</param>
|
/// <param name="filteredStocks">筛选后的库存列表</param>
|
/// <returns>任务列表</returns>
|
private (List<Dt_Task>, Dt_OutOrder orderDetail) CreateTasks(Dt_OutOrder order, List<Dt_BillGroupStock> filteredStocks)
|
{
|
var tasks = new List<Dt_Task>();
|
|
foreach (var stock in filteredStocks)
|
{
|
// 如果已分配数量达到出库数量，停止分配
|
if (order.OrderDetailList.AllocatedQuantity >= order.OrderDetailList.OutboundQuantity)
|
break;
|
|
// 如果托盘任务已存在，跳过
|
if (_taskService.IsExist(stock.PalletCode))
|
continue;
|
|
// 创建任务
|
tasks.Add(new Dt_Task
|
{
|
CreateDate = DateTime.Now, // 创建时间
|
Creater = "System", // 创建人
|
CurrentAddress = stock.LocationCode, //当前位置
|
Dispatchertime = DateTime.Now, //调度时间（任务下发时间）
|
Grade = 1, // 等级
|
InboundNo = stock.InboundNo, //单据编号
|
MaterialNo = stock.MaterialNo, // 物料号
|
NextAddress = stock.LocationCode, // 下一位置
|
PalletCode = stock.PalletCode, //托盘号
|
Remark = stock.Remark, //备注
|
Roadway = stock.Remark, //巷道
|
SourceAddress = stock.LocationCode, //来源位置
|
TargetAddress = order.OrderDetailList.Remarks, //目标地址
|
TaskNum = 1001, //任务号
|
TaskState = TaskStateConst.PendingDispatch.ToString(), //任务状态
|
TaskType = TaskTypeConst.WholeOutbound.ToString(), //任务类型
|
});
|
|
// 更新已分配数量
|
order.OrderDetailList.AllocatedQuantity++;
|
}
|
|
return (tasks, order);
|
}
|
|
/// <summary>
|
/// 更新库存状态
|
/// </summary>
|
/// <param name="filteredStocks">筛选后的库存列表</param>
|
/// <param name="order">订单对象</param>
|
/// <returns>更新后的库存列表</returns>
|
private List<Dt_BillGroupStock> UpdateStocks(List<Dt_BillGroupStock> filteredStocks, Dt_OutOrder order)
|
{
|
var updatedStocks = new List<Dt_BillGroupStock>();
|
var orderDetail = order.OrderDetailList;
|
int index = 0;
|
|
foreach (var stock in filteredStocks)
|
{
|
// 如果已分配数量达到出库数量，停止分配
|
if (index >= orderDetail.OutboundQuantity)
|
{
|
break;
|
}
|
|
// 更新库存状态
|
stock.LocationInfo.IsLocked = true;
|
stock.LocationInfo.Status = 0;
|
stock.State = "3";
|
updatedStocks.Add(stock);
|
}
|
|
return updatedStocks;
|
}
|
|
/// <summary>
|
/// 创建订单库存列表
|
/// </summary>
|
/// <param name="stock">筛选后的库存列表</param>
|
/// <param name="order">订单对象</param>
|
/// <param name="task">任务列表</param>
|
/// <returns>订单库存列表</returns>
|
private List<Dt_OutOrderAndStock> CreateOrderStock(List<Dt_BillGroupStock> stock, Dt_OutOrder order, List<Dt_Task> task)
|
{
|
var orderStocks = new List<Dt_OutOrderAndStock>();
|
for (int i = 0; i < task.Count; i++)
|
{
|
orderStocks.Add(new Dt_OutOrderAndStock()
|
{
|
AllocatedQuantity = order.OrderDetailList.AllocatedQuantity,
|
MaterialNo = stock[i].MaterialNo,
|
MaterialName = order.OrderDetailList.MaterialName,
|
OrderNumber = order.OrderNumber,
|
OutboundQuantity = order.OrderDetailList.OutboundQuantity,
|
PalletCode = stock[i].PalletCode,
|
PalletQuantity = stock[i].StockDetailList.PalletQuantity,
|
State = stock[i].State,
|
BatchNumber = order.OrderDetailList.BatchNumber,
|
CompletedQuantity = order.OrderDetailList.CompletedQuantity,
|
Creater = "System",
|
CreateDate = DateTime.Now,
|
GroupId = stock[i].GroupId,
|
GroupDetailId = stock[i].StockDetailList.GroupDetailId,
|
LocationCode = stock[i].LocationInfo.LocationID,
|
OutOrderDetailId = order.OrderDetailList.Id,
|
OutOrderId = order.Id,
|
});
|
}
|
return orderStocks;
|
}
|
|
#endregion private内部方法
|
}
|
