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

using Azure.Core;
using Kean.Application.Command.ViewModels;
using Kean.Presentation.Rest.Models;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.DependencyModel;
using Microsoft.Extensions.Logging;
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using static Kean.Application.Command.ViewModels.Order;

namespace Kean.Presentation.Rest.Controllers
{
    /// <summary>
    /// 库存服务
    /// </summary>
    [ApiController, Route("api/lc")]
    public class AgvApplyController : ControllerBase
    {
        private readonly ILogger<AgvApplyController> _logger; // 日志
        private readonly Application.Command.Interfaces.IStockService _stockCommandService; // 库存命令服务
        private readonly Application.Command.Interfaces.ITaskService _taskCommandService; // 任务命令服务
        private readonly Application.Command.Interfaces.IInterfaceService _interfaceService; // 库存命令服务
        private readonly Kean.Infrastructure.Soap.Hithium.WmsAPIService _wmsService; // WMS

        /// <summary>
        /// 依赖注入
        /// </summary>
        public AgvApplyController(
            ILogger<AgvApplyController> logger,
            Application.Command.Interfaces.ITaskService taskCommandService,
            Application.Command.Interfaces.IInterfaceService interfaceService,
            Kean.Infrastructure.Soap.Hithium.WmsAPIService wmsService,
            Application.Command.Interfaces.IStockService stockCommandService)
        {
            _logger = logger;
            _stockCommandService = stockCommandService;
            _taskCommandService = taskCommandService;
            _interfaceService = interfaceService;
            _wmsService = wmsService;
        }

        /// <summary>
        /// 获取入库订单
        /// </summary>
        /// <response code="201">成功</response>
        /// <response code="405">非法操作</response>
        /// <response code="422">请求内容错误</response>
        [HttpPost("planIn")]
        [ProducesResponseType(201)]
        [ProducesResponseType(405)]
        [ProducesResponseType(422)]
        [Anonymous]
        public async Task<IActionResult> PlanIn(
            [FromMember] string planCode,
            [FromMember] string planType,
            [FromMember] string user,
            [FromMember] string status,
            [FromMember] IEnumerable<Line> orders)
        {
            Result result = new Result();
            int statusCode = 0;
            DateTime? startTime = null;
            DateTime? endTime = null;

            result.requestNo = planCode;
            string strOrders = JsonConvert.SerializeObject(orders);

            _logger.LogInformation($"获取入库订单接口[PlanIn]开始：" +
                $"参数 planCode-{planCode} " +
                $"planType-{planType} " +
                $"user-{user} " +
                $"status-{status} " +
                $"orders -{strOrders} ");

            try
            {
                (string Device, Failure Failure) commandResult;
                Failure failure = new Failure();
                commandResult.Failure = failure;

                startTime = DateTime.Now;

                //@=@ 生成计划


                endTime = DateTime.Now;
                if (commandResult.Failure == null)
                {
                    result.code = "0";
                    statusCode = 201;
                }
                else
                {
                    result.code = "1";
                    result.message = commandResult.Failure.ErrorMessage;
                    statusCode = 422;
                }
            }
            catch (Exception ex)
            {
                statusCode = 422;
                _logger.LogWarning($"获取入库订单接口[PlanIn]异常：原因-{ex.StackTrace}");
                result.code = "1";
                result.message = $"获取入库订单接口[PlanIn]异常：原因-{ex.Message}";
            }

            _logger.LogInformation($"获取入库订单接口[PlanIn]结束：结果RESULT-{result.code} 消息MSG-{result.message} statusCode-{statusCode}");

            try
            {
                InterfaceRecord interfaceRecord = new InterfaceRecord();
                interfaceRecord.DIRECTION = "WMS->ASRS";
                interfaceRecord.METHOD = "PlanIn";
                interfaceRecord.REQUEST_NO = planCode;
                interfaceRecord.BARCODE = planType;
                interfaceRecord.RESULT = result.code;
                interfaceRecord.START_TIME = startTime.HasValue ? startTime.Value: DateTime.Now;
                interfaceRecord.END_TIME = endTime.HasValue ? endTime.Value: DateTime.Now;
                interfaceRecord.CREATE_TIME = endTime.HasValue ? endTime.Value : DateTime.Now;
                interfaceRecord.PARAM_IN = JsonConvert.SerializeObject(new
                {
                    planCode = planCode,
                    planType = planType,
                    user = user,
                    status = status,
                    orders = strOrders
                }, Formatting.Indented);
                interfaceRecord.PARAM_OUT = JsonConvert.SerializeObject(result, Formatting.Indented);

                await _interfaceService.Append(interfaceRecord);
            }
            catch(Exception e) 
            {
                _logger.LogWarning($"获取入库订单接口[PlanIn]接口记录处理错误。{e.Message}");
            }

            return StatusCode(statusCode, result);
        }

