Files
WMS/HHWMS.Web/Areas/Api/IWCSController.cs
T

697 lines
29 KiB
C#
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using AutoMapper;
using HHWMS.Web.Models;
using HHWMS.Web.Support;
using HHWMS.Web.Support.PLC;
using HslCommunication;
using HslCommunication.Profinet.Siemens;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using WalkingTec.Mvvm.Core;
using Microsoft.Extensions.Caching.Memory;
using HslCommunication.Core;
using WalkingTec.Mvvm.Core.Extensions;
namespace HHWMS.Web
{
/// <summary>
/// 提供给WCS调用接口
/// 调用方向 WCS --> WMS
/// </summary>
[Public]
[ActionDescription("HHWMS.WCSApi")]
[ApiController]
[Route("api/[controller]/[action]"), ApiExplorerSettings(GroupName = "User")]
public class IWCSController : ApiController
{
private readonly IUnitWork _unitWork;
private readonly IMapper _mapper;
private readonly IMemoryCache _cache;
private const int DEBOUNCE_INTERVAL_MS = 1000; // 防抖间隔1秒
public IWCSController(IUnitWork unitWork, IMapper mapper, IMemoryCache cache)
{
_unitWork = unitWork;
_mapper = mapper;
_cache = cache;
}
/// <summary>
/// 防抖处理装饰器
/// </summary>
private async Task<IActionResult> WithDebounce(string key, Func<Task<IActionResult>> action)
{
try
{
// 使用key作为请求标识
string requestKey = $"Debounce_{key}";
// 检查是否存在处理中的相同请求
if (_cache.TryGetValue(requestKey, out DateTime lastRequestTime))
{
var timeSinceLastRequest = DateTime.Now - lastRequestTime;
if (timeSinceLastRequest.TotalMilliseconds < DEBOUNCE_INTERVAL_MS)
{
var remainingSeconds =
Math.Ceiling((DEBOUNCE_INTERVAL_MS - timeSinceLastRequest.TotalMilliseconds) / 1000);
return ApiResultError($"请求过于频繁,请等待{remainingSeconds}秒后重试");
}
}
// 添加或更新缓存(设置防抖间隔时间)
var cacheEntryOptions = new MemoryCacheEntryOptions()
.SetAbsoluteExpiration(TimeSpan.FromMilliseconds(DEBOUNCE_INTERVAL_MS));
_cache.Set(requestKey, DateTime.Now, cacheEntryOptions);
try
{
// 执行实际的业务逻辑
return await action();
}
catch (Exception ex)
{
// 处理失败时移除缓存,允许重试
_cache.Remove(requestKey);
throw;
}
}
catch (Exception ex)
{
return ApiResultError($"处理请求时发生错误: {ex.Message}");
}
}
/// <summary>
/// 满入处理
/// </summary>
[HttpPost]
public IActionResult FullIn(WcsRequest request)
{
var task = _unitWork.FindSingle<TaskHeader>(x => x.TaskNo == request.TaskNo
&& x.Status != TaskStatusEnum.完成
&& x.TaskType != TaskTypeEnum.出库);
if (task == null)
{
return ApiResultError(msg: "未找到任务!");
}
// 更新旧仓位
var oldLoc = _unitWork.FindSingle<Location>(x => x.Code == task.ToLocation);
oldLoc.ContainerCode = "FullIn";
oldLoc.UpdateBy = "FullIn";
oldLoc.UpdateTime = DateTime.Now;
_unitWork.Update(oldLoc);
//查找新仓位
var locationVm = Wtm.CreateVM<LocationVM>();
var res = locationVm.GetMoveLocation(oldLoc);
if (res.Status)
{
string code = res.Data.LocationCode;
var newLoc = _unitWork.FindSingle<Location>(x => x.Code == code);
newLoc.ContainerCode = task.ContainerCode;
newLoc.Status = oldLoc.Status;
newLoc.ContainerStatus = oldLoc.ContainerStatus;
newLoc.Status = LocationStatusEnum.锁定;
newLoc.UpdateTime = DateTime.Now;
_unitWork.Update(newLoc);
task.ToLocation = newLoc.Code;
task.UpdateBy = "FullIn";
task.UpdateTime = DateTime.Now;
_unitWork.Update(task);
return ApiResult(new { LocationCode = res.Data.LocationCode });
}
else
{
return ApiResultError(msg: res.Message);
}
}
/// <summary>
/// 空出处理
/// </summary>
[HttpPost]
public IActionResult EmptyOut(WcsRequest request)
{
var task = _unitWork.FindSingle<TaskHeader>(x => x.TaskNo == request.TaskNo
&& x.Status != TaskStatusEnum.完成);
if (task == null)
{
return ApiResultError(msg: "未找到任务!");
}
//1. 更新容器
var container = _unitWork.FindSingle<Container>(x => x.Code == task.ContainerCode);
container.UpdateBy = "EmptyOut";
container.UpdateTime = DateTime.Now;
_unitWork.Update(container);
//2. 更新库位
var location = _unitWork.FindSingle<Location>(x => x.Code == task.FromLocation);
location.UpdateBy = "EmptyOut";
location.UpdateTime = DateTime.Now;
location.ContainerStatus = LocationStatus.空仓位;
_unitWork.Update(location);
//3. 更新任务
task.UpdateBy = "EmptyOut";
task.UpdateTime = DateTime.Now;
task.ErrorMsg = "空出";
var taskHistory = _mapper.Map<TaskHeaderHistory>(task);
_unitWork.Add(taskHistory);
_unitWork.Delete(task);
//4. 更新库存
_unitWork.BatchUpdate<Inventory>(x => x.ContainerCode == task.ContainerCode, x => new Inventory()
{
LocationCode = "空出",
UpdateBy = "EmptyOut",
UpdateTime = DateTime.Now
});
return ApiResult();
}
/// <summary>
/// 取货错处理
/// </summary>
[HttpPost]
public IActionResult PickError(WcsRequest request)
{
var task = _unitWork.FindSingle<TaskHeader>(x => x.TaskNo == request.TaskNo
&& x.Status != TaskStatusEnum.完成);
if (task == null)
{
return ApiResultError(msg: "未找到任务!");
}
var outLoc = _unitWork.FindSingle<Location>(x => x.Code == task.FromLocation);
var outTask = _unitWork.FindSingle<TaskHeader>(x => x.FromLocation == outLoc.ContiguousCode);
if (outTask != null)
{
return ApiResultError(msg: $"外侧仓位 {outLoc.Code} 已有出库任务!");
}
// 生成外侧仓位的移库任务
var locationVm = Wtm.CreateVM<LocationVM>();
var moveLocRes = locationVm.GetMoveLocation(outLoc);
if (moveLocRes.Status)
{
var taskHeader = new TaskHeader()
{
ZoneId = task.ZoneId,
TaskNo = _unitWork.GetSerialNumber("Move"),
TaskType = TaskTypeEnum.移库,
ContainerCode = outLoc.ContainerCode,
RoadWay = 2,
FromLocation = outLoc.Code,
ToLocation = moveLocRes.Data.LocationCode,
Status = TaskStatusEnum.新建,
CreateBy = "PickError",
CreateTime = DateTime.Now,
};
var sendTaskRes = locationVm.SendWcsTask(taskHeader);
if (sendTaskRes.Status)
{
string code = sendTaskRes.Data.LocationCode;
var moveLoc = _unitWork.FindSingle<Location>(x => x.Code == code);
moveLoc.Status = LocationStatusEnum.锁定;
moveLoc.UpdateBy = "PickError";
moveLoc.UpdateTime = DateTime.Now;
_unitWork.Update(moveLoc);
}
else
{
return ApiResultError(msg: sendTaskRes.Message);
}
}
else
{
return ApiResultError(msg: moveLocRes.Message);
}
return ApiResult();
}
/// <summary>
/// 状态返回(带防抖)
/// </summary>
[Public]
[HttpPost]
public Task<IActionResult> ReturnStatus(WcsRequest request)
{
if (request == null || string.IsNullOrEmpty(request.TaskNo))
{
return Task.FromResult<IActionResult>(ApiResultError("请求参数无效"));
}
return WithDebounce($"TaskStatus_{request.PalletNo}",
async () => { return await ProcessTaskStatusResult(request); });
}
/// <summary>
/// 处理任务状态结果的具体业务逻辑
/// </summary>
private async Task<IActionResult> ProcessTaskStatusResult(WcsRequest request)
{
// 1. 根据托盘号查找对应的任务
var task = _unitWork.FindSingle<TaskHeader>(x => x.TaskNo == request.TaskNo
&& x.Status != TaskStatusEnum.完成);
if (task == null)
{
return ApiResultError("未找到对应的任务");
}
/* 根据任务的巷道号来判断
* 1.线边库1号巷道只有任务完成,任务下发的时候已经分配仓位
* 2.成品库2号巷道有任务请求(10)和任务完成(100)
* 判断请求的state,来执行不同的逻辑
* 任务请求(10):根据请求的高度,分配仓位
* 任务完成(100):完成任务,更新库存,更新容器状态,更新库位状态,更新任务状态(线边库需要根据重量计算库存的数量),更新对应的工单
* 任务完成后,删除任务并放到历史任务中
*/
// 根据任务的巷道号和状态来执行不同的逻辑
if (task.RoadWay == 1) // 线边库1号巷道
{
// 线边库1号巷道只处理任务完成状态
if (request.State == 100) // 任务完成
{
await ProcessTaskCompletion(task, request);
}
}
else if (task.RoadWay == 2) // 成品库2号巷道
{
if (request.State == 10) // 任务请求,需要分配仓位
{
if (!string.IsNullOrWhiteSpace(task.ToLocation))
{
return ApiResult(new { LocationCode = task.ToLocation });
}
// 根据请求的高度,分配仓位
var locationVm = Wtm.CreateVM<LocationVM>();
request.RoadWay = 2;
// 默认1 模具2 低仓位3 高仓位4 成品大于4 超限 模具大于2 超限
if (request.Height == 2)
request.Height = 999;
else if (request.Height == 3)
request.Height = 1100;
else
request.Height = 0;
var container = _unitWork.FindSingle<Container>(x => x.Code == task.ContainerCode);
if (container != null)
{
request.LocationType = container.Type switch
{
ContainerTypeEnum.成品库 => LocationTypeEnum.C,
ContainerTypeEnum.模具库 => LocationTypeEnum.M,
ContainerTypeEnum.线边库 => LocationTypeEnum.X,
_ => request.LocationType
};
}
// 模具库 高度超限直接返回失败
if (request.LocationType == LocationTypeEnum.M && request.Height >= 2)
{
return ApiResultError(msg: "模具超高,未找到合适的仓位");
}
var location = locationVm.GetLocation(request).Data;
if (location != null)
{
// 更新任务的目标仓位
task.ToLocation = location.LocationCode;
_unitWork.Update(task);
var loc = _unitWork.FindSingle<Location>(x => x.Code == task.ToLocation);
loc.Status = LocationStatusEnum.锁定;
loc.Version = Guid.NewGuid();
loc.UpdateTime = DateTime.Now;
_unitWork.Update(loc);
return ApiResult(new { LocationCode = location.LocationCode });
}
else
{
return ApiResultError(msg: "未找到合适的仓位");
}
}
else if (request.State == 100) // 任务完成
{
await ProcessTaskCompletion(task, request);
}
}
return ApiResult(new { Message = "任务状态更新成功" });
}
/// <summary>
/// 处理任务完成的逻辑
/// </summary>
private async Task ProcessTaskCompletion(TaskHeader task, WcsRequest request)
{
// 开启事务
using (var transaction = DC.BeginTransaction())
{
try
{
// 更新库存
var inventories = _unitWork.Find<Inventory>(x => x.ContainerCode == task.ContainerCode).ToList();
var invTrans = new List<InventoryTransaction>();
foreach (var inventory in inventories)
{
inventory.LocationCode = task.ToLocation;
// 线边库
if (inventory.ZoneId == 1027)
{
if (task.TaskType == TaskTypeEnum.入库)
{
var containerconfig = _unitWork.Find<SysDictData>(x => x.DictType == "ContainerConfig")
.ToList();
int ContainerWeight = int.Parse(containerconfig
.FirstOrDefault(x => x.DictLabelUs.ToLower() == "container")?.DictValue);
int SmallContainerWeight =
int.Parse(containerconfig.FirstOrDefault(x => x.ID == inventory.Flag)?.DictValue);
var material =
_unitWork.FindSingle<Material>(x => x.MaterialCode == inventory.MaterialCode);
inventory.Qty =
(int)((request.Weight * 100 - ContainerWeight -
inventory.TaskQty * SmallContainerWeight) / (material.Qty ?? 1));
inventory.Qty = inventory.Qty > 0 ? inventory.Qty : 0;
}
if (!string.IsNullOrEmpty(inventory.ReceiptDetailId))
{
// ERP相关 入库报工
var finishInRequest = new FinishInRequest
{
Main = new FinishInMain
{
ErpCode = "003", // 账套号
InCode = _unitWork.GetSerialNumber("RW"), // 报工单号(上游单号)
InDate = (inventory.CreateTime ?? DateTime.Now)
.ToString("yyyy-MM-dd"), // 报工日期
StepCode = inventory.BatchCode, // 工序(批次编码)
WorkerCode = inventory.CreateBy, // 工人编码(创建人)
Maker = _unitWork.FindSingle<FrameworkUser>(x =>
x.ITCode == inventory.CreateBy).Name // 制单人(校验员)
},
Details = new List<FinishInDetail>()
};
if (task.TaskType == TaskTypeEnum.入库)
{
// 根据库存构建明细
finishInRequest.Details.Add(new FinishInDetail
{
MoDetailId = inventory.ReceiptDetailId, // 生产订单明细(ERP明细ID)
InvCode = inventory.MaterialCode, // 物料号
Qty = inventory.Qty ?? 0 // 完工数量
});
}
else if (task.TaskType == TaskTypeEnum.出库)
{
finishInRequest.Details.Add(new FinishInDetail
{
MaterialDetails = new List<MaterialDetail>
{
new MaterialDetail
{
MoDetailId = inventory.ReceiptDetailId, // 生产订单明细ID
InvCode = inventory.MaterialCode, // 物料号
Qty = (decimal)inventory.Qty // 完工数量(空值兜底为0)
}
}
});
}
// 调用ERP接口
var apiResult = await Wtm.CallAPI<FinishInResponse>("ERP", "FinishIn",
HttpMethodEnum.POST,
finishInRequest);
if (apiResult.Data != null && apiResult.Data.Result)
{
inventory.UploadErpFlag = 1;
}
else
{
inventory.UploadErpFlag = 0;
}
}
if (task.TaskType != TaskTypeEnum.移库)
{
// 创建库存交易记录 放到任务完成,计算数量信息
var invTran = _mapper.Map<InventoryTransaction>(inventory);
invTran.Type = task.TaskType == TaskTypeEnum.入库
? InventoryTranType.入库
: InventoryTranType.出库;
invTrans.Add(invTran);
}
else
{
// 创建库存交易记录 放到任务完成,计算数量信息
var invTran = _mapper.Map<InventoryTransaction>(inventory);
invTran.Type = InventoryTranType.入库;
invTrans.Add(invTran);
var invTran2 = _mapper.Map<InventoryTransaction>(inventory);
invTran2.Type = InventoryTranType.出库;
invTrans.Add(invTran2);
}
}
inventory.TaskStatus = InventoryTaskStatusEnum.Idle;
}
if (invTrans.Any())
{
_unitWork.BatchAdd(invTrans);
}
if (task.TaskType == TaskTypeEnum.出库 && task.ZoneId == 1027)
{
// 线边库出库删掉库存
_unitWork.BatchDelete(inventories);
}
else
{
_unitWork.BatchUpdate(inventories);
}
// 更新容器状态
var container = _unitWork.FindSingle<Container>(x => x.Code == task.ContainerCode);
if (container != null)
{
container.LocationCode = task.TaskType == TaskTypeEnum.出库 ? "" : task.ToLocation;
container.IsLock = ContainerLockEnum.未锁;
container.UpdateTime = DateTime.Now;
_unitWork.Update(container);
}
// 更新库位状态(区分入库、出库、移库)
switch (task.TaskType)
{
case TaskTypeEnum.入库:
// 处理入库:更新目标库位
var inLocation = _unitWork.FindSingle<Location>(x => x.Code == task.ToLocation);
if (inLocation != null)
{
inLocation.ContainerCode = task.ContainerCode; // 绑定容器编码
inLocation.Status = LocationStatusEnum.未锁; // 标记为未锁状态
inLocation.ContainerStatus = inventories.Any() ? LocationStatus.有货 : LocationStatus.空容器;
inLocation.UpdateTime = DateTime.Now;
_unitWork.Update(inLocation);
}
break;
case TaskTypeEnum.出库:
// 处理出库:更新源库位
var outLocation = _unitWork.FindSingle<Location>(x => x.Code == task.FromLocation);
if (outLocation != null)
{
outLocation.ContainerCode = ""; // 清空容器编码
outLocation.Status = LocationStatusEnum.未锁; // 标记为未锁状态
outLocation.ContainerStatus = LocationStatus.空仓位; // 标记为空仓位
outLocation.UpdateTime = DateTime.Now;
_unitWork.Update(outLocation);
}
break;
case TaskTypeEnum.移库:
// 处理移库:同时更新源库位和目标库位
// 1. 更新源库位(移出后变为空)
var sourceLocation = _unitWork.FindSingle<Location>(x => x.Code == task.FromLocation);
// 2. 更新目标库位(移入后有容器)
var targetLocation = _unitWork.FindSingle<Location>(x => x.Code == task.ToLocation);
if (targetLocation != null)
{
targetLocation.ContainerCode = task.ContainerCode;
targetLocation.Status = LocationStatusEnum.未锁;
targetLocation.ContainerStatus = sourceLocation.ContainerStatus;
targetLocation.UpdateTime = DateTime.Now;
_unitWork.Update(targetLocation);
}
if (sourceLocation != null)
{
sourceLocation.ContainerCode = "";
sourceLocation.Status = LocationStatusEnum.未锁;
sourceLocation.ContainerStatus = LocationStatus.空仓位;
sourceLocation.UpdateTime = DateTime.Now;
_unitWork.Update(sourceLocation);
}
break;
default:
// 处理未定义的任务类型(可选)
throw new ArgumentOutOfRangeException($"未处理的任务类型:{task.TaskType}");
}
// 更新任务状态为完成
task.Status = TaskStatusEnum.完成;
// 将任务复制到历史任务表
var taskHistory = _mapper.Map<TaskHeaderHistory>(task);
_unitWork.Add(taskHistory);
// 删除原任务
_unitWork.Delete(task);
// 提交事务
await transaction.CommitAsync();
}
catch (System.Exception ex)
{
await transaction.RollbackAsync();
throw new Exception($"处理任务完成失败: {ex.Message}");
}
}
}
#region 暂时无用
/// <summary>
/// 请求入库(带防抖)
/// </summary>
[HttpPost]
public Task<IActionResult> RequestIn(WcsRequest request)
{
if (request == null || string.IsNullOrEmpty(request.PalletNo))
{
return Task.FromResult<IActionResult>(ApiResultError("请求参数无效"));
}
return WithDebounce($"RequestIn_{request.PalletNo}", async () =>
{
await ProcessRequestIn(request);
return ApiResult(new { Message = "入库请求处理成功" });
});
}
/// <summary>
/// 处理入库请求的具体业务逻辑
/// </summary>
private async Task ProcessRequestIn(WcsRequest request)
{
// TODO: 实现具体的入库处理逻辑
await Task.Delay(1000); // 模拟异步处理
}
/// <summary>
/// 请求空闲库位(带防抖)
/// </summary>
[HttpPost]
public Task<IActionResult> RequestLocation(WcsRequest request)
{
if (string.IsNullOrEmpty(request?.PalletNo))
{
return Task.FromResult<IActionResult>(ApiResultError("容器编码不能为空"));
}
if (!request.RoadWay.HasValue)
{
return Task.FromResult<IActionResult>(ApiResultError("巷道不能为空"));
}
return WithDebounce($"RequestLocation_{request.TaskNo}", () =>
{
var vm = Wtm.CreateVM<LocationVM>();
var code = vm.GetLocation(request);
if (code.Status)
{
var updateResult = UpdateLocationAndContainer(code.Data.LocationCode, request.PalletNo);
return Task.FromResult<IActionResult>(updateResult);
}
return Task.FromResult<IActionResult>(ApiResultError("没有符合条件的可用库位"));
});
}
/// <summary>
/// 更新库位和容器
/// </summary>
/// <param name="locationCode"></param>
/// <param name="palletNo"></param>
/// <returns></returns>
private IActionResult UpdateLocationAndContainer(string locationCode, string palletNo)
{
var location = _unitWork.Find<Location>(x => x.Code == locationCode).FirstOrDefault();
var resultNum = _unitWork.BatchUpdate<Location>(
x => x.Code == locationCode && x.Version == location.Version,
x => new Location()
{
ContainerCode = palletNo,
// Status = LocationStatus.任务锁,
UpdateTime = DateTime.Now,
UpdateBy = "WMS",
Version = Guid.NewGuid()
});
if (resultNum == 0)
{
//失败
return ApiResult(ApiResultError("更新仓位失败!请重新请求!"));
}
var container = _unitWork.Find<Container>(x => x.Code == palletNo).FirstOrDefault();
if (container != null)
{
container.LocationCode = location?.Code;
_unitWork.Update(container);
}
return ApiResult(new { LocationCode = location?.Code });
}
#endregion
}
}