947 lines
37 KiB
C#
947 lines
37 KiB
C#
using JSMachine.WMS.App.Dto;
|
||
using JSMachine.WMS.App.Dto.Enum;
|
||
using JSMachine.WMS.App.IService;
|
||
using JSMachine.WMS.Business.Common.IService;
|
||
using JSMachine.WMS.Business.StockOut.IService;
|
||
using JSMachine.WMS.Business.StockOut.Models;
|
||
using JSMachine.WMS.Domain.Entity;
|
||
using JSMachine.WMS.Infrastructure;
|
||
using JSMachine.WMS.Infrastructure.Helper;
|
||
using JSMachine.WMS.PLC.ModbusImpl.Elevator.ModbusIO.Read;
|
||
using JSMachine.WMS.PLC.ModbusImpl.Elevator.Model;
|
||
using JSMachine.WMS.RPC.ErpRPC.Dto.In;
|
||
using JSMachine.WMS.RPC.ErpRPC.Dto.In.XRBusinessResult;
|
||
using JSMachine.WMS.RPC.ErpRPC.Dto.Out;
|
||
using JSMachine.WMS.RPC.ErpRPC.Dto.Out.XRBusinessResult;
|
||
using Microsoft.EntityFrameworkCore.Metadata.Internal;
|
||
using NPOI.SS.Formula.Functions;
|
||
using SqlSugar;
|
||
|
||
namespace JSMachine.WMS.Business.StockOut.ServiceImpl
|
||
{
|
||
/// <summary>
|
||
/// 出库服务类
|
||
/// </summary>
|
||
public class StockOutService : IStockOutService
|
||
{
|
||
private IERPTaskService _erpTaskService;
|
||
private IStorageRackService _storageRackService;
|
||
private IAGVTaskService _agvTaskService;
|
||
private ICommonService _commonService;
|
||
public StockOutService(
|
||
IERPTaskService erpTaskService,
|
||
IStorageRackService storageRackService,
|
||
IAGVTaskService agvTaskService,
|
||
ICommonService commonService)
|
||
{
|
||
_erpTaskService = erpTaskService;
|
||
_storageRackService = storageRackService;
|
||
_agvTaskService = agvTaskService;
|
||
_commonService = commonService;
|
||
}
|
||
|
||
#region 销售出库
|
||
/// <summary>
|
||
/// 销售出库
|
||
/// </summary>
|
||
/// <param name="erpSaleOutParam"></param>
|
||
/// <returns></returns>
|
||
public async Task<string> Stockout(StockOutParam stockOutParam)
|
||
{
|
||
//1.验证参数,检查销售订单号是否重复
|
||
//(同批次物料库存（排除锁定禁用）+同批次erp任务(状态为未完结且一天内的)关联的agv任务总数+同批次撤单总数)-erp出库命令总数<=本次出库数
|
||
//3.生成erp任务
|
||
|
||
//1.查询物料信息是否存在 (批次、数量)
|
||
//2.退库区库位是否有货(若全部有货，则全部更新成无货)
|
||
//3.生成ErpTask
|
||
string errMsg = string.Empty;
|
||
|
||
errMsg = await ValidateStockOutParam(stockOutParam);
|
||
if(!string.IsNullOrEmpty(errMsg))
|
||
{
|
||
LogHelper.Warn(errMsg);
|
||
return errMsg;
|
||
}
|
||
|
||
errMsg = await CalStockQty(stockOutParam);
|
||
if (!string.IsNullOrEmpty(errMsg))
|
||
{
|
||
LogHelper.Warn($"出库业务：批次号为{stockOutParam.materiaBatch}的库存不足，出库失败！");
|
||
return errMsg;
|
||
}
|
||
|
||
//生成ErpTask
|
||
bool res = await CreateStockOutErpTask(stockOutParam);
|
||
if (!res)
|
||
{
|
||
errMsg = "出库业务，生成Erp任务，数据库操作失败！";
|
||
LogHelper.Warn(errMsg);
|
||
return errMsg;
|
||
}
|
||
return errMsg;
|
||
}
|
||
|
||
private TaskTypeEnum CalStockOutTaskType(StockOutParam stockOutParam)
|
||
{
|
||
TaskTypeEnum taskType = 0;
|
||
|
||
if (stockOutParam.transport == (int)TransportEnum.SouthArea ||
|
||
stockOutParam.transport == (int)TransportEnum.NorthArea ||
|
||
stockOutParam.transport == (int)TransportEnum.MiddleOutArea)
|
||
{
|
||
taskType = TaskTypeEnum.SaleOut;
|
||
}
|
||
|
||
if (stockOutParam.transport == (int)TransportEnum.ReturnStockArea)
|
||
{
|
||
if(string.IsNullOrEmpty(stockOutParam.produceReturnCode))
|
||
stockOutParam.produceReturnCode = stockOutParam.saleNo;
|
||
|
||
stockOutParam.saleNo = null;
|
||
taskType = TaskTypeEnum.ProductionOut;
|
||
}
|
||
|
||
return taskType;
|
||
}
|
||
|
||
private async Task<string> ValidateStockOutParam(StockOutParam stockOutParam)
|
||
{
|
||
TaskTypeEnum taskType = CalStockOutTaskType(stockOutParam);
|
||
|
||
if (taskType == 0)
|
||
return "出库码头值错误";
|
||
|
||
string errMsg = string.Empty;
|
||
if (stockOutParam.num <= 0)
|
||
{
|
||
errMsg = "出库数要大于0！";
|
||
LogHelper.Warn(errMsg);
|
||
}
|
||
if (string.IsNullOrEmpty(stockOutParam.materiaBatch))
|
||
{
|
||
errMsg = "批次号不能为空！";
|
||
LogHelper.Warn(errMsg);
|
||
}
|
||
|
||
if (taskType == TaskTypeEnum.SaleOut && string.IsNullOrEmpty(stockOutParam.saleNo))
|
||
{
|
||
errMsg = "销售单号不能为空！";
|
||
LogHelper.Warn(errMsg);
|
||
}
|
||
|
||
if (taskType == TaskTypeEnum.ProductionOut && string.IsNullOrEmpty(stockOutParam.produceReturnCode))
|
||
{
|
||
errMsg = "生产退库单号不能为空！";
|
||
LogHelper.Warn(errMsg);
|
||
}
|
||
|
||
if (taskType == TaskTypeEnum.SaleOut)
|
||
{
|
||
bool exist = await _erpTaskService.Exist(p => p.SaleNo == stockOutParam.saleNo);
|
||
if (exist)
|
||
{
|
||
errMsg = $"销售单号{stockOutParam.saleNo}重复！";
|
||
LogHelper.Warn(errMsg);
|
||
}
|
||
}
|
||
|
||
if (taskType == TaskTypeEnum.ProductionOut)
|
||
{
|
||
bool exist = await _erpTaskService.Exist(p => p.ProduceReturnCode == stockOutParam.produceReturnCode);
|
||
if (exist)
|
||
{
|
||
errMsg = $"生产退库单号{stockOutParam.produceReturnCode}重复！";
|
||
LogHelper.Warn(errMsg);
|
||
}
|
||
}
|
||
|
||
return errMsg;
|
||
}
|
||
private async Task<string> CalStockQty(StockOutParam stockOutParam)
|
||
{
|
||
List<StorageRackDto> storageRacks = await _storageRackService.GetListByExpression(p =>
|
||
p.MateriaBatch == stockOutParam.materiaBatch &&
|
||
!p.IsLock &&
|
||
!p.IsDisabled &&
|
||
p.Transport == TransportEnum.NormalArea);
|
||
|
||
if(storageRacks.IsNullOrEmpty())
|
||
{
|
||
return "无可用库存";
|
||
}
|
||
|
||
List<ERPTaskDto> erpTaks = await _erpTaskService.GetListByExpression(p =>
|
||
p.CreationTime >= DateTime.Now.AddDays(-1) &&
|
||
(p.TaskType == TaskTypeEnum.SaleOut || p.TaskType == TaskTypeEnum.ProductionOut) &&
|
||
p.TaskStatus == TaskStatusEnum.InExecution &&
|
||
p.MateriaBatch == stockOutParam.materiaBatch);
|
||
|
||
int stockQty= storageRacks.Sum(p=>p.MateriaNum);
|
||
int taskTotalNum = 0;
|
||
int cancelTotalNum = 0;
|
||
|
||
if (!erpTaks.IsNullOrEmpty())
|
||
{
|
||
cancelTotalNum = erpTaks.Sum(p=>p.ErpCancelNum);
|
||
|
||
List<AGVTaskDto> agvtTasks = await _agvTaskService
|
||
.GetListByExpression(p => erpTaks.Select(x => x.Id).Contains(p.ErpTaskId));
|
||
|
||
taskTotalNum = agvtTasks.GroupBy(p=>p.BarCode).Select(p=>p.First()).Sum(p=>p.MateriaNum);
|
||
}
|
||
|
||
bool enough = stockQty + taskTotalNum + cancelTotalNum - erpTaks.Sum(p => p.ErpOrderNum) >= stockOutParam.num;
|
||
return enough ? "" : "库存不足";
|
||
}
|
||
|
||
/// <summary>
|
||
/// 根据销售出库单，扣减库存
|
||
/// </summary>
|
||
/// <param name="saleNo"></param>
|
||
/// <param name="taskType"></param>
|
||
/// <returns></returns>
|
||
private async Task<SaleOutStockDto> GetSumStockNum(string saleNo, TaskTypeEnum taskType)
|
||
{
|
||
var stockResult = new SaleOutStockDto();
|
||
var erpTask = new ERPTaskDto();
|
||
|
||
//销售出库
|
||
if (taskType == TaskTypeEnum.SaleOut)
|
||
{
|
||
erpTask = await _erpTaskService.GetSingalByExpression(p => p.SaleNo == saleNo);
|
||
}
|
||
|
||
//生产退库
|
||
else if (taskType == TaskTypeEnum.ProductionOut)
|
||
{
|
||
erpTask = await _erpTaskService.GetSingalByExpression(p => p.ProduceReturnCode == saleNo);
|
||
}
|
||
|
||
if (erpTask != null)
|
||
{
|
||
var erpOrderNum = erpTask.ErpOrderNum;
|
||
stockResult.SumCancelNum = erpTask.ErpCancelNum;
|
||
|
||
stockResult.SumReulstNum = erpOrderNum - erpTask.ErpCancelNum;
|
||
}
|
||
return stockResult;
|
||
}
|
||
|
||
|
||
/// <summary>
|
||
/// 销售出库，计算目标库位
|
||
/// </summary>
|
||
/// <param name="transport"></param>
|
||
/// <returns></returns>
|
||
public async Task<StorageRackDto> CalculateDestWarehouse_SaleOut(TransportEnum transport)
|
||
{
|
||
//1 出库区是否有同批次货物，有则查看其列上是否有空余库位
|
||
//2 锁定目标库位
|
||
StorageRackDto destStorageRack = null;
|
||
if (transport==TransportEnum.MiddleOutArea)
|
||
{
|
||
destStorageRack = await CalculateDestWarehouse_SaleOutMiddle();
|
||
return destStorageRack;
|
||
}
|
||
|
||
//所有出库区库位
|
||
List<StorageRackDto> wareHouses = await _storageRackService.GetListByExpression(p =>
|
||
p.Floor == FloorEnum.FirstFloor &&
|
||
p.Transport == transport);
|
||
|
||
//没有空库位
|
||
if (wareHouses.All(p => p.IsLock || p.IsDisabled))
|
||
{
|
||
|
||
var clearWardHoses = wareHouses.OrderBy(p => p.AreaNumSort).ToList();
|
||
foreach (var item in clearWardHoses)
|
||
{
|
||
item.MateriaBatch = "";
|
||
item.MateriaNum = 0;
|
||
|
||
item.OrderNo = "";
|
||
item.MateriaName = "";
|
||
item.MateriaType = "";
|
||
item.MateriaCode = "";
|
||
item.BarCode = "";
|
||
item.IsLock = false;
|
||
}
|
||
await _storageRackService.EditBatch(clearWardHoses);
|
||
|
||
//锁定库位
|
||
var tempStorageRack = clearWardHoses.OrderBy(p => p.AreaNumSort).ThenByDescending(p => p.NumSort).FirstOrDefault();
|
||
|
||
destStorageRack = tempStorageRack;
|
||
destStorageRack.IsLock = true;
|
||
await _storageRackService.EditSingal(destStorageRack);
|
||
}
|
||
else
|
||
{
|
||
//有空库位，按照AreaNumSort、NumSort排序，依次放
|
||
var tempWareHouses = wareHouses.Where(p => !p.IsLock && !p.IsDisabled).ToList();
|
||
var sortWareHoses = tempWareHouses.OrderBy(p => p.AreaNumSort).ThenByDescending(p => p.NumSort).ToList();
|
||
foreach (var item in sortWareHoses)
|
||
{
|
||
if (string.IsNullOrEmpty(item.MateriaBatch))
|
||
{
|
||
//锁定库位
|
||
item.IsLock = true;
|
||
destStorageRack = item;
|
||
break;
|
||
}
|
||
}
|
||
|
||
//锁定库位
|
||
await _storageRackService.EditSingal(destStorageRack);
|
||
}
|
||
return destStorageRack;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 计算中间出库区的出库目标库位
|
||
/// </summary>
|
||
/// <returns></returns>
|
||
public async Task<StorageRackDto> CalculateDestWarehouse_SaleOutMiddle()
|
||
{
|
||
//获取楼层的所有库位
|
||
List<StorageRackDto> wareHouses = await _storageRackService.GetListByExpression(p =>
|
||
p.Floor == FloorEnum.FirstFloor && p.Transport == TransportEnum.MiddleOutArea);
|
||
|
||
if (wareHouses.IsNullOrEmpty())
|
||
{
|
||
LogHelper.Warn($"中间出库区没有空余库位");
|
||
return null;
|
||
}
|
||
|
||
wareHouses = wareHouses.OrderBy(p => p.AreaNumSort).OrderBy(p => p.ReservoirAreaColumnId).ToList();
|
||
|
||
if (wareHouses.IsNullOrEmpty())
|
||
return null;
|
||
|
||
var groupByColumn = wareHouses.GroupBy(p => p.ReservoirAreaColumnId);
|
||
StorageRackDto destStorageRack = null;
|
||
foreach (var columnGroup in groupByColumn)
|
||
{
|
||
bool unlokedColumn = columnGroup.All(p => !p.IsLock && !p.IsDisabled);
|
||
if (unlokedColumn)
|
||
{
|
||
destStorageRack = columnGroup.OrderByDescending(p => p.NumSort).FirstOrDefault(p => string.IsNullOrEmpty(p.BarCode));
|
||
if (destStorageRack != null)
|
||
break;
|
||
|
||
}
|
||
}
|
||
|
||
return destStorageRack;
|
||
}
|
||
|
||
/// <summary>
|
||
///出库，生成ErpTask
|
||
/// </summary>
|
||
/// <param name="erpSaleOutParam"></param>
|
||
/// <returns></returns>
|
||
private async Task<bool> CreateStockOutErpTask(StockOutParam stockOutParam)
|
||
{
|
||
TaskTypeEnum taskType = CalStockOutTaskType(stockOutParam);
|
||
|
||
var erpTask = new ERPTaskDto
|
||
{
|
||
BarCode = stockOutParam.barCode,
|
||
SaleNo = stockOutParam.saleNo,
|
||
ProduceReturnCode = stockOutParam.produceReturnCode,
|
||
CustomName = stockOutParam.customName,
|
||
MateriaName = stockOutParam.materiaName,
|
||
MateriaType = stockOutParam.materiaType,
|
||
MateriaBatch = stockOutParam.materiaBatch,
|
||
MateriaCode = stockOutParam.materiaCode,
|
||
Transport = (TransportEnum)stockOutParam.transport,
|
||
ErpOrderNum = stockOutParam.num,
|
||
|
||
Priority = PriorityEnum.High,
|
||
TaskStatus = TaskStatusEnum.Initial,
|
||
TaskType = taskType,
|
||
};
|
||
|
||
bool res = await _erpTaskService.Add(erpTask);
|
||
return res;
|
||
}
|
||
|
||
private async Task<StorageRackDto> CalculateOutMaterial(ERPTaskDto erpTask)
|
||
{
|
||
//1. 筛选出该批次的所有物料库位
|
||
//2. 按照列号分组,并按照同一列的拖数从小到大排序(优先出拖数少的列)
|
||
//3. 存在锁定列（同批次物料），先判断锁定列是否足够
|
||
//3.1 如果锁定列足够，则返回空，等待解锁
|
||
//3.2 如果锁定列不够，取第一个未锁定列
|
||
//3.3 未锁定列前面存在不同批次物料，则生成中转掏货任务
|
||
//3.4 未锁定列前面不存在不同批次物料，则直接出库
|
||
List<StorageRackDto> storageRacksAll = await _storageRackService
|
||
.GetListByExpression(p => p.Transport == TransportEnum.NormalArea);
|
||
|
||
if (storageRacksAll.IsNullOrEmpty())
|
||
return null;
|
||
|
||
List<StorageRackDto> storageRacksSameBatch = storageRacksAll
|
||
.Where(p => p.MateriaBatch == erpTask.MateriaBatch && !p.IsDisabled)
|
||
.ToList();
|
||
|
||
if (storageRacksSameBatch.IsNullOrEmpty())
|
||
return null;
|
||
|
||
var groupByCol = storageRacksSameBatch
|
||
.GroupBy(p => p.ReservoirAreaColumnId)
|
||
.OrderBy(p => p.Count());
|
||
|
||
var groupByColInclude = storageRacksAll
|
||
.Where(p => storageRacksSameBatch.Select(x => x.ReservoirAreaColumnId).Distinct().Contains(p.ReservoirAreaColumnId))
|
||
.GroupBy(p => p.ReservoirAreaColumnId)
|
||
.OrderBy(p => p.Count());
|
||
|
||
List<AGVTaskDto> agvTasks = await _commonService.GetCreatedAgvTasksFromErpTask(erpTask, erpTask.TaskType);
|
||
//已生成任务的数量
|
||
int createdNum = agvTasks.Sum(p => p.MateriaNum);
|
||
//还需要的数量
|
||
int stillNeedNum = erpTask.ErpOrderNum - erpTask.ErpCancelNum - createdNum;
|
||
|
||
var lockedCols = groupByColInclude.Where(p => p.Any(x => x.IsLock));
|
||
int unlockedInLockedCol = lockedCols.SelectMany(p => p).Where(p => !p.IsLock && !p.IsDisabled).Sum(p => p.MateriaNum);
|
||
if (unlockedInLockedCol >= stillNeedNum)
|
||
{
|
||
LogHelper.Info($"出库业务,已锁定的列上物料足够，等待列解锁后继续出库");
|
||
return null;
|
||
}
|
||
|
||
var unlockedCol = groupByColInclude.Where(p => p.All(x => !x.IsLock)).OrderBy(p => p.Count()).FirstOrDefault();
|
||
|
||
if (unlockedCol == null)
|
||
{
|
||
LogHelper.Info($"出库业务,已锁定列上物料不够，但不存在未锁定列物料，确认出库命令是否有误");
|
||
return null;
|
||
}
|
||
|
||
//判断该列上是否存在不同批次未锁定的物料,有则掏货
|
||
//判断该列上是否存在不同批次被锁定的物料,有则等待解锁
|
||
|
||
StorageRackDto destMaterial = unlockedCol.OrderBy(p => p.NumSort).First(p=>!string.IsNullOrEmpty(p.BarCode));
|
||
List<StorageRackDto> allInThisCol = unlockedCol.ToList();
|
||
|
||
if (allInThisCol.Any(p => p.IsLock))
|
||
{
|
||
LogHelper.Info($"出库业务 列 {destMaterial.ReservoirAreaColumnId} 上存在被锁定的物料，将等待解锁后继续取后续的物料");
|
||
return null;
|
||
}
|
||
|
||
List<StorageRackDto> diffrentBatchInThisCol = allInThisCol
|
||
.Where(p => !string.IsNullOrEmpty(p.MateriaBatch) && p.MateriaBatch != destMaterial.MateriaBatch)
|
||
.ToList();
|
||
|
||
if (diffrentBatchInThisCol.IsNullOrEmpty())
|
||
return destMaterial;
|
||
|
||
List<StorageRackDto> diffrentBatchInThisColFront = diffrentBatchInThisCol
|
||
.Where(p => p.NumSort < destMaterial.NumSort)
|
||
.ToList();
|
||
|
||
if (diffrentBatchInThisColFront.IsNullOrEmpty())
|
||
return destMaterial;
|
||
|
||
StorageRackDto diffrentBatchInThisColFirst = diffrentBatchInThisColFront.OrderBy(p => p.NumSort).First();
|
||
if (diffrentBatchInThisColFirst.IsLock)
|
||
{
|
||
LogHelper.Info($"出库业务 列 {diffrentBatchInThisColFirst.ReservoirAreaColumnId} 上存在不同批次的前序物料，且该前序物料被锁定，" +
|
||
$"将等待物料解锁后继续取后续的物料");
|
||
return null;
|
||
}
|
||
|
||
//掏货
|
||
return diffrentBatchInThisColFirst;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 销售出库，根据ERPTask生成二楼/一楼 AgvTask
|
||
/// </summary>
|
||
/// <param name="erpTask">erp任务</param>
|
||
/// <returns></returns>
|
||
public async Task<bool> CreateAgvTaskSecondFloor_SaleOut(ERPTaskDto erpTask)
|
||
{
|
||
//1.计算要出库的物料
|
||
//2.如果物料在一楼，直接生成到出库码头的任务
|
||
//3.如果物料在二楼
|
||
//3.1 有可用提升机库位，生成到提升机的任务
|
||
//3.2 没有可用提升机库位，生成中转任务
|
||
|
||
StorageRackDto stockOutMaterial = await CalculateOutMaterial(erpTask);
|
||
if (stockOutMaterial == null)
|
||
{
|
||
LogHelper.Warn($"出库业务，批次号 {erpTask.MateriaBatch} 暂无可直接出库的物料");
|
||
_ = _erpTaskService.UpdateTaskMsg(erpTask.Id, $"暂无可直接出库的物料");
|
||
return false;
|
||
}
|
||
|
||
if (stockOutMaterial.MateriaBatch == erpTask.MateriaBatch)
|
||
{
|
||
if (stockOutMaterial.Floor == FloorEnum.FirstFloor)
|
||
return await CreateTaskToWharf(stockOutMaterial, erpTask);
|
||
else
|
||
return await CreateTaskToElevator(stockOutMaterial, erpTask);
|
||
|
||
}
|
||
else
|
||
{
|
||
return await CreateTaskToTransfer(stockOutMaterial, TaskTypeEnum.RemoveStockOutObstruction, erpTask);
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 生成直接去出库码头的任务
|
||
/// </summary>
|
||
/// <returns></returns>
|
||
private async Task<bool> CreateTaskToWharf(StorageRackDto stockOutWarehouse, ERPTaskDto erpTask)
|
||
{
|
||
if(stockOutWarehouse.Floor!=FloorEnum.FirstFloor)
|
||
{
|
||
return false;
|
||
}
|
||
|
||
//2.计算目标库位
|
||
StorageRackDto wareHouse = await CalculateDestWarehouse_SaleOut(erpTask.Transport);
|
||
if (wareHouse == null)
|
||
{
|
||
LogHelper.Warn($"批次号 {erpTask.MateriaBatch} 暂无合适的码头库位");
|
||
_ = _erpTaskService.UpdateTaskMsg(erpTask.Id, "暂无合适的码头库位");
|
||
return false;
|
||
}
|
||
|
||
AGVTaskDto agvTask = new()
|
||
{
|
||
ErpTaskId = erpTask.Id,
|
||
BarCode = stockOutWarehouse.BarCode,
|
||
OrderNo = stockOutWarehouse.OrderNo,
|
||
CustomName = stockOutWarehouse.CustomName,
|
||
MateriaName = stockOutWarehouse.MateriaName,
|
||
MateriaType = stockOutWarehouse.MateriaType,
|
||
MateriaNum = stockOutWarehouse.MateriaNum,
|
||
MateriaBatch = stockOutWarehouse.MateriaBatch,
|
||
MateriaCode = stockOutWarehouse.MateriaCode,
|
||
TaskType = erpTask.TaskType,
|
||
TaskStatus = TaskStatusEnum.Initial,
|
||
Priority = PriorityEnum.High,
|
||
Floor = FloorEnum.FirstFloor,
|
||
|
||
StartPositionCode = stockOutWarehouse.StorageRackNo,
|
||
EndPositionCode = wareHouse.StorageRackNo,
|
||
|
||
Transport = erpTask.Transport
|
||
};
|
||
|
||
//锁定终点库位
|
||
await _storageRackService.Lock(wareHouse);
|
||
|
||
//锁定起点库位
|
||
await _storageRackService.Lock(stockOutWarehouse);
|
||
|
||
_ = _erpTaskService.UpdateTaskMsg(erpTask.Id, "");
|
||
|
||
//生成agvTask
|
||
return await _agvTaskService.Add(agvTask);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 生成去提升机的任务
|
||
/// </summary>
|
||
/// <returns></returns>
|
||
private async Task<bool> CreateTaskToElevator(StorageRackDto stockOutWarehouse, ERPTaskDto erpTask)
|
||
{
|
||
if (stockOutWarehouse.Floor != FloorEnum.SecondFloor)
|
||
{
|
||
return false;
|
||
}
|
||
|
||
StorageRackDto elevator = await _commonService.GetUsableElevator(FloorEnum.SecondFloor,2);
|
||
if (elevator == null)
|
||
{
|
||
LogHelper.Warn("无可用提升机库位");
|
||
return false;
|
||
//return await CreateTaskToTransfer(stockOutWarehouse, TaskTypeEnum.TransferStockOut, erpTask);
|
||
}
|
||
|
||
await _commonService.CreateAndInsertAgvTask(new Common.Models.AgvTaskCreationParam
|
||
{
|
||
StartPosition = stockOutWarehouse,
|
||
EndPosition = elevator,
|
||
TaskType = erpTask.TaskType,
|
||
ErpTaskId = erpTask.Id,
|
||
StockOutWharf= erpTask.Transport,
|
||
|
||
ErpUploadStatus=ErpUploadStatusEnum.Unnecessary
|
||
});
|
||
_ = _erpTaskService.UpdateTaskMsg(erpTask.Id, "");
|
||
|
||
return true;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 生成去中转区的任务
|
||
/// </summary>
|
||
/// <returns></returns>
|
||
private async Task<bool> CreateTaskToTransfer(StorageRackDto stockOutWarehouse, TaskTypeEnum taskType, ERPTaskDto erpTask)
|
||
{
|
||
bool bRet = await _commonService.CreateAgvTaskToTransferArea(stockOutWarehouse, taskType, erpTask);
|
||
if (!bRet)
|
||
{
|
||
LogHelper.Error($"出库业务 erpTaskId {erpTask.Id} 生成中转任务失败，" +
|
||
$"批次 {stockOutWarehouse.MateriaBatch}" +
|
||
$"合格证号 {stockOutWarehouse.BarCode}");
|
||
|
||
_ = _erpTaskService.UpdateTaskMsg(erpTask.Id, $"{taskType.GetDescription()}任务生成失败");
|
||
}
|
||
else
|
||
{
|
||
_ = _erpTaskService.UpdateTaskMsg(erpTask.Id, "中转进行中");
|
||
|
||
await _storageRackService.Lock(stockOutWarehouse);
|
||
}
|
||
return bRet;
|
||
}
|
||
|
||
|
||
|
||
#endregion
|
||
|
||
#region 搬运物料
|
||
|
||
/// <summary>
|
||
/// 物料搬运，起点库位验证
|
||
/// </summary>
|
||
/// <param name="startRankNo"></param>
|
||
/// <returns></returns>
|
||
public async Task<ApiResult<string>> CheckCarryStartRankNo(string startRankNo)
|
||
{
|
||
var result = new ApiResult<string>() { ResultCode = "500" };
|
||
if (string.IsNullOrEmpty(startRankNo))
|
||
{
|
||
result.ErrorMsg = $"请扫描起点库位码！";
|
||
return result;
|
||
}
|
||
//起点物料信息
|
||
StorageRackDto startMaterial = await _storageRackService.GetSingalByExpression(p => p.StorageRackNo == startRankNo);
|
||
if (startMaterial == null)
|
||
{
|
||
result.ErrorMsg = $"起点库位 {startRankNo}不存在，无法搬运！";
|
||
return result;
|
||
}
|
||
else
|
||
{
|
||
if (startMaterial.IsLock)
|
||
{
|
||
result.ErrorMsg = $"起点库位 {startRankNo}被锁定，无法搬运！";
|
||
return result;
|
||
}
|
||
if (startMaterial.IsDisabled)
|
||
{
|
||
result.ErrorMsg = $"起点库位 {startRankNo}被禁用，无法搬运！";
|
||
return result;
|
||
}
|
||
if (startMaterial.Transport != TransportEnum.NormalArea)
|
||
{
|
||
result.ErrorMsg = $"起点库位 {startRankNo}不在存储区，无法搬运！";
|
||
return result;
|
||
}
|
||
if (startMaterial.MateriaNum <= 0)
|
||
{
|
||
result.ErrorMsg = $"起点库位 {startRankNo}没有物料信息，无法搬运！";
|
||
return result;
|
||
}
|
||
}
|
||
|
||
result.ResultCode = "200";
|
||
return result;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 物料搬运，终点库位验证
|
||
/// </summary>
|
||
/// <param name="endRankNo"></param>
|
||
/// <returns></returns>
|
||
public async Task<ApiResult<string>> CheckCarryEndRankNo(string endRankNo)
|
||
{
|
||
var result = new ApiResult<string>() { ResultCode = "500" };
|
||
if (string.IsNullOrEmpty(endRankNo))
|
||
{
|
||
result.ErrorMsg = $"请扫描终点库位码！";
|
||
return result;
|
||
}
|
||
//终点物料信息
|
||
StorageRackDto endMaterial = await _storageRackService.GetSingalByExpression(p => p.StorageRackNo == endRankNo);
|
||
if (endMaterial == null)
|
||
{
|
||
result.ErrorMsg = $"终点库位 {endRankNo}不存在，无法搬运！";
|
||
return result;
|
||
}
|
||
else
|
||
{
|
||
if (endMaterial.IsLock)
|
||
{
|
||
result.ErrorMsg = $"终点库位 {endMaterial}被锁定，无法搬运！";
|
||
return result;
|
||
}
|
||
if (endMaterial.IsDisabled)
|
||
{
|
||
result.ErrorMsg = $"终点库位 {endMaterial}被禁用，无法搬运！";
|
||
return result;
|
||
}
|
||
//if (endMaterial.Transport != TransportEnum.NormalArea)
|
||
//{
|
||
// result.ErrorMsg = $"终点库位 {endRankNo}不在存储区，无法搬运！";
|
||
// return result;
|
||
//}
|
||
//if (endMaterial.MateriaNum > 0)
|
||
//{
|
||
// result.ErrorMsg = $"终点库位 {endRankNo}存在物料信息，无法搬运！";
|
||
// return result;
|
||
//}
|
||
}
|
||
|
||
result.ResultCode = "200";
|
||
return result;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 搬运物料
|
||
/// 同楼层的存储区，才能搬运
|
||
/// </summary>
|
||
/// <param name="carryInParam"></param>
|
||
/// <returns></returns>
|
||
public async Task<ApiResult<string>> CarryMaterialInfo(CarryInParam carryInParam)
|
||
{
|
||
//1.查询起点物料信息是否存在
|
||
//2.查询终点物料信息是否存在
|
||
//3.直接生成AgvTask
|
||
|
||
|
||
var result = new ApiResult<string>() { ResultCode = "500" };
|
||
|
||
//起点库位信息
|
||
StorageRackDto start = await _storageRackService.GetSingalByExpression(p => !p.IsLock && !p.IsDisabled && p.StorageRackNo == carryInParam.StartStorageRackNo);
|
||
|
||
//终点库位信息
|
||
StorageRackDto end = await _storageRackService.GetSingalByExpression(p => !p.IsLock && !p.IsDisabled && p.StorageRackNo == carryInParam.EndStorageRackNo);
|
||
|
||
//是否存在，起点、终点正在执行的AgvTask
|
||
var isExsit = await _agvTaskService.Exist(p => p.StartPositionCode == start.StorageRackNo &&
|
||
p.EndPositionCode == end.StorageRackNo &&
|
||
p.TaskType == TaskTypeEnum.Carry &&
|
||
(p.TaskStatus == TaskStatusEnum.Initial || p.TaskStatus == TaskStatusEnum.InExecution));
|
||
if (isExsit)
|
||
{
|
||
result.ErrorMsg = $"已经存在起点{start.StorageRackNo} 到 终点{end.StorageRackNo}的搬运任务";
|
||
return result;
|
||
}
|
||
|
||
//直接生成AgvTask
|
||
bool res = await CreateAgvTask_Carry(start, end);
|
||
if (!res)
|
||
{
|
||
result.ErrorMsg = $"搬运物料，生成Agv任务，数据库操作失败！";
|
||
return result;
|
||
}
|
||
else
|
||
{
|
||
result.ResultCode = "200";
|
||
return result;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 搬运物料，生成AgvTask
|
||
/// </summary>
|
||
/// <param name="start"></param>
|
||
/// <param name="end"></param>
|
||
/// <returns></returns>
|
||
private async Task<bool> CreateAgvTask_Carry(StorageRackDto start, StorageRackDto end)
|
||
{
|
||
var excuteResult = false;
|
||
AGVTaskDto agvTask = new()
|
||
{
|
||
ErpTaskId = Guid.Empty,
|
||
BarCode = start.BarCode,
|
||
OrderNo = start.OrderNo,
|
||
CustomName = start.CustomName,
|
||
MateriaName = start.MateriaName,
|
||
MateriaType = start.MateriaType,
|
||
MateriaNum = start.MateriaNum,
|
||
MateriaBatch = start.MateriaBatch,
|
||
MateriaCode = start.MateriaCode,
|
||
TaskType = TaskTypeEnum.Carry,
|
||
TaskStatus = TaskStatusEnum.Initial,
|
||
Priority = PriorityEnum.Middle,
|
||
Floor = start.Floor,
|
||
|
||
StartPositionCode = start.StorageRackNo,
|
||
EndPositionCode = end.StorageRackNo,
|
||
Transport = TransportEnum.NormalArea
|
||
};
|
||
|
||
//锁定起点库位
|
||
start.IsLock = true;
|
||
await _storageRackService.EditSingal(start);
|
||
|
||
//锁定终点库位
|
||
end.IsLock = true;
|
||
await _storageRackService.EditSingal(end);
|
||
|
||
//生成agvTask
|
||
excuteResult = await _agvTaskService.Add(agvTask);
|
||
|
||
return excuteResult;
|
||
}
|
||
#endregion
|
||
|
||
#region 出库撤单
|
||
/// <summary>
|
||
/// 出库撤单
|
||
/// 只有销售出库，才能撤单
|
||
/// </summary>
|
||
/// <param name="cancelOrderParam"></param>
|
||
/// <returns></returns>
|
||
public async Task<XRNewResultDto<int>> ErpCancelOrder(ErpCancelOrderParam cancelOrderParam)
|
||
{
|
||
var result = new XRNewResultDto<int>() { success = false, status = 500, data = 0 };
|
||
if (string.IsNullOrEmpty(cancelOrderParam.saleNo))
|
||
{
|
||
result.errors = "销售出库单号不能为空！";
|
||
LogHelper.Warn(result.errors);
|
||
|
||
return result;
|
||
}
|
||
if (string.IsNullOrEmpty(cancelOrderParam.materiaBatch))
|
||
{
|
||
result.errors = "批次号不能为空！";
|
||
LogHelper.Warn(result.errors);
|
||
|
||
return result;
|
||
}
|
||
if (string.IsNullOrEmpty(cancelOrderParam.materiaType))
|
||
{
|
||
result.errors = "物料类型不能为空！";
|
||
LogHelper.Warn(result.errors);
|
||
|
||
return result;
|
||
}
|
||
if (string.IsNullOrEmpty(cancelOrderParam.customName))
|
||
{
|
||
result.errors = "客户名称不能为空！";
|
||
LogHelper.Warn(result.errors);
|
||
|
||
return result;
|
||
}
|
||
if (string.IsNullOrEmpty(cancelOrderParam.materiaName))
|
||
{
|
||
result.errors = "物料名称不能为空！";
|
||
LogHelper.Warn(result.errors);
|
||
|
||
return result;
|
||
}
|
||
|
||
var erpTaskList = await _erpTaskService.GetListByExpression(p => p.SaleNo == cancelOrderParam.saleNo);
|
||
if (erpTaskList.IsNullOrEmpty())
|
||
{
|
||
result.errors = $"销售出库单号{cancelOrderParam.saleNo},不存在任务！";
|
||
LogHelper.Warn(result.errors);
|
||
|
||
return result;
|
||
}
|
||
|
||
var sumCancelNum = erpTaskList == null ? 0 : erpTaskList.Sum(p => p.ErpCancelNum);
|
||
if (sumCancelNum > 0)
|
||
{
|
||
result.errors = $"销售出库单号{cancelOrderParam.saleNo},不能重复撤单！";
|
||
LogHelper.Warn(result.errors);
|
||
|
||
return result;
|
||
}
|
||
|
||
var erpTask = erpTaskList?.FirstOrDefault();
|
||
|
||
if (erpTask.TaskType != TaskTypeEnum.SaleOut)
|
||
{
|
||
result.errors = $"单号{cancelOrderParam.saleNo},不是销售单号,无法撤单";
|
||
LogHelper.Warn(result.errors);
|
||
|
||
return result;
|
||
}
|
||
|
||
if (erpTask.TaskStatus == TaskStatusEnum.Completed)
|
||
{
|
||
result.errors = $"批次号为{cancelOrderParam.materiaBatch} 销售单号为{cancelOrderParam.saleNo},任务已经完成，无法撤单";
|
||
LogHelper.Warn(result.errors);
|
||
|
||
return result;
|
||
}
|
||
var erpCancelNum = await GetErpCancelNum(cancelOrderParam);
|
||
if (erpCancelNum <= 0)
|
||
{
|
||
result.errors = $"批次号为{cancelOrderParam.materiaBatch} 销售单号为{cancelOrderParam.saleNo},没有可以撤回的数量";
|
||
LogHelper.Warn(result.errors);
|
||
|
||
return result;
|
||
}
|
||
//更新Erp出库撤单数量
|
||
if (erpTask != null)
|
||
{
|
||
erpTask.ErpCancelNum = erpCancelNum;
|
||
bool res = await _erpTaskService.EditSingal(erpTask);
|
||
if (!res)
|
||
{
|
||
result.errors = "更新Erp出库撤单数量，数据库操作失败！";
|
||
LogHelper.Warn(result.errors);
|
||
return result;
|
||
}
|
||
}
|
||
result.success = true;
|
||
result.status = 200;
|
||
result.data = erpTask.ErpCancelNum;
|
||
result.message = $"撤单成功：批次号为{cancelOrderParam.materiaBatch} 销售单号为{cancelOrderParam.saleNo},撤单数量为{erpTask.ErpCancelNum}";
|
||
return result;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 根据销售出库单，计算可以撤单的数量
|
||
/// </summary>
|
||
/// <param name="cancelOrderParam"></param>
|
||
/// <returns></returns>
|
||
private async Task<int> GetErpCancelNum(ErpCancelOrderParam cancelOrderParam)
|
||
{
|
||
var result = 0;
|
||
|
||
var erpTask = await _erpTaskService.GetSingalByExpression(p => p.SaleNo == cancelOrderParam.saleNo);
|
||
|
||
if (erpTask != null)
|
||
{
|
||
var agvTaskList = await _agvTaskService.GetListByExpression(p => p.ErpTaskId == erpTask.Id &&
|
||
(p.TaskStatus == TaskStatusEnum.Initial || p.TaskStatus == TaskStatusEnum.InExecution || p.TaskStatus == TaskStatusEnum.Completed) &&
|
||
(p.TaskType == TaskTypeEnum.SaleOut));
|
||
|
||
var sumMateriaNum = 0;
|
||
if (agvTaskList.Count > 0)
|
||
{
|
||
var groupAgvTaskList = agvTaskList.GroupBy(p => p.BarCode);
|
||
foreach (var groupAgvTask in groupAgvTaskList)
|
||
{
|
||
sumMateriaNum += groupAgvTask.FirstOrDefault().MateriaNum;
|
||
}
|
||
}
|
||
|
||
if (erpTask.ErpOrderNum - sumMateriaNum > 0)
|
||
{
|
||
result = erpTask.ErpOrderNum - sumMateriaNum;
|
||
}
|
||
}
|
||
|
||
return result;
|
||
}
|
||
#endregion
|
||
}
|
||
}
|