feat(router): 添加托盘操作页面路由

wanshenmean

3 天以前 b690250002ee04f4309e6a90fd16fbfd9bd959e2

 Code/WMS/WIDESEA_WMSServer/WIDESEA_TaskInfoService/TaskService_GradingMachine.cs

@@ -1,33 +1,26 @@
using Mapster;
using MapsterMapper;
using Microsoft.Extensions.Configuration;
using SqlSugar;
using System.DirectoryServices.Protocols;
using Serilog;
using System.Text.Json;
using System.Text.Encodings.Web;
using System.Text.Unicode;
using WIDESEA_Common.Constants;
using WIDESEA_Common.LocationEnum;
using WIDESEA_Common.StockEnum;
using WIDESEA_Common.TaskEnum;
using WIDESEA_Common.WareHouseEnum;
using WIDESEA_Core;
using WIDESEA_Core.BaseRepository;
using WIDESEA_Core.BaseServices;
using WIDESEA_Core.Core;
using WIDESEA_Core.Enums;
using WIDESEA_Core.Helper;
using WIDESEA_DTO.GradingMachine;
using WIDESEA_DTO.MES;
using WIDESEA_DTO.Stock;
using WIDESEA_DTO.Task;
using WIDESEA_IBasicService;
using WIDESEA_IStockService;
using WIDESEA_ITaskInfoService;
using WIDESEA_Model.Models;

namespace WIDESEA_TaskInfoService
{
    public partial class TaskService
    {
        /// <summary>
        /// JSON序列化选项（中文不转义）
        /// </summary>
        private static readonly JsonSerializerOptions _jsonOptions = new()
        {
            Encoder = JavaScriptEncoder.Create(UnicodeRanges.All)
        };
        #region 分容柜接口

        /// <summary>
@@ -35,39 +28,51 @@
        /// </summary>
        public async Task<WebResponseContent> InOrOutCompletedAsync(GradingMachineInputDto input)
        {
            var log = Log.ForContext("SourceContext", "分容柜完成信号");
            log.Information("[InOrOutCompleted] 请求参数: {Request}", JsonSerializer.Serialize(input, _jsonOptions));
            WebResponseContent content = new WebResponseContent();
            if (string.IsNullOrWhiteSpace(input.PalletCode) || string.IsNullOrWhiteSpace(input.LocationCode))
            if (string.IsNullOrWhiteSpace(input.LocationCode))
            {
                return content.Error($"托盘号或者货位编号不能为空");
                var errResult = content.Error($"货位编号不能为空");
                log.Warning("[InOrOutCompleted] 响应: {Response}", JsonSerializer.Serialize(errResult, _jsonOptions));
                return errResult;
            }

            try
            {
                var stockInfo = await _stockInfoService.GetStockInfoAsync(input.PalletCode, input.LocationCode);
                var stockInfo = await _stockInfoService.GetStockInfoAsync(3, input.LocationCode);

                int locationStatus;
                if (stockInfo == null)
                {
                    var location = await _locationInfoService.GetLocationInfoAsync(input.LocationCode);
                    locationStatus = location?.LocationStatus ?? 0;
                    var errResult = content.Error("WMS未找到库存信息");
                    log.Warning("[InOrOutCompleted] 响应: {Response}", JsonSerializer.Serialize(errResult, _jsonOptions));
                    return errResult;
                }
                else
                locationStatus = MapLocationStatus(stockInfo.StockStatus);

                int MapLocationStatus(int stockStatus) => stockStatus switch
                {
                    locationStatus = stockInfo.LocationDetails?.LocationStatus ?? 0;
                }
                    (int)StockStatusEmun.入库完成 => 10,
                    (int)StockStatusEmun.空托盘库存 => 11,
                    _ => 0
                };

                OutputDto outPutDto = new OutputDto()
                {
                    LocationCode = input.LocationCode,
                    PalletCode = input.PalletCode,
                    PalletCode = stockInfo.PalletCode,
                    IsNormalProcedure = 1,
                    LocationStatus = locationStatus
                };
                return content.OK(data: outPutDto);
                var result = content.OK(data: outPutDto);
                log.Information("[InOrOutCompleted] 响应: {Response}", JsonSerializer.Serialize(result, _jsonOptions));
                return result;
            }
            catch (Exception ex)
            {
                content.Error(ex.Message);
                log.Error(ex, "[InOrOutCompleted] 异常");
            }

