using Microsoft.AspNetCore.Mvc;
|
using WIDESEA_Core;
|
using WIDESEA_Core.BaseController;
|
using WIDESEA_DTO.Outbound;
|
using WIDESEA_IOutboundService;
|
using WIDESEA_Model.Models;
|
using static WIDESEA_OutboundService.OutboundBatchPickingService;
|
|
namespace WIDESEA_WMSServer.Controllers.Outbound
|
{
|
|
[Route("api/OutboundBatchPicking")]
|
[ApiController]
|
public class OutboundBatchPickingController : ApiBaseController<IOutboundBatchPickingService, Dt_PickingRecord>
|
{
|
private readonly ISplitPackageService _splitPackageService;
|
private readonly IOutStockLockInfoService _outStockLockInfoService;
|
private readonly IOutboundBatchPickingService _outboundBatchPickingService;
|
|
private readonly ILogger<OutboundBatchPickingController> _logger;
|
public OutboundBatchPickingController(IOutboundBatchPickingService service, ISplitPackageService splitPackageService, IOutStockLockInfoService outStockLockInfoService, IOutboundBatchPickingService outboundBatchPickingService, ILogger<OutboundBatchPickingController> logger) : base(service)
|
{
|
_splitPackageService = splitPackageService;
|
_outStockLockInfoService = outStockLockInfoService;
|
_outboundBatchPickingService = outboundBatchPickingService;
|
_logger = logger;
|
}
|
|
/// <summary>
|
/// 分拣确认
|
/// </summary>
|
[HttpPost("confirm-picking")]
|
public async Task<WebResponseContent> ConfirmPicking([FromBody] ConfirmPickingDto dto)
|
{
|
return await _outboundBatchPickingService.ConfirmBatchPicking(dto.OrderNo, dto.PalletCode, dto.Barcode);
|
}
|
|
/// <summary>
|
/// 取消分拣
|
/// </summary>
|
[HttpPost("cancel-picking")]
|
public async Task<WebResponseContent> CancelPicking([FromBody] CancelPickingDto dto)
|
{
|
return await _outboundBatchPickingService.CancelPicking(dto.OrderNo, dto.PalletCode, dto.Barcode);
|
}
|
/// <summary>
|
/// 取消拆包链
|
/// </summary>
|
[HttpPost("cancel-split-chain")]
|
public async Task<WebResponseContent> CancelSplitChain([FromBody] CancelSplitChainDto dto)
|
{
|
return await _outboundBatchPickingService.CancelSplitPackageChain(dto.OrderNo, dto.PalletCode, dto.StartBarcode);
|
}
|
|
/// <summary>
|
/// 获取拆包链信息
|
/// </summary>
|
[HttpPost("split-package-chain-info")]
|
public async Task<WebResponseContent> GetSplitPackageChainInfo([FromBody] SplitPackageChainInfoRequestDto dto)
|
{
|
return await _outboundBatchPickingService.GetSplitPackageChainInfo(dto.OrderNo, dto.Barcode);
|
}
|
/// <summary>
|
/// 查找完整拆包链（从根条码开始）
|
/// </summary>
|
[HttpPost("find-root-split-chain")]
|
public async Task<WebResponseContent> FindRootSplitChain([FromBody] SplitPackageChainInfoRequestDto dto)
|
{
|
try
|
{
|
// 查找根条码
|
var rootBarcode = await _outboundBatchPickingService. FindRootBarcode(dto.OrderNo, dto.Barcode);
|
|
// 获取完整拆包链
|
var splitChain = await _outboundBatchPickingService.GetSplitPackageChain(dto.OrderNo, rootBarcode);
|
|
var chainInfo = new SplitPackageChainInfoDto
|
{
|
OriginalBarcode = rootBarcode,
|
RootBarcode = rootBarcode,
|
TotalSplitTimes = splitChain.Count,
|
ChainType = "root",
|
SplitChain = splitChain.Select(x => new SplitChainItemDto
|
{
|
SplitTime = x.SplitTime,
|
OriginalBarcode = x.OriginalBarcode,
|
NewBarcode = x.NewBarcode,
|
SplitQuantity = x.SplitQty,
|
Operator = x.Operator,
|
IsReverted = x.IsReverted
|
}).ToList()
|
};
|
|
return WebResponseContent.Instance.OK("获取成功", chainInfo);
|
}
|
catch (Exception ex)
|
{
|
_logger.LogError($"查找完整拆包链失败 - OrderNo: {dto.OrderNo}, Barcode: {dto.Barcode}, Error: {ex.Message}");
|
return WebResponseContent.Instance.Error("查找完整拆包链失败");
|
}
|
}
|
/// <summary>
|
/// 手动拆包
|
/// </summary>
|
[HttpPost("split-package")]
|
public async Task<WebResponseContent> SplitPackage([FromBody] SplitPackageDto dto)
|
{
|
return await _outboundBatchPickingService.ManualSplitPackage(dto.OrderNo, dto.PalletCode, dto.OriginalBarcode, dto.SplitQuantity);
|
}
|
/// <summary>
|
/// 取消拆包
|
/// </summary>
|
[HttpPost("cancel-split")]
|
public async Task<WebResponseContent> CancelSplit([FromBody] CancelSplitDto dto)
|
{
|
return await _outboundBatchPickingService.CancelSplitPackage(dto.OrderNo, dto.PalletCode, dto.NewBarcode);
|
}
|
|
/// <summary>
|
/// 分批回库
|
/// </summary>
|
[HttpPost("return-stock")]
|
public async Task<WebResponseContent> ReturnStock([FromBody] ReturnStockDto dto)
|
{
|
return await _outboundBatchPickingService.BatchReturnStock(dto.OrderNo, dto.PalletCode);
|
}
|
|
/// <summary>
|
/// 获取托盘的锁定信息
|
/// </summary>
|
[HttpPost("pallet-locks")]
|
public async Task<WebResponseContent> GetPalletLocks([FromBody] PalletLocksDto dto)
|
{
|
try
|
{
|
var locks = await _outboundBatchPickingService.GetPalletLockInfos(dto.OrderNo, dto.PalletCode);
|
return WebResponseContent.Instance.OK("获取成功", locks);
|
}
|
catch (Exception ex)
|
{
|
_logger.LogError(ex, $"获取托盘锁定信息异常 - OrderNo: {dto.OrderNo}, PalletCode: {dto.PalletCode}");
|
return WebResponseContent.Instance.Error("系统异常，请稍后重试" + ex.Message);
|
}
|
}
|
/// <summary>
|
/// 获取已拣选列表
|
/// </summary>
|
[HttpPost("pallet-picked-list")]
|
public async Task<WebResponseContent> GetPalletPickedList([FromBody] PalletLocksDto dto)
|
{
|
try
|
{
|
var pickedList = await _outboundBatchPickingService.GetPalletPickedList(dto.OrderNo, dto.PalletCode);
|
return WebResponseContent.Instance.OK("获取成功", pickedList);
|
}
|
catch (Exception ex)
|
{
|
_logger.LogError(ex, $"获取已拣选列表异常 - OrderNo: {dto.OrderNo}, PalletCode: {dto.PalletCode}");
|
return WebResponseContent.Instance.Error("系统异常，请稍后重试" + ex.Message);
|
}
|
}
|
|
/// <summary>
|
/// 获取托盘状态
|
/// </summary>
|
[HttpPost("pallet-status")]
|
public async Task<WebResponseContent> GetPalletStatus([FromBody] PalletLocksDto dto)
|
{
|
try
|
{
|
var status = await _outboundBatchPickingService.GetPalletStatus(dto.OrderNo, dto.PalletCode);
|
return WebResponseContent.Instance.OK("获取成功", status);
|
}
|
catch (Exception ex)
|
{
|
_logger.LogError(ex, $"获取托盘状态异常 - OrderNo: {dto.OrderNo}, PalletCode: {dto.PalletCode}");
|
return WebResponseContent.Instance.Error("系统异常，请稍后重试" + ex.Message);
|
}
|
}
|
|
/// <summary>
|
/// 获取拆包信息
|
/// </summary>
|
[HttpPost("split-package-info")]
|
public async Task<WebResponseContent> GetSplitPackageInfo([FromBody] SplitPackageInfoDto dto)
|
{
|
try
|
{
|
var info = await _outboundBatchPickingService.GetSplitPackageInfo(dto.OrderNo, dto.PalletCode, dto.Barcode);
|
return WebResponseContent.Instance.OK("获取成功", info);
|
}
|
catch (Exception ex)
|
{
|
_logger.LogError(ex, $"获取拆包信息异常 - OrderNo: {dto.OrderNo}, PalletCode: {dto.PalletCode}, Barcode: {dto.Barcode}");
|
return WebResponseContent.Instance.Error("系统异常，请稍后重试" +ex.Message);
|
}
|
}
|
|
/// <summary>
|
/// 取走空箱
|
/// </summary>
|
[HttpPost("remove-empty-pallet")]
|
public async Task<WebResponseContent> RemoveEmptyPallet([FromBody] RemoveEmptyPalletDto dto)
|
{
|
try
|
{
|
var result = await _outboundBatchPickingService.RemoveEmptyPallet(dto.OrderNo, dto.PalletCode);
|
return result;
|
}
|
catch (Exception ex)
|
{
|
_logger.LogError(ex, $"取走空箱异常 - OrderNo: {dto.OrderNo}, PalletCode: {dto.PalletCode}");
|
return WebResponseContent.Instance.Error("系统异常，请稍后重试" +ex.Message);
|
}
|
}
|
|
}
|
|
}
|