        /// <summary>
        /// 获取出库订单
        /// </summary>
        /// <response code="201">成功</response>
        /// <response code="405">非法操作</response>
        /// <response code="422">请求内容错误</response>
        [HttpPost("planOut")]
        [ProducesResponseType(201)]
        [ProducesResponseType(405)]
        [ProducesResponseType(422)]
        [Anonymous]
        public async Task<IActionResult> PlanOut(
            [FromMember] string requestNo,
            [FromMember] string factoryNo,
            [FromMember] string warehouseNo,
            [FromMember] string targetNo,
            [FromMember] string taskType,
            [FromMember] string requiredTime,
            [FromMember] string statut,
            [FromMember] IEnumerable<OrderList> detials) 
        {
            string strDetials = JsonConvert.SerializeObject(detials);

            _logger.LogInformation($"获取出库订单接口[PlanOut]开始：" +
                $"参数：requestNo-{requestNo} " +
                $"factoryNo-{factoryNo} " +
                $"warehouseNo-{warehouseNo} " +
                $"targetNo-{targetNo} " +
                $"taskType-{taskType} " +
                $"requiredTime-{requiredTime} " +
                $"statut-{statut} " +
                $"detials-{strDetials} ");

            Result result = new Result();
            result.requestNo = requestNo;
            int statusCode = 0;
            DateTime? startTime = null;
            DateTime? endTime = null;

            try
            {
                startTime = DateTime.Now;
                Failure failure = new Failure();


                endTime = DateTime.Now;
                if (failure == null)
                {
                    result.code = "0";
                    statusCode = 201;
                }
                else
                {
                    result.code = "1";
                    result.message = failure.ErrorMessage;
                    statusCode = 422;
                }
            }
            catch (Exception ex)
            {
                statusCode = 422;
                _logger.LogWarning($"获取出库订单接口[PlanOut]异常：原因-{ex.StackTrace}");
                result.code = "1";
                result.message = $"获取出库订单接口[PlanOut]异常：原因-{ex.Message}";
            }
            finally 
            {
                _logger.LogInformation($"获取出库订单接口[PlanOut]结束：结果RESULT-{result.code} 消息MSG-{result.message} statusCode-{statusCode}");

                try
                {
                    InterfaceRecord interfaceRecord = new InterfaceRecord();
                    interfaceRecord.DIRECTION = "MOM->ASRS";
                    interfaceRecord.METHOD = "PlanOut";
                    interfaceRecord.REQUEST_NO = requestNo;
                    interfaceRecord.BARCODE = "";
                    interfaceRecord.RESULT = result.code;
                    interfaceRecord.START_TIME = startTime.HasValue ? startTime.Value : DateTime.Now;
                    interfaceRecord.END_TIME = endTime.HasValue ? endTime.Value : DateTime.Now;
                    interfaceRecord.CREATE_TIME = endTime.HasValue ? endTime.Value : DateTime.Now;
                    interfaceRecord.PARAM_IN = JsonConvert.SerializeObject(new
                    {
                        requestNo = requestNo,
                        factoryNo = factoryNo,
                        warehouseNo = warehouseNo,
                        targetNo = targetNo,
                        taskType = taskType,
                        requiredTime = requiredTime,
                        statut = statut,
                        detials = strDetials
                    }, Formatting.Indented);
                    interfaceRecord.PARAM_OUT = JsonConvert.SerializeObject(result, Formatting.Indented);

                    await _interfaceService.Append(interfaceRecord);
                }
                catch (Exception e)
                {
                    _logger.LogWarning($"获取出库订单接口[PlanOut]接口记录处理错误。{e.Message}");
                }
            }

            return StatusCode(statusCode, result);
        }