            return content;
@@ -80,10 +85,14 @@
        /// <returns></returns>
        public async Task<WebResponseContent> SendLocationStatusAsync(GradingMachineInputDto input)
        {
            var log = Log.ForContext("SourceContext", "分容柜状态更新");
            log.Information("[SendLocationStatus] 请求参数: {Request}", JsonSerializer.Serialize(input, _jsonOptions));
            WebResponseContent content = new WebResponseContent();
            if (string.IsNullOrWhiteSpace(input.LocationCode))
            {
                return content.Error($"货位编号不能为空");
                var errResult = content.Error($"货位编号不能为空");
                log.Warning("[SendLocationStatus] 响应: {Response}", JsonSerializer.Serialize(errResult, _jsonOptions));
                return errResult;
            }

            try
@@ -91,8 +100,8 @@
                var result = await _locationInfoService.Db.Updateable<Dt_LocationInfo>()
                    .SetColumns(s => new Dt_LocationInfo
                    {
                        LocationStatus = input.LocationStatus
                    }).Where(s => s.LocationCode == input.LocationCode).ExecuteCommandAsync() > 0;
                        EnableStatus = input.LocationStatus == 1 ? 0 : 3,
                    }).Where(s => s.LocationCode == input.LocationCode && s.RoadwayNo == TaskAddressConstants.GRADING_RoadWayNo).ExecuteCommandAsync() > 0;

                if (result)
                {
@@ -102,10 +111,12 @@
                {
                    content.Error("更新失败");
                }
                log.Information("[SendLocationStatus] 响应: {Response}", JsonSerializer.Serialize(content, _jsonOptions));
            }
            catch (Exception ex)
            {
                content.Error(ex.Message);
                log.Error(ex, "[SendLocationStatus] 异常");
            }
            return content;
        }
@@ -117,54 +128,66 @@
        /// <returns></returns>
        public async Task<WebResponseContent> RequestOutboundAsync(GradingMachineInputDto input)
        {
            var log = Log.ForContext("SourceContext", "分容柜出库请求");
            log.Information("[RequestOutbound] 请求参数: {Request}", JsonSerializer.Serialize(input, _jsonOptions));
            WebResponseContent content = new WebResponseContent();
            if (string.IsNullOrWhiteSpace(input.LocationCode) || string.IsNullOrWhiteSpace(input.PalletCode))
            {
                return content.Error($"托盘号或者货位编号不能为空");
                var errResult = content.Error($"托盘号或者货位编号不能为空");
                log.Warning("[RequestOutbound] 响应: {Response}", JsonSerializer.Serialize(errResult, _jsonOptions));
                return errResult;
            }
            try
            {
                var stock = await _stockInfoService.GetStockInfoAsync(input.PalletCode, input.LocationCode);
                if (stock == null)
                {
                    content.Error("未找到对应的托盘");
                    var errResult = content.Error("未找到对应的托盘");
                    log.Warning("[RequestOutbound] 响应: {Response}", JsonSerializer.Serialize(errResult, _jsonOptions));
                    return errResult;
                }
                else
                {
                    var taskList = new Dt_Task
                    {
                        WarehouseId = stock.WarehouseId,
                        PalletCode = stock.PalletCode,
                        PalletType = stock.PalletType,
                        SourceAddress = stock.LocationCode,
                        CurrentAddress = stock.LocationCode,
                        NextAddress = TaskAddressConstants.DEFAULT_ADDRESS,
                        TargetAddress = TaskAddressConstants.GRADING_OUTBOUND_ADDRESS,
                        Roadway = stock.LocationDetails.RoadwayNo,
                        TaskType = TaskTypeEnum.Outbound.GetHashCode(),
                        TaskStatus = TaskStatusEnum.New.GetHashCode(),
                        Grade = 1,
                        TaskNum = await BaseDal.GetTaskNo(),
                        Creater = "system",
                    };

                var taskList = new Dt_Task
                {
                    WarehouseId = stock.WarehouseId,
                    PalletCode = stock.PalletCode,
                    PalletType = stock.PalletType,
                    SourceAddress = stock.LocationCode,
                    CurrentAddress = stock.LocationCode,
                    NextAddress = TaskAddressConstants.GRADING_OUTBOUND_ADDRESS,
                    TargetAddress = TaskAddressConstants.GRADING_OUTBOUND_ADDRESS,
                    Roadway = stock.LocationDetails.RoadwayNo,
                    TaskType = TaskOutboundTypeEnum.Outbound.GetHashCode(),
                    TaskStatus = TaskOutStatusEnum.OutNew.GetHashCode(),
                    Grade = 1,
                    TaskNum = await BaseDal.GetTaskNo(),
                    Creater = "system",
                };

                return await _unitOfWorkManage.BeginTranAsync(async () =>
                {
                    var result = await BaseDal.AddDataAsync(taskList) > 0;
                    var wmstaskDto = result ? _mapper.Map<WMSTaskDTO>(taskList) : null;

                    var httpResponse = _httpClientHelper.Post<WebResponseContent>("http://logistics-service/api/logistics/notifyoutbound", JsonSerializer.Serialize(wmstaskDto)).Data;
                    var wmsTaskDtos = new List<WMSTaskDTO> { wmstaskDto };
                    var httpResponse = _httpClientHelper.Post<WebResponseContent>("http://localhost:9292/api/Task/ReceiveTask", JsonSerializer.Serialize(wmsTaskDtos)).Data;
                    if (result && httpResponse != null)
                    {
                        content.OK("出库请求成功");
                        var okResult = content.OK("出库请求成功");
                        log.Information("[RequestOutbound] 响应: {Response}", JsonSerializer.Serialize(okResult, _jsonOptions));
                        return okResult;
                    }
                    else
                    {
                        content.Error("出库请求失败");
                        var errResult = content.Error("出库请求失败");
                        log.Warning("[RequestOutbound] 响应: {Response}", JsonSerializer.Serialize(errResult, _jsonOptions));
                        return errResult;
                    }
                }
                });
            }
            catch (Exception ex)
            {
                content.Error(ex.Message);
                log.Error(ex, "[RequestOutbound] 异常");
            }
            return content;
        }
