Files
WMS/HHWMS.Web/Areas/Api/IWCSController.cs
T
zhougf b12ed2d5e5 任务添加zoneid
添加物料打印
添加物料工序
添加库存出库
修改状态返回接口
wcs请求添加 重量和入口
2025-07-09 01:11:10 +08:00

354 lines
14 KiB
C#

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秒
private int ContainerWeight = 500;
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 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> TaskStatusResult(WcsRequest request)
{
if (request == null || string.IsNullOrEmpty(request.PalletNo))
{
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) // 任务请求,需要分配仓位
{
// 根据请求的高度,分配仓位
var locationVm = Wtm.CreateVM<LocationVM>();
request.RoadWay = 2;
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
};
}
var location = await locationVm.GetLocation(request).Data;
if (location != null)
{
// 更新任务的目标仓位
task.ToLocation = location.LocationCode;
_unitWork.Update(task);
}
else
{
return ApiResultError("未找到合适的仓位");
}
}
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)
{
var material = _unitWork.FindSingle<Material>(x => x.MaterialCode == inventory.MaterialCode);
inventory.LocationCode = task.ToLocation;
if(task.TaskType == TaskTypeEnum.入库)
inventory.Qty = (request.Weight - ContainerWeight) / material.Qty;
inventory.TaskStatus = InventoryTaskStatusEnum.Idle;
// 创建库存交易记录 放到任务完成,计算数量信息
var invTransaction = new InventoryTransaction
{
Type = task.TaskType == TaskTypeEnum.入库 ? InventoryTranType.入库 : InventoryTranType.出库,
ContainerCode = task.ContainerCode,
LocationCode = task.ToLocation,
MaterialCode = inventory.MaterialCode,
MaterialName = inventory.MaterialName,
MaterialSpec = inventory.MaterialSpec,
MaterialUnit = inventory.MaterialUnit,
Qty = inventory.Qty,
CreateTime = DateTime.Now
};
invTrans.Add(invTransaction);
}
_unitWork.BatchAdd(invTrans);
_unitWork.BatchUpdate(inventories);
// 更新容器状态
var container = _unitWork.FindSingle<Container>(x => x.Code == task.ContainerCode);
if (container != null)
{
container.LocationCode = task.ToLocation;
container.IsLock = ContainerLockEnum.未锁;
container.UpdateTime = DateTime.Now;
}
_unitWork.Update(container);
// 更新库位状态
var location = task.TaskType == TaskTypeEnum.入库
? _unitWork.FindSingle<Location>(x => x.Code == task.ToLocation)
: _unitWork.FindSingle<Location>(x => x.Code == task.FromLocation);
if (location != null)
{
location.ContainerCode = task.TaskType == TaskTypeEnum.入库 ? request.PalletNo : "";
location.Status = LocationStatusEnum.未锁;
location.ContainerStatus = LocationStatus.空仓位;
location.UpdateTime = DateTime.Now;
}
_unitWork.Update(location);
// 更新任务状态为完成
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}");
}
}
}
/// <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 });
}
}
}