using Microsoft.AspNetCore.Authorization;
|
using Microsoft.AspNetCore.Mvc;
|
using Microsoft.Extensions.Caching.Memory;
|
using Newtonsoft.Json;
|
using System.DirectoryServices.Protocols;
|
using System.Threading.Tasks;
|
using WIDESEA_Common.StockEnum;
|
using WIDESEA_Common.WareHouseEnum;
|
using WIDESEA_Core;
|
using WIDESEA_Core.BaseRepository;
|
using WIDESEA_Core.Filter;
|
using WIDESEA_Core.LogHelper;
|
using WIDESEA_DTO.Basic;
|
using WIDESEA_ITaskInfoService;
|
using WIDESEA_Model.Models;
|
|
namespace WIDESEA_WMSServer.Controllers
|
{
|
|
[Route("api/ESS")]
|
[ApiController]
|
[AllowAnonymous]
|
public class ESSController : Controller
|
{
|
|
public readonly ITaskService _taskService;
|
private readonly ILogger<ESSController> _logger;
|
private readonly IMemoryCache _memoryCache;
|
private static readonly SemaphoreSlim _semaphore = new SemaphoreSlim(1, 1);
|
public ESSController(ITaskService taskService, ILogger<ESSController> logger, IMemoryCache memoryCache)
|
{
|
_taskService = taskService;
|
_logger = logger;
|
_memoryCache = memoryCache;
|
}
|
|
/// <summary>
|
/// 容器到达上报
|
/// </summary>
|
/// <param name="request"></param>
|
/// <returns></returns>
|
[HttpPost("ContainerArrivalReport"), AllowAnonymous]
|
public async Task<IActionResult> ContainerArrivalReport([FromBody] ContainerArrivalRequest request)
|
{
|
//这里要判断出库的时候，料箱会到扫码处。也会请求这个接口。
|
_logger.LogInformation(" ESSController ContainerArrivalReport : CallId={CallId},ContainerCode={ContainerCode},SlotCode={SlotCode}", request.CallId, request.ContainerCode, request.SlotCode);
|
var response = new ApiResponse<ContainerArrivalResponseData>
|
{
|
Code = 1
|
|
};
|
|
// 生成请求的唯一标识（基于callId + 时间戳）
|
var requestKey = $"callback_{request.CallId}-{request.ContainerCode}_{DateTime.UtcNow:yyyyMMddHH}";
|
|
// 检查是否已经处理过相同的请求
|
if (_memoryCache.TryGetValue(requestKey, out bool _))
|
{
|
_logger.LogWarning("检测到重复请求，已忽略: CallId={CallId}", request.CallId);
|
response.Code = 1;
|
response.Msg = null;
|
response.Data = null;
|
return Ok(response);
|
}
|
|
|
await _semaphore.WaitAsync();
|
try
|
{
|
if (_memoryCache.TryGetValue(requestKey, out bool _))
|
{
|
_logger.LogWarning("双重检查检测到重复请求，已忽略: CallId={CallId}", request.CallId);
|
response.Code = 1;
|
response.Msg = null;
|
response.Data = null;
|
return Ok(response);
|
}
|
|
WebResponseContent result = await _taskService.RequestInboundTask(request.ContainerCode, request.SlotCode);
|
|
var cacheOptions = new MemoryCacheEntryOptions
|
{
|
AbsoluteExpirationRelativeToNow = TimeSpan.FromSeconds(20)
|
};
|
_memoryCache.Set(requestKey, true, cacheOptions);
|
response = new ApiResponse<ContainerArrivalResponseData>
|
{
|
Code = 0,
|
Msg = "",
|
Data = new ContainerArrivalResponseData
|
{
|
direction = "100"
|
}
|
};
|
if (result != null && !string.IsNullOrEmpty( result.Message ) && result.Message.Contains("该托盘已生成任务"))
|
{
|
return Ok(response);
|
}
|
if (result != null && result.Status)
|
{
|
return Ok(response);
|
}
|
else
|
{
|
response.Code = 1;
|
response.Msg = null;
|
response.Data = null;
|
_logger.LogError(" ESSController ContainerArrivalReport Error: Message={Message}", result.Message);
|
|
return Ok(response);
|
}
|
}
|
catch (Exception ex)
|
{
|
_logger.LogError(ex, "处理任务状态回调时发生异常: CallId={CallId}", request.CallId);
|
return Ok($"处理回调时发生异常: {ex.Message}");
|
}
|
finally
|
{
|
_semaphore.Release();
|
}
|
|
}
|
|
/// <summary>
|
/// 异常上报
|
/// </summary>
|
/// <param name="request"></param>
|
/// <returns></returns>
|
[HttpPost("ExceptionReporting"), AllowAnonymous]
|
|
public async Task<ActionResult<StatusCallbackResponse>> ExceptionReporting(
|
[FromBody] RobotAbnormalEventRequest request)
|
{
|
_logger.LogInformation("异常上报接口request: " + JsonConvert.SerializeObject(request));
|
|
|
return StatusCallbackResponse.Success();
|
|
}
|
//任务状态上报接口
|
[HttpPost("TaskStatusCcallback"), AllowAnonymous]
|
|
public async Task<ActionResult<StatusCallbackResponse>> TaskStatusCallback(
|
[FromBody] StatusCallbackRequest request)
|
{
|
_logger.LogInformation("任务状态上报接口request: " + JsonConvert.SerializeObject(request));
|
try
|
{
|
|
_logger.LogInformation("收到任务状态回调: CallId={CallId}, EventType={EventType}, Status={Status}",
|
request.CallId, request.EventType, request.Status);
|
|
// 根据事件类型和状态进行不同的业务处理
|
switch (request.EventType)
|
{
|
case EventType.tote_load:
|
await HandleToteLoad(request);
|
break;
|
case EventType.tote_unload:
|
await HandleToteUnload(request);
|
break;
|
case EventType.robot_reach:
|
await HandleRobotReach(request);
|
break;
|
case EventType.task:
|
await HandleTaskStatusChange(request);
|
break;
|
case EventType.task_allocated:
|
await HandleTaskAllocated(request);
|
break;
|
|
default:
|
_logger.LogWarning("未知的事件类型: {EventType}", request.EventType);
|
break;
|
}
|
|
_logger.LogInformation("任务状态回调处理完成: CallId={CallId}", request.CallId);
|
|
return StatusCallbackResponse.Success();
|
}
|
catch (Exception ex)
|
{
|
_logger.LogError(ex, "处理任务状态回调时发生异常: CallId={CallId}", request?.CallId);
|
return StatusCallbackResponse.Error($"处理回调时发生异常: {ex.Message}");
|
}
|
}
|
|
/// <summary>
|
/// 处理任务状态变化
|
/// </summary>
|
private async Task HandleTaskStatusChange(StatusCallbackRequest request)
|
{
|
// 根据任务状态进行不同的处理
|
switch (request.Status)
|
{
|
case WIDESEA_DTO.Basic.TaskStatus.success:
|
await HandleTaskCompleted(request);
|
break;
|
case WIDESEA_DTO.Basic.TaskStatus.fail:
|
await HandleTaskFailed(request);
|
break;
|
case WIDESEA_DTO.Basic.TaskStatus.cancel:
|
await HandleTaskCancelled(request);
|
break;
|
case WIDESEA_DTO.Basic.TaskStatus.suspend:
|
await HandleTaskSuspended(request);
|
break;
|
}
|
}
|
|
/// <summary>
|
/// 处理任务完成
|
/// </summary>
|
private async Task HandleTaskCompleted(StatusCallbackRequest request)
|
{
|
_logger.LogInformation("任务完成: TaskCode={TaskCode}, Container={Container}, Robot={Robot}",
|
request.TaskCode, request.ContainerCode, request.RobotCode);
|
|
await _taskService.TaskCompleted(request.TaskCode);
|
// 根据不同的任务类型进行特殊处理
|
if (request.Weight.HasValue)
|
{
|
// 称重任务完成
|
_logger.LogInformation("称重任务完成: 重量={Weight}g, 托盘层={TrayLevel}",
|
request.Weight, request.TrayLevel);
|
}
|
else if (request.Rfids != null && request.Rfids.Count > 0)
|
{
|
// RFID任务完成
|
_logger.LogInformation("RFID任务完成: RFID数量={RfidCount}, 托盘层={TrayLevel}",
|
request.Rfids.Count, request.TrayLevel);
|
}
|
else if (request.IsLocationHasContainer.HasValue)
|
{
|
// 扫描任务完成
|
_logger.LogInformation("扫描任务完成: 库位有容器={HasContainer}",
|
request.IsLocationHasContainer);
|
}
|
else
|
{
|
// 普通任务完成
|
_logger.LogInformation("普通任务完成");
|
}
|
|
// 这里添加您的业务逻辑
|
await Task.CompletedTask;
|
}
|
|
/// <summary>
|
/// 处理任务失败
|
/// </summary>
|
private async Task HandleTaskFailed(StatusCallbackRequest request)
|
{
|
_logger.LogWarning("任务失败: TaskCode={TaskCode}, 原因={Message}",
|
request.TaskCode, request.Message);
|
|
// 这里添加您的失败处理逻辑
|
await Task.CompletedTask;
|
}
|
|
/// <summary>
|
/// 处理任务取消
|
/// </summary>
|
private async Task HandleTaskCancelled(StatusCallbackRequest request)
|
{
|
_logger.LogInformation("任务取消: TaskCode={TaskCode}", request.TaskCode);
|
|
// 这里添加您的取消处理逻辑
|
await Task.CompletedTask;
|
}
|
|
/// <summary>
|
/// 处理任务挂起
|
/// </summary>
|
private async Task HandleTaskSuspended(StatusCallbackRequest request)
|
{
|
_logger.LogWarning("任务挂起: TaskCode={TaskCode}, 系统任务码={SysTaskCode}, 原因={Message}",
|
request.TaskCode, request.SysTaskCode, request.Message);
|
|
// 这里添加您的挂起处理逻辑
|
await Task.CompletedTask;
|
}
|
|
/// <summary>
|
/// 处理任务分配
|
/// </summary>
|
private async Task HandleTaskAllocated(StatusCallbackRequest request)
|
{
|
_logger.LogInformation("任务分配: TaskCode={TaskCode}, Robot={Robot}",
|
request.TaskCode, request.RobotCode);
|
|
// 这里添加您的任务分配处理逻辑
|
await Task.CompletedTask;
|
}
|
|
/// <summary>
|
/// 处理取箱操作
|
/// </summary>
|
private async Task HandleToteLoad(StatusCallbackRequest request)
|
{
|
if (request.Status == WIDESEA_DTO.Basic.TaskStatus.success)
|
{
|
_logger.LogInformation("取箱完成: Container={Container}, Location={Location}",
|
request.ContainerCode, request.LocationCode);
|
}
|
else
|
{
|
_logger.LogWarning("取箱失败: Container={Container}, Location={Location}",
|
request.ContainerCode, request.LocationCode);
|
}
|
|
// 这里添加您的取箱处理逻辑
|
await Task.CompletedTask;
|
}
|
|
/// <summary>
|
/// 处理放箱操作
|
/// </summary>
|
private async Task HandleToteUnload(StatusCallbackRequest request)
|
{
|
if (request.Status == WIDESEA_DTO.Basic.TaskStatus.success)
|
{
|
_logger.LogInformation("放箱完成: Container={Container}, Location={Location}",
|
request.ContainerCode, request.LocationCode);
|
}
|
else
|
{
|
_logger.LogWarning("放箱失败: Container={Container}, Location={Location}",
|
request.ContainerCode, request.LocationCode);
|
}
|
|
// 这里添加您的放箱处理逻辑
|
await Task.CompletedTask;
|
}
|
|
/// <summary>
|
/// 处理机器人到达工作站
|
/// </summary>
|
private async Task HandleRobotReach(StatusCallbackRequest request)
|
{
|
_logger.LogInformation("机器人到达工作站: Robot={Robot}, Station={Station}, Location={Location}",
|
request.RobotCode, request.StationCode, request.LocationCode);
|
|
if (request.Trays != null && request.Trays.Count > 0)
|
{
|
_logger.LogInformation("机器人携带托盘信息: 托盘数量={TrayCount}", request.Trays.Count);
|
foreach (var tray in request.Trays)
|
{
|
_logger.LogInformation("托盘: Container={Container}, Level={Level}, Position={Position}, Face={Face}",
|
tray.ContainerCode, tray.TrayLevel, tray.PositionCode, tray.ContainerFace);
|
}
|
}
|
|
// 这里添加您的机器人到达处理逻辑
|
await Task.CompletedTask;
|
}
|
}
|
}
|