@@ -176,31 +199,44 @@
        /// <returns></returns>
        public async Task<WebResponseContent> GetPalletCodeCellAsync(GradingMachineInputDto input)
        {
            var log = Log.ForContext("SourceContext", "分容柜电芯查询");
            log.Information("[GetPalletCodeCell] 请求参数: {Request}", JsonSerializer.Serialize(input, _jsonOptions));
            WebResponseContent content = new WebResponseContent();
            if (string.IsNullOrWhiteSpace(input.PalletCode) || string.IsNullOrWhiteSpace(input.LocationCode))
            {
                return content.Error($"托盘号或者货位编号不能为空");
                var errResult = content.Error($"托盘号或者货位编号不能为空");
                log.Warning("[GetPalletCodeCell] 响应: {Response}", JsonSerializer.Serialize(errResult, _jsonOptions));
                return errResult;
            }
            try
            {
                var stockInfo = await _stockInfoService.GetStockInfoAsync(input.PalletCode, input.LocationCode);
                if (stockInfo == null)
                {
                    return content.Error("未找到对应的托盘");
                    var errResult = content.Error("未找到对应的托盘");
                    log.Warning("[GetPalletCodeCell] 响应: {Response}", JsonSerializer.Serialize(errResult, _jsonOptions));
                    return errResult;
                }
                var outPutDtos = stockInfo.Details.Select(x => new OutputDto()

                var outPutDtos = new
                {
                    LocationCode = input.LocationCode,
                    PalletCode = input.PalletCode,
                    input.LocationCode,
                    input.PalletCode,
                    IsNormalProcedure = 1,
                    LocationStatus = stockInfo.LocationDetails.LocationStatus,
                    CellCode = x.SerialNumber,
                    Channel = x.InboundOrderRowNo.ToString()
                }).ToList();
                return content.OK(data: outPutDtos);
                    stockInfo.LocationDetails.LocationStatus,
                    Data = stockInfo.Details.Select(x => new CellCodeData
                    {
                        CellCode = x.SerialNumber,
                        Channel = x.InboundOrderRowNo.ToString()
                    }).ToList()
                };
                var result = content.OK(data: outPutDtos);
                log.Information("[GetPalletCodeCell] 响应: {Response}", JsonSerializer.Serialize(result, _jsonOptions));
                return result;
            }
            catch (Exception ex)
            {
                log.Error(ex, "[GetPalletCodeCell] 异常");
                return content.Error(ex.Message);
            }
        }