1

huangxiaoqiang

2025-10-23 82149871f30f4564d84272649352496a2ab0a38e

 ÏîÄ¿´úÂë/WMS/WIDESEA_WMSServer/WIDESEA_WMSServer/Controllers/Task/TaskController.cs

@@ -11,15 +11,11 @@
{
    private readonly IHttpContextAccessor _httpContextAccessor;
    private readonly IDt_TaskService _taskService;
    private readonly ILocationInfoService _locationService;

    public TaskController(IDt_TaskService taskService,
        IHttpContextAccessor httpContextAccessor,
        ILocationInfoService locationService) : base(taskService)
    public TaskController(IDt_TaskService service,
        IHttpContextAccessor httpContextAccessor) : base(service)
    {
        _httpContextAccessor = httpContextAccessor;
        _taskService = taskService;
        _locationService = locationService;
    }

    /// <summary>
@@ -28,45 +24,54 @@
    /// <param name="saveModel">任务号</param>
    /// <returns>成功或失败</returns>
    [HttpGet, Route("CompleteTaskAsync"), AllowAnonymous]
    //[TypeFilter(typeof(ThrottleFilter), Arguments = new object[] { 5 })] // 5秒节流
    public async Task<WebResponseContent> CompleteTaskAsync(int taskNum)
    {
        return await _taskService.CompleteAsync(taskNum);
    }
    /// <summary>
    /// è¯·æ±‚任务巷道
    /// </summary>
    /// <param name="input">请求数据</param>
    /// <returns></returns>
    [HttpPost, AllowAnonymous, Route("RequestTaskAsync")]
    [TypeFilter(typeof(ThrottleFilter), Arguments = new object[] { 5 })] // 5秒节流
    public async Task<WebResponseContent> RequestTaskAsync([FromBody] RequestTaskDto input)
    {
        return await Service.RequestTaskAsync(input);
        return await Service.CompleteAsync(taskNum);
    }

    /// <summary>
    /// è¯·æ±‚任务货位
    /// ä»»åŠ¡å–消
    /// </summary>
    /// <param name="input">请求数据</param>
    /// <param name="taskNum"></param>
    /// <returns></returns>
    [HttpPost, AllowAnonymous, Route("RequestLocationTaskAsync")]
    [TypeFilter(typeof(ThrottleFilter), Arguments = new object[] { 5 })] // 5秒节流
    public async Task<WebResponseContent> UpdateExistingTask([FromBody] RequestTaskDto input)
    [HttpPost, Route("TaskCancel"), AllowAnonymous]
    public WebResponseContent TaskCancel(int taskNum)
    {
        return await Service.UpdateExistingTask(input);
        return Service.TaskCancel(taskNum);
    }

    /// <summary>
    /// ç©ºæ‰˜ç›˜å…¥åº“请求
    /// èŽ·å–任务信息
    /// </summary>
    /// <returns></returns>
    [HttpPost, Route("GetTaskInfo")]
    public WebResponseContent GetTaskInfo()
    {
        return Service.GetTaskInfo();
    }

    /// <summary>
    /// è¯·æ±‚入库任务
    /// </summary>
    /// <param name="input">请求数据</param>
    /// <returns></returns>
    [HttpPost, AllowAnonymous, Route("RequestTrayInTaskAsync")]
    [TypeFilter(typeof(ThrottleFilter), Arguments = new object[] { 5 })] // 5秒节流
    public async Task<WebResponseContent> RequestTrayInTaskAsync([FromBody] RequestTaskDto input)
    [HttpPost, AllowAnonymous, Route("RequestInboundTaskAsync")]
    [TypeFilter(typeof(ThrottleFilter), Arguments = new object[] { 5 })]
    public async Task<WebResponseContent> RequestInboundTaskAsync([FromBody] RequestTaskDto input)
    {
        return await Service.RequestTrayInTaskAsync(input);
        return await Service.RequestInboundTaskAsync(input);
    }

    /// <summary>
    /// æ›´æ–°è´§ä½ä»»åŠ¡çŠ¶æ€åˆ°ä¸‹ä¸€ä¸ªèŠ‚点
    /// </summary>
    /// <param name="input">请求数据</param>
    /// <returns></returns>
    [HttpPost, AllowAnonymous, Route("RequestLocationAsync")]
    [TypeFilter(typeof(ThrottleFilter), Arguments = new object[] { 5 })]
    public async Task<WebResponseContent> RequestLocationAsync([FromBody] RequestTaskDto input)
    {
        return await Service.RequestLocationAsync(input);
    }

    /// <summary>
@@ -74,11 +79,23 @@
    /// </summary>
    /// <param name="request">请求数据</param>
    /// <returns></returns>
    [HttpPost, AllowAnonymous, Route("RequestTrayOutTaskAsync")]
    [TypeFilter(typeof(ThrottleFilter), Arguments = new object[] { 5 })] // 5秒节流
    public async Task<WebResponseContent> RequestTrayOutTaskAsync([FromBody] RequestOutTaskDto request)
    [HttpPost, AllowAnonymous, Route("RequestOutboundTaskAsync")]
    [TypeFilter(typeof(ThrottleFilter), Arguments = new object[] { 5 })]
    public async Task<Dt_Task> RequestOutboundTaskAsync([FromBody] RequestTaskDto taskDto)
    {
        return await Service.RequestTrayOutTaskAsync(request.Position, request.Tag, request.AreaCdoe, request.AreaCdoes, request.ProductionLine);
        return await Service.RequestOutboundTaskAsync(taskDto);
    }

    /// <summary>
    /// ç©ºæ‰˜ç›˜æ»¡ç›˜å‡ºåº“请求
    /// </summary>
    /// <param name="request">请求数据</param>
    /// <returns></returns>
    [HttpPost, AllowAnonymous, Route("OtherOutBoundTaskAsync")]
    [TypeFilter(typeof(ThrottleFilter), Arguments = new object[] { 2 })]
    public Task<WebResponseContent> OtherOutBoundTaskAsync(string palletCode)
    {
        return Service.OtherOutBoundTaskAsync(palletCode);
    }

    /// <summary>
@@ -86,11 +103,57 @@
    /// </summary>
    /// <param name="input">请求数据</param>
    /// <returns></returns>
    [HttpPost, AllowAnonymous, Route("UpdateTaskStatus")]
    [TypeFilter(typeof(ThrottleFilter), Arguments = new object[] { 5 })] // 5秒节流
    [HttpPost,HttpGet,Route("UpdateTaskStatus") ,AllowAnonymous]
    [TypeFilter(typeof(ThrottleFilter), Arguments = new object[] { 5 })] 
    public async Task<WebResponseContent> UpdateTaskStatus([FromBody] UpdateStatusDto input)
    {
        return await Service.UpdateTaskStatus(input.TaskNum, input.TaskState);
    }

    /// <summary>
    /// è¯·æ±‚跨楼层任务2
    /// </summary>
    /// <param name="taskDto"></param>
    /// <returns></returns>
    [HttpPost, AllowAnonymous, Route("AcrossFloorTaskAsync")]
    public async Task<WebResponseContent> AcrossFloorTaskAsync([FromBody] RequestAcrossFloorTaskDto taskDto)
    {
        return await Service.AcrossFloorTaskAsync(taskDto);
    }


    [HttpPost, AllowAnonymous, Route("GetEmptyLocation")]
    [TypeFilter(typeof(ThrottleFilter), Arguments = new object[] { 5 })]
    public async Task<DtLocationInfo> GetEmptyLocation(string roadWay)
    {
        return await Service.GetEmptyLocation(roadWay);
    }

    [HttpPost, AllowAnonymous, Route("GetAGVEmptyCacheLocation")]
    [TypeFilter(typeof(ThrottleFilter), Arguments = new object[] { 5 })]
    public async Task<DtLocationInfo> GetAGVEmptyCacheLocation(int AreaId,DtLocationInfo location)
    {
        return await Service.GetAGVEmptyCacheLocation(AreaId,location);
    }

    [HttpPost, AllowAnonymous, Route("StackerIsNeedRelocationAsync")]
    [TypeFilter(typeof(ThrottleFilter), Arguments = new object[] { 5 })]
    public async Task<WebResponseContent> StackerIsNeedRelocationAsync([FromBody] RequestTaskDto taskDto)
    {
        return await Service.StackerIsNeedRelocationAsync(taskDto);
    }

    [HttpPost, AllowAnonymous, Route("AGVIsNeedRelocationAsync")]
    [TypeFilter(typeof(ThrottleFilter), Arguments = new object[] { 5 })]
    public async Task<WebResponseContent> AGVIsNeedRelocationAsync([FromBody] RequestTaskDto taskDto)
    {
        return await Service.AGVIsNeedRelocationAsync(taskDto);
    }

    [HttpPost, AllowAnonymous, Route("SendERPTaskCompletion")]
    [TypeFilter(typeof(ThrottleFilter), Arguments = new object[] { 5 })]
    public Task<WebResponseContent> SendERPTaskCompletion(string palletCode)
    {
        return Service.SendERPTaskCompletion(palletCode);
    }
}