        /// <summary>
        /// 线边退库
        /// </summary>
        /// <response code="201">成功</response>
        /// <response code="405">非法操作</response>
        /// <response code="422">请求内容错误</response>
        [HttpPost("goodsBack")]
        [ProducesResponseType(201)]
        [ProducesResponseType(405)]
        [ProducesResponseType(422)]
        [Anonymous]
        public async Task<IActionResult> GoodsBack(
            [FromMember] string requestNo,
            [FromMember] string warehouseNo,
            [FromMember] string taskType, //空托盘，线边退货
            [FromMember] string requiredTime,
            [FromMember] IEnumerable<OrderList> detials)
        {
            string strDetials = JsonConvert.SerializeObject(detials);

            _logger.LogInformation($"线边退库接口[GoodsBack]开始：" +
                $"参数 requestNo-{requestNo} " +
                $"warehouseNo-{warehouseNo} " +
                $"taskType-{taskType} " +
                $"requiredTime-{requiredTime} " +
                $"strDetials-{strDetials} ");

            Result result = new Result();
            int statusCode = 0;
            DateTime? startTime = null;
            DateTime? endTime = null;

            result.requestNo = requestNo;

            try
            {
                if (taskType == "线边退货")
                {
                    (string Device, Failure Failure) commandResult;
                    Failure failure = new Failure();
                    commandResult.Failure = failure;

                    Stock stock = new Stock();
                    stock.Barcode = detials.First().stockBarcode;

                    foreach (OrderList m in detials)
                    {
                        Stock.Line line = new Stock.Line();

                        //var goods = await _
                        line.Material = 5;
                        line.Quantity = m.qty;
                        line.QualityState = "ok";
                        line.Enabled = true;
                        line.Supplier = m.supplier;

                        stock.Lines.Prepend(line);
                    }






                    //commandResult = await _stockCommandService.ScanInbound(stock, full, destination);
                    //failure = commandResult.Failure;        
                }
                else if (taskType == "空托盘")
                {
                }
                else
                {
                    result.code = "1";
                    result.message = $"任务类型[taskType:({taskType})未定义";
                    statusCode = 422;
                }
            }
            catch (Exception ex)
            {
                statusCode = 200;
                _logger.LogWarning($"线边退库接口[GoodsBack]异常：原因-{ex.StackTrace}");
                result.code = "1";
                result.message = $"线边退库接口[GoodsBack]异常：原因-{ex.Message}";
            }
            finally 
            {
                _logger.LogInformation($"线边退库接口[GoodsBack]结束：结果RESULT-{result.code} 消息MSG-{result.message} statusCode-{statusCode}");

                try
                {
                    InterfaceRecord interfaceRecord = new InterfaceRecord();
                    interfaceRecord.DIRECTION = "MOM->ASRS";
                    interfaceRecord.METHOD = "GoodsBack";
                    interfaceRecord.REQUEST_NO = requestNo;
                    interfaceRecord.BARCODE = detials.First().stockBarcode;
                    interfaceRecord.RESULT = result.code;
                    interfaceRecord.START_TIME = startTime.HasValue ? startTime.Value : DateTime.Now;
                    interfaceRecord.END_TIME = endTime.HasValue ? endTime.Value : DateTime.Now;
                    interfaceRecord.CREATE_TIME = endTime.HasValue ? endTime.Value : DateTime.Now;
                    interfaceRecord.PARAM_IN = JsonConvert.SerializeObject(new
                    {
                        requestNo = requestNo,
                        warehouseNo = warehouseNo,
                        taskType = taskType,
                        requiredTime = requiredTime,
                        detials = strDetials
                    }, Formatting.Indented);
                    interfaceRecord.PARAM_OUT = JsonConvert.SerializeObject(result, Formatting.Indented);

                    await _interfaceService.Append(interfaceRecord);
                }
                catch (Exception e)
                {
                    _logger.LogWarning($"属性更改接口[Freeze]接口记录处理错误。{e.Message}");
                }
            }

            return StatusCode(statusCode, result);
        }

        /// <summary>
        /// 模拟 入库订单完成
        /// </summary>
        [HttpPost("feedbackIn")]
        [Anonymous]
        public IActionResult FeedbackIn()
        {
            return StatusCode(200, new
            {
                requestNo = "requestNo",
                code = "1",
                message = "失败"
            });
        }

        /// <summary>
        /// 模拟 配送任务完成结果接口
        /// </summary>
        [HttpPost("feedbackPlanOut")]
        [Anonymous]
        public async Task<IActionResult> FeedbackPlanOut()
        {
            return StatusCode(200, new
            {
                requestNo = "requestNo",
                code = "1",
                message = "失败"
            });
        }

        /// <summary>
        /// 模拟 线边退货完成接口
        /// </summary>
        [HttpPost("feedbackBackIn")]
        [Anonymous]
        public IActionResult FeedbackBackIn()
        {
            return StatusCode(200, new
            {
                requestNo = "requestNo",
                code = "1",
                message = "失败"
            });
        }
        
        /// <summary>
        /// 模拟 设备状态接口
        /// </summary>
        [HttpPost("deviceStatus")]
        [Anonymous]
        public IActionResult DeviceStatus()
        {
            return StatusCode(200, new
            {
                requestNo = "requestNo",
                code = "0",
                message = "test成功"
            });
        }
    }
}