SDLC_WMS/Server/Wms.Core.Presentation.Rest/Controllers/TasksController.cs

using Kean.Application.Command.ViewModels;
using Microsoft.AspNetCore.Mvc;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using System;
using System.Linq;
using System.Threading.Tasks;

namespace Kean.Presentation.Rest.Controllers
{
    /// <summary>
    /// 任务服务
    /// </summary>
    [ApiController, Route("api/tasks")]
    public class TasksController : ControllerBase
    {
        private readonly Application.Command.Interfaces.ITaskService _taskCommandService; // 任务命令服务
        private readonly Application.Query.Interfaces.ITaskService _taskQueryService; // 任务查询服务
        private readonly Application.Query.Interfaces.IIdentityService _identityQueryService; // 身份查询服务

        /// <summary>
        /// 依赖注入
        /// </summary>
        public TasksController(
            Application.Command.Interfaces.ITaskService taskCommandService,
            Application.Query.Interfaces.IIdentityService identityQueryService,
            Application.Query.Interfaces.ITaskService taskQueryService)
        {
            _taskCommandService = taskCommandService;
            _taskQueryService = taskQueryService;
            _identityQueryService = identityQueryService;
        }

        /// <summary>
        /// 获取任务列表
        /// </summary>
        /// <response code="200">成功</response>
        [HttpGet]
        [ProducesResponseType(200)]
        public async Task<IActionResult> GetList(
            [FromQuery] int[] area,
            [FromQuery] string type,
            [FromQuery] string qualityState,
            [FromQuery] string barcode,
            [FromQuery] string original,
            [FromQuery] string destination,
            [FromQuery] DateTime? timeFrom,
            [FromQuery] DateTime? timeTo,
            [FromQuery] string sort,
            [FromQuery] int? offset,
            [FromQuery] int? limit)
        {
            if (area.Length == 0)
            {
                area = null;
            }
            var items = await _taskQueryService.GetTaskList(area, type, qualityState, barcode, original, destination, timeFrom, timeTo, sort, offset, limit);
            if (offset.HasValue || limit.HasValue)
            {
                var total = await _taskQueryService.GetTaskCount(area, type, qualityState, barcode, original, destination, timeFrom, timeTo);
                return StatusCode(200, new { items, total });
            }
            else
            {
                return StatusCode(200, new { items, total = items.Count() });
            }
        }

        /// <summary>
        /// 创建任务
        /// </summary>
        /// <response code="201">成功</response>
        /// <response code="405">非法操作</response>
        /// <response code="422">请求内容错误</response>
        [HttpPost]
        [ProducesResponseType(201)]
        [ProducesResponseType(405)]
        [ProducesResponseType(422)]
        public async Task<IActionResult> Create(
            [FromMember] string operation,
            [FromMiddleware] int session,
            [FromMember] Application.Command.ViewModels.Task task
)
        {
            task.Operator = session;
            
            var user = await _identityQueryService.GetUser(session);
            try
            {
                JObject jObj = JObject.Parse(task.Tag);
                JToken jPostUser = jObj.SelectToken("postUser");
                if (jPostUser == null)
                {
                    jObj.Add("postUser", user.Name);
                }
                else
                {
                    jObj["postUser"] = user.Name;
                }

                task.Tag = JsonConvert.SerializeObject(jObj);
            }
            catch { }


            (int Id, Failure Failure) result;
            (string message, Failure Failure) resultReupload;
            switch (operation)
            {
                case "infeed":
                    result = await _taskCommandService.Infeed(task);
                    break;
                case "outfeed":
                    result = await _taskCommandService.Outfeed(task);
                    break;
                case "transfer":
                    result = await _taskCommandService.Transfer(task);
                    break;
                case "bypass":
                    result = await _taskCommandService.Bypass(task);
                    break;
                case "applyout":
                    result = await _taskCommandService.ApplyOut(task);
                    break;
                case "palletOut":
                    result = await _taskCommandService.PalletOut(task);
                    break;
                case "Complete":
                    result.Failure = await _taskCommandService.Complete(task.Id);
                    break;
                case "Cancel":
                    result.Failure = await _taskCommandService.Cancel(task.Id);
                    break;
                case "ReuploadHiWMS":
                    resultReupload = await _taskCommandService.ReuploadHiWMS(task.Id);

                    result.Failure = resultReupload.Failure;
                    if (!string.IsNullOrEmpty(resultReupload.message))
                    {
                        result.Failure = new Failure();
                        result.Failure.ErrorMessage = resultReupload.message;
                    }
                    break;
                case "SetRollByLocalComplete":
                    resultReupload = await _taskCommandService.SetRollTaskByLocalComplete(task.Id, session);

                    result.Failure = resultReupload.Failure;
                    break;
                case "RecompleteForNoAgv":
                    result = await _taskCommandService.RecompleteForNoAgv(task);
                    break;
                case "RecompleteForNoHiwms":
                    result = await _taskCommandService.RecompleteForNoHiwms(task);
                    break;
                //case "directoutbound":
                //    result = await _taskCommandService.DirectOutbound(task);
                //    break;
                case "CallDelete":
                    result.Failure = await _taskCommandService.CallDelete(task.Id);
                    break;
                case "SetPriority":
                    result.Failure = await _taskCommandService.SetPriority(task);
                    break;
                default:
                    return StatusCode(405);
            }
            if (result.Failure == null)
            {
                return StatusCode(201);
            }
            else
            {
                return StatusCode(422, result.Failure);
            }
        }

        /////// <summary>
        /////// 设置应急模式
        /////// </summary>
        /////// <response code="201">成功</response>
        /////// <response code="405">非法操作</response>
        /////// <response code="422">请求内容错误</response>
        ////[HttpPost("emergency")]
        ////[ProducesResponseType(201)]
        ////[ProducesResponseType(405)]
        ////[ProducesResponseType(422)]
        ////[Anonymous]
        ////public async Task<IActionResult> SetEmergency(
        ////    [FromMember] string stationCode,
        ////    [FromMember] string stationModel,
        ////    [FromMiddleware] int session)
        ////{
        ////    Failure failure = await _taskCommandService.Emergency(stationCode, stationModel, session);
           
        ////    if (failure == null)
        ////    {
        ////        return StatusCode(201);
        ////    }
        ////    else
        ////    {
        ////        return StatusCode(422, failure);
        ////    }
        ////}
    }
}