From 42cb7e13165395327f2f9de6c1def858a18424b2 Mon Sep 17 00:00:00 2001
From: pan <antony1029@163.com>
Date: 星期一, 08 十二月 2025 14:57:51 +0800
Subject: [PATCH] 提交
---
项目代码/WMS无仓储版/WIDESEA_WMSServer/WIDESEA_OutboundService/OutboundBatchPickingService.cs | 4597 ++++++++++++++++++++++++++++++++++++++++++++++++++++++-----
1 files changed, 4,193 insertions(+), 404 deletions(-)
diff --git "a/\351\241\271\347\233\256\344\273\243\347\240\201/WMS\346\227\240\344\273\223\345\202\250\347\211\210/WIDESEA_WMSServer/WIDESEA_OutboundService/OutboundBatchPickingService.cs" "b/\351\241\271\347\233\256\344\273\243\347\240\201/WMS\346\227\240\344\273\223\345\202\250\347\211\210/WIDESEA_WMSServer/WIDESEA_OutboundService/OutboundBatchPickingService.cs"
index bbd2251..bb29ac6 100644
--- "a/\351\241\271\347\233\256\344\273\243\347\240\201/WMS\346\227\240\344\273\223\345\202\250\347\211\210/WIDESEA_WMSServer/WIDESEA_OutboundService/OutboundBatchPickingService.cs"
+++ "b/\351\241\271\347\233\256\344\273\243\347\240\201/WMS\346\227\240\344\273\223\345\202\250\347\211\210/WIDESEA_WMSServer/WIDESEA_OutboundService/OutboundBatchPickingService.cs"
@@ -1,5 +1,6 @@
锘縰sing Microsoft.Extensions.Logging;
using SqlSugar;
+using SqlSugar.Extensions;
using System;
using System.Collections.Generic;
using System.Linq;
@@ -9,14 +10,18 @@
using WIDESEA_Common.CommonEnum;
using WIDESEA_Common.OrderEnum;
using WIDESEA_Common.StockEnum;
+using WIDESEA_Common.TaskEnum;
using WIDESEA_Core;
using WIDESEA_Core.BaseRepository;
using WIDESEA_Core.BaseServices;
+using WIDESEA_Core.Enums;
+using WIDESEA_DTO.Basic;
using WIDESEA_DTO.Outbound;
using WIDESEA_IAllocateService;
using WIDESEA_IBasicService;
using WIDESEA_IOutboundService;
using WIDESEA_IStockService;
+using WIDESEA_ITaskInfoService;
using WIDESEA_Model.Models;
using WIDESEA_Model.Models.Basic;
using WIDESEA_Model.Models.Outbound;
@@ -45,6 +50,7 @@
private readonly IDailySequenceService _dailySequenceService;
private readonly IAllocateService _allocateService;
private readonly IRepository<Dt_OutboundBatch> _outboundBatchRepository;
+ private readonly ITask_HtyService _task_HtyService;
private readonly ILogger<OutboundPickingService> _logger;
private Dictionary<string, string> stations = new Dictionary<string, string>
@@ -64,7 +70,7 @@
public OutboundBatchPickingService(IRepository<Dt_PickingRecord> BaseDal, IUnitOfWorkManage unitOfWorkManage, IStockInfoService stockInfoService, IStockService stockService,
IOutStockLockInfoService outStockLockInfoService, IStockInfoDetailService stockInfoDetailService, ILocationInfoService locationInfoService,
IOutboundOrderDetailService outboundOrderDetailService, ISplitPackageService splitPackageService, IOutboundOrderService outboundOrderService,
- IRepository<Dt_Task> taskRepository, IESSApiService eSSApiService, ILogger<OutboundPickingService> logger, IInvokeMESService invokeMESService, IDailySequenceService dailySequenceService, IAllocateService allocateService, IRepository<Dt_OutboundBatch> outboundBatchRepository) : base(BaseDal)
+ IRepository<Dt_Task> taskRepository, IESSApiService eSSApiService, ILogger<OutboundPickingService> logger, IInvokeMESService invokeMESService, IDailySequenceService dailySequenceService, IAllocateService allocateService, IRepository<Dt_OutboundBatch> outboundBatchRepository, ITask_HtyService task_HtyService) : base(BaseDal)
{
_unitOfWorkManage = unitOfWorkManage;
_stockInfoService = stockInfoService;
@@ -82,6 +88,7 @@
_dailySequenceService = dailySequenceService;
_allocateService = allocateService;
_outboundBatchRepository = outboundBatchRepository;
+ _task_HtyService = task_HtyService;
}
// <summary>
@@ -216,7 +223,7 @@
.Where(x => x.OrderNo == orderNo &&
x.PalletCode == palletCode &&
x.CurrentBarcode == barcode
- //&& x.Status == (int)OutLockStockStatusEnum.鍑哄簱涓�
+ //&& x.Status == (int)OutLockStockStatusEnum.鍑哄簱涓�
)
.FirstAsync();
@@ -240,50 +247,140 @@
#endregion
- #region 鍙栬蛋绌虹閫昏緫
+ #region 鍒嗘壒鍒嗘嫞
/// <summary>
- /// 鍙栬蛋绌虹 - 娓呯悊宸插畬鎴愭嫞閫夌殑鎵樼洏鏁版嵁
+ /// 鍒嗘壒鍒嗘嫞纭
/// </summary>
- public async Task<WebResponseContent> RemoveEmptyPallet(string orderNo, string palletCode)
+ public async Task<WebResponseContent> ConfirmBatchPicking(string orderNo, string palletCode, string barcode)
{
try
{
_unitOfWorkManage.BeginTran();
- // 楠岃瘉鎵樼洏鏄惁鍙互鍙栬蛋锛堝繀椤诲叏閮ㄥ畬鎴愭嫞閫夛級
- var validationResult = await ValidateEmptyPalletRemoval(orderNo, palletCode);
+ // 楠岃瘉鍒嗘嫞璇锋眰
+ var validationResult = await ValidatePickingRequest(orderNo, palletCode, barcode);
if (!validationResult.IsValid)
+ {
+ _unitOfWorkManage.RollbackTran();
return WebResponseContent.Instance.Error(validationResult.ErrorMessage);
+ }
- var completedLocks = validationResult.Data;
+ var (lockInfo, orderDetail, stockDetail, batch) = validationResult.Data;
- // 娓呯悊閿佸畾璁板綍锛堟爣璁颁负宸插畬鎴愶級
- await CleanupCompletedLocks(completedLocks);
+ // 妫�鏌ユ槸鍚﹂渶瑕佽嚜鍔ㄦ媶鍖�
+ var autoSplitResult = await CheckAndAutoSplitIfNeeded(lockInfo, stockDetail, palletCode);
+ if (autoSplitResult != null)
+ {
+ // 濡傛灉鎵ц浜嗚嚜鍔ㄦ媶鍖咃紝閲嶆柊鑾峰彇鏈�鏂扮殑閿佸畾淇℃伅鍜屽簱瀛樹俊鎭�
+ var refreshedValidation = await ValidatePickingRequest(orderNo, palletCode, barcode);
+ if (!refreshedValidation.IsValid)
+ {
+ _unitOfWorkManage.RollbackTran();
+ return WebResponseContent.Instance.Error(refreshedValidation.ErrorMessage);
+ }
- // 鏇存柊鐩稿叧璁㈠崟鐘舵��
- await UpdateOrderStatusAfterPalletRemoval(orderNo);
+ (lockInfo, orderDetail, stockDetail, batch) = refreshedValidation.Data;
- // 璁板綍鎿嶄綔鍘嗗彶
- // await RecordEmptyPalletRemoval(orderNo, palletCode, completedLocks);
+
+ var actualPickedQty = lockInfo.AssignQuantity;
+ var pickingResult = await ExecutePickingLogic(lockInfo, orderDetail, stockDetail, actualPickedQty);
+
+ // 鏇存柊鎵规鍜岃鍗曟暟鎹�
+ await UpdateBatchAndOrderData(batch, orderDetail, actualPickedQty, orderNo);
+
+ // 璁板綍鎷ｉ�夊巻鍙�
+ await RecordPickingHistory(pickingResult, orderNo, palletCode);
+
+ _unitOfWorkManage.CommitTran();
+
+ return WebResponseContent.Instance.OK("鑷姩鎷嗗寘骞跺垎鎷ｆ垚鍔�", autoSplitResult);
+ }
+
+ // 姝ｅ父鍒嗘嫞娴佺▼锛堜笉闇�瑕佽嚜鍔ㄦ媶鍖咃級
+ var normalPickedQty = lockInfo.AssignQuantity;
+ var normalPickingResult = await ExecutePickingLogic(lockInfo, orderDetail, stockDetail, normalPickedQty);
+
+ // 鏇存柊鎵规鍜岃鍗曟暟鎹�
+ await UpdateBatchAndOrderData(batch, orderDetail, normalPickedQty, orderNo);
+
+ // 璁板綍鎷ｉ�夊巻鍙�
+ await RecordPickingHistory(normalPickingResult, orderNo, palletCode);
_unitOfWorkManage.CommitTran();
- return WebResponseContent.Instance.OK("鍙栬蛋绌虹鎴愬姛");
+ return WebResponseContent.Instance.OK("鍒嗘嫞鎴愬姛", new
+ {
+ PickedQuantity = normalPickedQty,
+ Barcode = barcode,
+ MaterialCode = lockInfo.MaterielCode,
+ AutoSplitted = false
+ });
}
catch (Exception ex)
{
_unitOfWorkManage.RollbackTran();
- _logger.LogError($"鍙栬蛋绌虹澶辫触 - OrderNo: {orderNo}, PalletCode: {palletCode}, Error: {ex.Message}");
- return WebResponseContent.Instance.Error($"鍙栬蛋绌虹澶辫触锛歿ex.Message}");
+ _logger.LogError($"鍒嗘嫞澶辫触 - OrderNo: {orderNo}, PalletCode: {palletCode}, Barcode: {barcode}, Error: {ex.Message}");
+ return WebResponseContent.Instance.Error($"鍒嗘嫞澶辫触锛歿ex.Message}");
}
}
+ /// <summary>
+ /// 鍙栨秷鍒嗘嫞
+ /// </summary>
+ public async Task<WebResponseContent> CancelPicking(string orderNo, string palletCode, string barcode)
+ {
+ try
+ {
+ _unitOfWorkManage.BeginTran();
+
+ // 鏌ユ壘鍒嗘嫞璁板綍
+ var pickingRecord = await Db.Queryable<Dt_PickingRecord>()
+ .Where(x => x.OrderNo == orderNo &&
+ x.PalletCode == palletCode &&
+ x.Barcode == barcode &&
+ !x.IsCancelled)
+ .OrderByDescending(x => x.PickTime)
+ .FirstAsync();
+
+ if (pickingRecord == null)
+ return WebResponseContent.Instance.Error("鏈壘鍒板垎鎷ｈ褰�");
+
+ // 鎭㈠閿佸畾淇℃伅鍜屽簱瀛�
+ var revertResult = await RevertPickingData(pickingRecord);
+
+ // 鏇存柊鎵规鍜岃鍗曟暟鎹�
+ await RevertBatchAndOrderData(pickingRecord, revertResult);
+
+ // 鏍囪鍒嗘嫞璁板綍涓哄凡鍙栨秷
+ pickingRecord.IsCancelled = true;
+ pickingRecord.CancelTime = DateTime.Now;
+ pickingRecord.CancelOperator = App.User.UserName;
+ await Db.Updateable(pickingRecord).ExecuteCommandAsync();
+
+ _unitOfWorkManage.CommitTran();
+
+ return WebResponseContent.Instance.OK("鍙栨秷鍒嗘嫞鎴愬姛");
+ }
+ catch (Exception ex)
+ {
+ _unitOfWorkManage.RollbackTran();
+ _logger.LogError($"鍙栨秷鍒嗘嫞澶辫触 - OrderNo: {orderNo}, PalletCode: {palletCode}, Error: {ex.Message}");
+ return WebResponseContent.Instance.Error($"鍙栨秷鍒嗘嫞澶辫触锛歿ex.Message}");
+ }
+ }
+ #endregion
+
+
+ #region 鍙栬蛋绌虹閫昏緫
+
/// <summary>
- /// 楠岃瘉绌虹鍙栬蛋鏉′欢
+ /// 楠岃瘉绌虹鍙栬蛋鏉′欢
/// </summary>
private async Task<ValidationResult<List<Dt_OutStockLockInfo>>> ValidateEmptyPalletRemoval(string orderNo, string palletCode)
{
+ _logger.LogInformation($"寮�濮嬮獙璇佺┖鎵樼洏鍙栬蛋 - 璁㈠崟: {orderNo}, 鎵樼洏: {palletCode}");
+
// 鑾峰彇鎵樼洏鐨勬墍鏈夐攣瀹氳褰�
var lockInfos = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
.Where(x => x.OrderNo == orderNo && x.PalletCode == palletCode)
@@ -292,7 +389,33 @@
if (!lockInfos.Any())
return ValidationResult<List<Dt_OutStockLockInfo>>.Error("璇ユ墭鐩樻病鏈夐攣瀹氳褰�");
- // 妫�鏌ユ槸鍚︽湁鏈畬鎴愮殑閿佸畾璁板綍
+ // 鑾峰彇搴撳瓨淇℃伅
+ var stockInfo = await _stockInfoService.Db.Queryable<Dt_StockInfo>()
+ .FirstAsync(x => x.PalletCode == palletCode);
+
+ if (stockInfo == null)
+ {
+ _logger.LogWarning($"鏈壘鍒版墭鐩樼殑搴撳瓨淇℃伅锛屽彲鑳藉凡琚竻鐞�");
+ // 濡傛灉鎵句笉鍒板簱瀛樹俊鎭紝鍙鏌ラ攣瀹氳褰�
+ }
+ else
+ {
+ // 妫�鏌ユ墭鐩樹笂鏄惁杩樻湁搴撳瓨璐х墿
+ var remainingStock = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
+ .Where(x => x.StockId == stockInfo.Id &&
+ x.StockQuantity > 0) // 鍙鏌ユ暟閲忓ぇ浜�0鐨勫簱瀛�
+ .ToListAsync();
+
+ if (remainingStock.Any())
+ {
+ var remainingQty = remainingStock.Sum(x => x.StockQuantity);
+ var barcodes = string.Join(", ", remainingStock.Select(x => x.Barcode).Take(5)); // 鍙樉绀哄墠5涓�
+ return ValidationResult<List<Dt_OutStockLockInfo>>.Error(
+ $"鎵樼洏涓婅繕鏈夊簱瀛樿揣鐗╋紝鏁伴噺{remainingQty}锛屾潯鐮�: {barcodes}锛屼笉鑳藉彇璧扮┖绠�");
+ }
+ }
+
+ // 妫�鏌ユ槸鍚︽湁鏈畬鎴愮殑閿佸畾璁板綍锛堢姸鎬佷负鍑哄簱涓垨鍥炲簱涓級
var unfinishedLocks = lockInfos.Where(x =>
x.Status == (int)OutLockStockStatusEnum.鍑哄簱涓� ||
x.Status == (int)OutLockStockStatusEnum.鍥炲簱涓�).ToList();
@@ -305,15 +428,19 @@
$"鎵樼洏杩樻湁{unfinishedCount}鏉℃湭瀹屾垚璁板綍锛屽墿浣欐暟閲弡unfinishedQty}锛屼笉鑳藉彇璧扮┖绠�");
}
- // 鑾峰彇宸插畬鎴愮殑閿佸畾璁板綍
+ // 鑾峰彇宸插畬鎴愮殑閿佸畾璁板綍锛堢姸鎬佷负鎷ｉ�夊畬鎴愭垨宸插彇璧帮級
var completedLocks = lockInfos.Where(x =>
- x.Status == (int)OutLockStockStatusEnum.鎷ｉ�夊畬鎴�).ToList();
+ x.Status == (int)OutLockStockStatusEnum.鎷ｉ�夊畬鎴� ||
+ x.Status == (int)OutLockStockStatusEnum.宸插彇璧�).ToList();
if (!completedLocks.Any())
return ValidationResult<List<Dt_OutStockLockInfo>>.Error("璇ユ墭鐩樻病鏈夊凡瀹屾垚鎷ｉ�夌殑璁板綍");
+ _logger.LogInformation($"绌烘墭鐩橀獙璇侀�氳繃 - 鎵惧埌 {completedLocks.Count} 鏉″凡瀹屾垚璁板綍");
+
return ValidationResult<List<Dt_OutStockLockInfo>>.Success(completedLocks);
}
+
/// <summary>
/// 娓呯悊宸插畬鎴愮殑閿佸畾璁板綍
@@ -322,35 +449,78 @@
{
foreach (var lockInfo in completedLocks)
{
- // 鏍囪閿佸畾璁板綍涓哄凡鍙栬蛋锛堝彲浠ユ柊澧炵姸鎬佹垨鐩存帴鍒犻櫎锛屾牴鎹笟鍔￠渶姹傦級
- // 杩欓噷鎴戜滑灏嗗叾鐘舵�佹洿鏂颁负"宸插彇璧�"锛屽苟璁板綍鍙栬蛋鏃堕棿
+ // 鏍囪閿佸畾璁板綍涓哄凡鍙栬蛋
lockInfo.Status = (int)OutLockStockStatusEnum.宸插彇璧�;
lockInfo.Operator = App.User.UserName;
await _outStockLockInfoService.Db.Updateable(lockInfo).ExecuteCommandAsync();
- // 鍚屾椂娓呯悊瀵瑰簲鐨勫簱瀛樿褰曠姸鎬�
+ // 娓呯悊瀵瑰簲鐨勫簱瀛樿褰曠姸鎬�
await CleanupStockInfo(lockInfo);
}
}
/// <summary>
- /// 娓呯悊搴撳瓨淇℃伅
+ /// 娓呯悊搴撳瓨淇℃伅 - 澧炲己鐗堟湰
/// </summary>
private async Task CleanupStockInfo(Dt_OutStockLockInfo lockInfo)
{
- var stockDetail = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
- .FirstAsync(x => x.Barcode == lockInfo.CurrentBarcode && x.StockId == lockInfo.StockId);
-
- if (stockDetail != null)
+ try
{
- // 濡傛灉搴撳瓨宸茬粡鍑哄簱瀹屾垚锛屾爣璁颁负宸叉竻鐞�
- if (stockDetail.Status == (int)StockStatusEmun.鍑哄簱瀹屾垚)
+ // 鏌ユ壘閿佸畾鐨勫簱瀛樻槑缁�
+ var stockDetail = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
+ .FirstAsync(x => x.Barcode == lockInfo.CurrentBarcode && x.StockId == lockInfo.StockId);
+
+ if (stockDetail != null)
{
+ // 璁板綍娓呯悊鍓嶇殑鐘舵��
+ decimal originalQty = stockDetail.StockQuantity;
+ int originalStatus = stockDetail.Status;
+
+ // 濡傛灉搴撳瓨鏁伴噺澶т簬0锛岄渶瑕佸厛娓呴浂
+ if (stockDetail.StockQuantity > 0)
+ {
+ _logger.LogWarning($"鍙栬蛋绌烘墭鐩樻椂鍙戠幇鏉＄爜 {lockInfo.CurrentBarcode} 杩樻湁搴撳瓨 {stockDetail.StockQuantity}锛岃嚜鍔ㄦ竻闆�");
+ stockDetail.StockQuantity = 0;
+ stockDetail.OutboundQuantity = 0;
+ }
+
+ // 鏍囪涓哄凡娓呯悊鐘舵��
stockDetail.Status = (int)StockStatusEmun.宸叉竻鐞�;
+
await _stockInfoDetailService.Db.Updateable(stockDetail).ExecuteCommandAsync();
+
+ _logger.LogInformation($"娓呯悊搴撳瓨鏄庣粏 - 鏉＄爜: {stockDetail.Barcode}, 鍘熺姸鎬�: {originalStatus} -> 宸叉竻鐞�, 鍘熸暟閲�: {originalQty} -> 0");
+ }
+ else
+ {
+ _logger.LogWarning($"鏈壘鍒版潯鐮佸搴旂殑搴撳瓨鏄庣粏: {lockInfo.CurrentBarcode}");
+ }
+
+ // 鍚屾椂娓呯悊璇ユ墭鐩樹笂鐨勬墍鏈夊簱瀛橈紙閬垮厤閬楁紡锛�
+ var allStockDetails = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
+ .Where(x => x.StockId == lockInfo.StockId && x.StockQuantity > 0)
+ .ToListAsync();
+
+ if (allStockDetails.Any())
+ {
+ foreach (var stock in allStockDetails)
+ {
+ stock.StockQuantity = 0;
+ stock.OutboundQuantity = 0;
+ stock.Status = (int)StockStatusEmun.宸叉竻鐞�;
+
+ await _stockInfoDetailService.Db.Updateable(stock).ExecuteCommandAsync();
+ _logger.LogWarning($"娓呯悊閬楁紡搴撳瓨 - 鏉＄爜: {stock.Barcode}, 鏁伴噺: {stock.StockQuantity} -> 0");
+ }
}
}
+ catch (Exception ex)
+ {
+ _logger.LogError($"娓呯悊搴撳瓨淇℃伅澶辫触 - 閿佸畾ID: {lockInfo.Id}, 鏉＄爜: {lockInfo.CurrentBarcode}, Error: {ex.Message}");
+ // 涓嶆姏鍑哄紓甯革紝缁х画澶勭悊鍏朵粬璁板綍
+ }
}
+
/// <summary>
/// 鏇存柊璁㈠崟鐘舵��
@@ -401,115 +571,36 @@
#endregion
- #region 杈呭姪鏂规硶
-
- private string GetPalletStatusText(PalletStatusEnum status)
+ private List<SplitResult> CreateSplitResults(Dt_OutStockLockInfo lockInfo, decimal splitQty, decimal remainQty, string newBarcode, string originalBarcode)
{
- return status switch
+ return new List<SplitResult>
+ {
+ new SplitResult
{
- PalletStatusEnum.鏈紑濮� => "鏈紑濮�",
- PalletStatusEnum.鎷ｉ�変腑 => "鎷ｉ�変腑",
- PalletStatusEnum.宸插畬鎴� => "宸插畬鎴�",
- PalletStatusEnum.鏃犱换鍔� => "鏃犱换鍔�",
- _ => "鏈煡"
- };
+ materialCode = lockInfo.MaterielCode,
+ supplierCode = lockInfo.SupplyCode,
+ quantityTotal = splitQty.ToString("F2"),
+ batchNumber = newBarcode,
+ batch = lockInfo.BatchNo,
+ factory = lockInfo.FactoryArea,
+ date = DateTime.Now.ToString("yyyy-MM-dd"),
+ },
+ new SplitResult
+ {
+ materialCode = lockInfo.MaterielCode,
+ supplierCode = lockInfo.SupplyCode,
+ quantityTotal = remainQty.ToString("F2"),
+ batchNumber = originalBarcode,
+ batch = lockInfo.BatchNo,
+ factory = lockInfo.FactoryArea,
+ date = DateTime.Now.ToString("yyyy-MM-dd"),
+ }
+ };
}
- #endregion
- #region 鍒嗘壒鍒嗘嫞
- /// <summary>
- /// 鍒嗘壒鍒嗘嫞纭
- /// </summary>
- public async Task<WebResponseContent> ConfirmBatchPicking(string orderNo, string palletCode, string barcode)
- {
- try
- {
- _unitOfWorkManage.BeginTran();
- // 1. 楠岃瘉鍒嗘嫞璇锋眰
- var validationResult = await ValidatePickingRequest(orderNo, palletCode, barcode);
- if (!validationResult.IsValid)
- return WebResponseContent.Instance.Error(validationResult.ErrorMessage);
-
- var (lockInfo, orderDetail, stockDetail, batch) = validationResult.Data;
-
- // 浣跨敤閿佸畾淇℃伅鐨勫垎閰嶆暟閲忎綔涓哄疄闄呭垎鎷ｆ暟閲�
- var actualPickedQty = lockInfo.AssignQuantity;
-
- // 2. 鎵ц鍒嗘嫞閫昏緫
- var pickingResult = await ExecutePickingLogic(lockInfo, orderDetail, stockDetail, actualPickedQty);
-
- // 3. 鏇存柊鎵规鍜岃鍗曟暟鎹�
- await UpdateBatchAndOrderData(batch, orderDetail, actualPickedQty, orderNo);
-
- // 4. 璁板綍鎷ｉ�夊巻鍙�
- await RecordPickingHistory(pickingResult, orderNo, palletCode);
-
- _unitOfWorkManage.CommitTran();
-
- return WebResponseContent.Instance.OK("鍒嗘嫞鎴愬姛", new
- {
- PickedQuantity = actualPickedQty,
- Barcode = barcode,
- MaterialCode = lockInfo.MaterielCode
- });
- }
- catch (Exception ex)
- {
- _unitOfWorkManage.RollbackTran();
- _logger.LogError($"鍒嗘嫞澶辫触 - OrderNo: {orderNo}, PalletCode: {palletCode}, Barcode: {barcode}, Error: {ex.Message}");
- return WebResponseContent.Instance.Error($"鍒嗘嫞澶辫触锛歿ex.Message}");
- }
- }
- /// <summary>
- /// 鍙栨秷鍒嗘嫞
- /// </summary>
- public async Task<WebResponseContent> CancelPicking(string orderNo, string palletCode, string barcode)
- {
- try
- {
- _unitOfWorkManage.BeginTran();
-
- // 鏌ユ壘鍒嗘嫞璁板綍
- var pickingRecord = await Db.Queryable<Dt_PickingRecord>()
- .Where(x => x.OrderNo == orderNo &&
- x.PalletCode == palletCode &&
- x.Barcode == barcode &&
- !x.IsCancelled)
- .OrderByDescending(x => x.PickTime)
- .FirstAsync();
-
- if (pickingRecord == null)
- return WebResponseContent.Instance.Error("鏈壘鍒板垎鎷ｈ褰�");
-
- // 鎭㈠閿佸畾淇℃伅鍜屽簱瀛�
- await RevertPickingData(pickingRecord);
-
- //鏇存柊鎵规鍜岃鍗曟暟鎹�
- await RevertBatchAndOrderData(pickingRecord);
-
- // 鏍囪鍒嗘嫞璁板綍涓哄凡鍙栨秷
- pickingRecord.IsCancelled = true;
- pickingRecord.CancelTime = DateTime.Now;
- pickingRecord.CancelOperator = App.User.UserName;
- await Db.Updateable(pickingRecord).ExecuteCommandAsync();
-
- _unitOfWorkManage.CommitTran();
-
- return WebResponseContent.Instance.OK("鍙栨秷鍒嗘嫞鎴愬姛");
- }
- catch (Exception ex)
- {
- _unitOfWorkManage.RollbackTran();
- _logger.LogError($"鍙栨秷鍒嗘嫞澶辫触 - OrderNo: {orderNo}, PalletCode: {palletCode}, Error: {ex.Message}");
- return WebResponseContent.Instance.Error($"鍙栨秷鍒嗘嫞澶辫触锛歿ex.Message}");
- }
- }
-
- #endregion
-
- #region 鎵嬪姩鎷嗗寘
+ #region 鎵嬪姩鎷嗗寘
/// <summary>
/// 鎵嬪姩鎷嗗寘
@@ -520,24 +611,19 @@
{
_unitOfWorkManage.BeginTran();
- // 楠岃瘉鎷嗗寘璇锋眰
+ // 楠岃瘉鎷嗗寘璇锋眰
var validationResult = await ValidateSplitRequest(orderNo, palletCode, originalBarcode, splitQuantity);
if (!validationResult.IsValid)
return WebResponseContent.Instance.Error(validationResult.ErrorMessage);
var (lockInfo, stockDetail) = validationResult.Data;
- // . 鎵ц鎷嗗寘閫昏緫
- var splitResult = await ExecuteSplitLogic(lockInfo, stockDetail, splitQuantity, palletCode);
+ // 鎵ц鎷嗗寘閫昏緫
+ var splitResult = await ExecuteManualSplitLogic(lockInfo, stockDetail, splitQuantity, palletCode);
_unitOfWorkManage.CommitTran();
- return WebResponseContent.Instance.OK("鎵嬪姩鎷嗗寘鎴愬姛", new
- {
- NewBarcode = splitResult.NewBarcode,
- OriginalBarcode = originalBarcode,
- SplitQuantity = splitQuantity
- });
+ return WebResponseContent.Instance.OK("鎵嬪姩鎷嗗寘鎴愬姛", splitResult);
}
catch (Exception ex)
{
@@ -547,14 +633,345 @@
}
}
- #endregion
+ /// <summary>
+ /// 楠岃瘉鎷嗗寘璇锋眰 - 澧炲己鍒嗛厤鏁伴噺鎺у埗
+ /// </summary>
+ private async Task<ValidationResult<(Dt_OutStockLockInfo, Dt_StockInfoDetail)>> ValidateSplitRequest(
+ string orderNo, string palletCode, string originalBarcode, decimal splitQuantity)
+ {
+ _logger.LogInformation($"寮�濮嬮獙璇佹媶鍖呰姹� - 璁㈠崟: {orderNo}, 鎵樼洏: {palletCode}, 鍘熸潯鐮�: {originalBarcode}, 鎷嗗寘鏁伴噺: {splitQuantity}");
- #region 鍙栨秷鎷嗗寘
+ // 鏌ユ壘閿佸畾淇℃伅
+ var lockInfo = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
+ .Where(x => x.OrderNo == orderNo &&
+ x.PalletCode == palletCode &&
+ x.CurrentBarcode == originalBarcode &&
+ x.Status == (int)OutLockStockStatusEnum.鍑哄簱涓�)
+ .FirstAsync();
- #region 鍙栨秷鎷嗗寘 - 淇鐗堟湰
+ if (lockInfo == null)
+ {
+ _logger.LogWarning($"鏈壘鍒版湁鏁堢殑閿佸畾淇℃伅 - 璁㈠崟: {orderNo}, 鎵樼洏: {palletCode}, 鏉＄爜: {originalBarcode}");
+ return ValidationResult<(Dt_OutStockLockInfo, Dt_StockInfoDetail)>.Error("鏈壘鍒版湁鏁堢殑閿佸畾淇℃伅");
+ }
+
+ _logger.LogInformation($"鎵惧埌閿佸畾淇℃伅 - 鍒嗛厤鏁伴噺: {lockInfo.AssignQuantity}, 宸叉嫞閫�: {lockInfo.PickedQty}, 璁㈠崟鏁伴噺: {lockInfo.OrderQuantity}");
+
+ // 鑾峰彇璁㈠崟鏄庣粏
+ var orderDetail = await _outboundOrderDetailService.Db.Queryable<Dt_OutboundOrderDetail>()
+ .FirstAsync(x => x.Id == lockInfo.OrderDetailId);
+
+ if (orderDetail == null)
+ {
+ _logger.LogWarning($"鏈壘鍒拌鍗曟槑缁� - OrderDetailId: {lockInfo.OrderDetailId}");
+ return ValidationResult<(Dt_OutStockLockInfo, Dt_StockInfoDetail)>.Error("鏈壘鍒拌鍗曟槑缁�");
+ }
+
+ _logger.LogInformation($"鎵惧埌璁㈠崟鏄庣粏 - 宸插垎閰嶆暟閲�: {orderDetail.AllocatedQuantity}, 閿佸畾鏁伴噺: {orderDetail.LockQuantity}");
+
+ // 鑾峰彇搴撳瓨淇℃伅
+ var stockDetail = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
+ .FirstAsync(x => x.Barcode == originalBarcode && x.StockId == lockInfo.StockId);
+
+ if (stockDetail == null)
+ {
+ _logger.LogWarning($"鏈壘鍒板簱瀛樹俊鎭� - 鏉＄爜: {originalBarcode}, StockId: {lockInfo.StockId}");
+ return ValidationResult<(Dt_OutStockLockInfo, Dt_StockInfoDetail)>.Error("鏈壘鍒板搴旂殑搴撳瓨淇℃伅");
+ }
+
+ _logger.LogInformation($"鎵惧埌搴撳瓨淇℃伅 - 搴撳瓨鏁伴噺: {stockDetail.StockQuantity}, 鍑哄簱鏁伴噺: {stockDetail.OutboundQuantity}");
+
+ // 楠岃瘉鎷嗗寘鏁伴噺涓嶈兘澶т簬搴撳瓨鏁伴噺
+ if (stockDetail.StockQuantity < splitQuantity)
+ {
+ _logger.LogWarning($"鎷嗗寘鏁伴噺澶т簬搴撳瓨鏁伴噺 - 鎷嗗寘鏁伴噺: {splitQuantity}, 搴撳瓨鏁伴噺: {stockDetail.StockQuantity}");
+ return ValidationResult<(Dt_OutStockLockInfo, Dt_StockInfoDetail)>.Error($"鎷嗗寘鏁伴噺涓嶈兘澶т簬搴撳瓨鏁伴噺锛屽綋鍓嶅簱瀛橈細{stockDetail.StockQuantity}");
+ }
+
+ // 楠岃瘉鎷嗗寘鏁伴噺涓嶈兘澶т簬閿佸畾淇℃伅鐨勫垎閰嶆暟閲�
+ if (lockInfo.AssignQuantity < splitQuantity)
+ {
+ _logger.LogWarning($"鎷嗗寘鏁伴噺澶т簬鍒嗛厤鏁伴噺 - 鎷嗗寘鏁伴噺: {splitQuantity}, 鍒嗛厤鏁伴噺: {lockInfo.AssignQuantity}");
+ return ValidationResult<(Dt_OutStockLockInfo, Dt_StockInfoDetail)>.Error($"鎷嗗寘鏁伴噺涓嶈兘澶т簬鍒嗛厤鏁伴噺锛屽綋鍓嶅垎閰嶆暟閲忥細{lockInfo.AssignQuantity}");
+ }
+
+ // 楠岃瘉鎷嗗寘鏁伴噺涓嶈兘澶т簬閿佸畾淇℃伅鐨勬湭鎷ｉ�夋暟閲�
+ decimal remainingToPick = lockInfo.AssignQuantity - lockInfo.PickedQty;
+ if (remainingToPick < splitQuantity)
+ {
+ _logger.LogWarning($"鎷嗗寘鏁伴噺澶т簬鏈嫞閫夋暟閲� - 鎷嗗寘鏁伴噺: {splitQuantity}, 鏈嫞閫夋暟閲�: {remainingToPick}");
+ return ValidationResult<(Dt_OutStockLockInfo, Dt_StockInfoDetail)>.Error($"鎷嗗寘鏁伴噺涓嶈兘澶т簬鏈嫞閫夋暟閲忥紝褰撳墠鏈嫞閫夛細{remainingToPick}");
+ }
+
+ // 楠岃瘉鎷嗗寘鍚庡師閿佸畾淇℃伅鐨勫垎閰嶆暟閲忎笉浼氫负璐熸暟
+ if (lockInfo.AssignQuantity - splitQuantity < 0)
+ {
+ _logger.LogWarning($"鎷嗗寘鍚庡垎閰嶆暟閲忎负璐熸暟 - 褰撳墠鍒嗛厤鏁伴噺: {lockInfo.AssignQuantity}, 鎷嗗寘鏁伴噺: {splitQuantity}");
+ return ValidationResult<(Dt_OutStockLockInfo, Dt_StockInfoDetail)>.Error($"鎷嗗寘鍚庡垎閰嶆暟閲忎笉鑳戒负璐熸暟");
+ }
+
+ // 楠岃瘉璁㈠崟鏄庣粏鐨勫垎閰嶆暟閲忔槸鍚﹁冻澶�
+ // 娉ㄦ剰锛氭墜鍔ㄦ媶鍖呬笉浼氭敼鍙樿鍗曟槑缁嗙殑鍒嗛厤鏁伴噺锛屽洜涓烘�诲垎閰嶆暟閲忎笉鍙�
+ // 鍙槸浠庝竴涓攣瀹氫俊鎭浆绉诲埌鍙︿竴涓攣瀹氫俊鎭�
+ decimal totalLockAssignQuantity = await GetTotalLockAssignQuantity(orderDetail.Id);
+ if (orderDetail.AllocatedQuantity != totalLockAssignQuantity)
+ {
+ _logger.LogWarning($"璁㈠崟鏄庣粏鍒嗛厤鏁伴噺涓庨攣瀹氫俊鎭笉涓�鑷� - 璁㈠崟鏄庣粏鍒嗛厤鏁伴噺: {orderDetail.AllocatedQuantity}, 閿佸畾淇℃伅鎬诲垎閰嶆暟閲�: {totalLockAssignQuantity}");
+ // 杩欓噷涓嶇洿鎺ヨ繑鍥為敊璇紝鍥犱负鎷嗗寘鎿嶄綔鏈韩涓嶄細瀵艰嚧涓嶄竴鑷达紝鍙槸璁板綍璀﹀憡
+ }
+
+ _logger.LogInformation($"鎷嗗寘楠岃瘉閫氳繃 - 鍘熸潯鐮�: {originalBarcode}, 鎷嗗寘鏁伴噺: {splitQuantity}");
+
+ return ValidationResult<(Dt_OutStockLockInfo, Dt_StockInfoDetail)>.Success((lockInfo, stockDetail));
+ }
/// <summary>
- /// 鍙栨秷鎷嗗寘 - 鏀寔澶氭鎷嗗寘鐨勬儏鍐�
+ /// 鑾峰彇璁㈠崟鏄庣粏鐨勬墍鏈夐攣瀹氫俊鎭殑鎬诲垎閰嶆暟閲�
+ /// </summary>
+ private async Task<decimal> GetTotalLockAssignQuantity(long orderDetailId)
+ {
+ var lockInfos = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
+ .Where(x => x.OrderDetailId == orderDetailId)
+ .ToListAsync();
+
+ return lockInfos.Sum(x => x.AssignQuantity);
+ }
+
+ /// <summary>
+ /// 鎵ц鎵嬪姩鎷嗗寘閫昏緫 - 瀹屾暣鐗堟湰
+ /// </summary>
+ private async Task<List<SplitResult>> ExecuteManualSplitLogic(Dt_OutStockLockInfo lockInfo, Dt_StockInfoDetail stockDetail,
+ decimal splitQuantity, string palletCode)
+ {
+ _logger.LogInformation($"寮�濮嬫墽琛屾墜鍔ㄦ媶鍖呴�昏緫 - 鍘熸潯鐮�: {stockDetail.Barcode}, 鎷嗗寘鏁伴噺: {splitQuantity}");
+
+ try
+ {
+ // 楠岃瘉搴撳瓨鏁伴噺鏄惁瓒冲
+ decimal availableStock = stockDetail.StockQuantity;
+ if (availableStock < splitQuantity)
+ {
+ throw new InvalidOperationException($"搴撳瓨涓嶈冻锛屽綋鍓嶅簱瀛�: {availableStock}, 闇�瑕佹媶鍖�: {splitQuantity}");
+ }
+
+ // 楠岃瘉鎷嗗寘鏁伴噺涓嶈兘绛変簬鎴栧ぇ浜庡師閿佸畾淇℃伅鍒嗛厤鏁伴噺
+ if (splitQuantity >= lockInfo.AssignQuantity)
+ {
+ throw new InvalidOperationException($"鎷嗗寘鏁伴噺涓嶈兘绛変簬鎴栧ぇ浜庡師閿佸畾淇℃伅鍒嗛厤鏁伴噺锛屾媶鍖呮暟閲�: {splitQuantity}, 鍘熷垎閰嶆暟閲�: {lockInfo.AssignQuantity}");
+ }
+
+ // 璁＄畻鍓╀綑鏁伴噺
+ decimal remainQty = lockInfo.AssignQuantity - splitQuantity;
+
+ // 楠岃瘉鍓╀綑鏁伴噺鏄惁鍚堢悊
+ if (remainQty <= 0)
+ {
+ throw new InvalidOperationException($"鎷嗗寘鍚庡墿浣欐暟閲忓繀椤诲ぇ浜�0锛屽綋鍓嶅墿浣�: {remainQty}");
+ }
+
+ _logger.LogInformation($"鎷嗗寘璁＄畻 - 鍘熷垎閰嶆暟閲�: {lockInfo.AssignQuantity}, 鎷嗗寘鏁伴噺: {splitQuantity}, 鍓╀綑鏁伴噺: {remainQty}");
+ _logger.LogInformation($"鍘熷簱瀛樹俊鎭� - 搴撳瓨鏁伴噺: {stockDetail.StockQuantity}, 鍑哄簱鏁伴噺: {stockDetail.OutboundQuantity}");
+
+ // 鐢熸垚鏂版潯鐮�
+ string newBarcode = await GenerateNewBarcode();
+ _logger.LogInformation($"鐢熸垚鏂版潯鐮�: {newBarcode}");
+
+ // 璁板綍鎷嗗寘鍓嶇殑鍏抽敭鏁版嵁
+ decimal originalLockAssignQty = lockInfo.AssignQuantity;
+ decimal originalLockOrderQty = lockInfo.OrderQuantity;
+ decimal originalStockQty = stockDetail.StockQuantity;
+ decimal originalOutboundQty = stockDetail.OutboundQuantity;
+
+ // 鍒涘缓鏂板簱瀛樻槑缁�
+ var newStockDetail = new Dt_StockInfoDetail
+ {
+ StockId = stockDetail.StockId,
+ MaterielCode = stockDetail.MaterielCode,
+ OrderNo = stockDetail.OrderNo,
+ BatchNo = stockDetail.BatchNo,
+ StockQuantity = splitQuantity,
+ OutboundQuantity = 0,
+ Barcode = newBarcode,
+ Status = (int)StockStatusEmun.鍑哄簱閿佸畾,
+ SupplyCode = stockDetail.SupplyCode,
+ Unit = stockDetail.Unit,
+ BarcodeQty = stockDetail.BarcodeQty,
+ BarcodeUnit = stockDetail.BarcodeUnit,
+ BusinessType = stockDetail.BusinessType,
+ InboundOrderRowNo = stockDetail.InboundOrderRowNo,
+ };
+
+ await _stockInfoDetailService.Db.Insertable(newStockDetail).ExecuteCommandAsync();
+ _logger.LogInformation($"鍒涘缓鏂板簱瀛樻槑缁嗘垚鍔� - 鏉＄爜: {newBarcode}, 搴撳瓨鏁伴噺: {splitQuantity}");
+
+ // 淇锛氭洿鏂板師搴撳瓨鏄庣粏 - 纭繚鏁版嵁涓�鑷存��
+ // 鍘熷簱瀛樺噺灏戞媶鍖呮暟閲忥紝浣嗗嚭搴撴暟閲忎繚鎸佷笉鍙橈紙鍥犱负鏄墜鍔ㄦ媶鍖咃紝涓嶆秹鍙婂疄闄呭嚭搴擄級
+ stockDetail.StockQuantity -= splitQuantity;
+
+ // 纭繚涓嶄細涓鸿礋鏁�
+ if (stockDetail.StockQuantity < 0)
+ {
+ _logger.LogWarning($"鍘熷簱瀛樻暟閲忓嚭鐜拌礋鏁帮紝閲嶇疆涓�0");
+ stockDetail.StockQuantity = 0;
+ }
+
+ // 鍑哄簱鏁伴噺淇濇寔涓嶅彉
+ // stockDetail.OutboundQuantity = stockDetail.OutboundQuantity; // 淇濇寔涓嶅彉
+
+ await _stockInfoDetailService.Db.Updateable(stockDetail).ExecuteCommandAsync();
+ _logger.LogInformation($"鏇存柊鍘熷簱瀛樻槑缁� - 鏉＄爜: {stockDetail.Barcode}, " +
+ $"搴撳瓨鏁伴噺: {originalStockQty} -> {stockDetail.StockQuantity}, " +
+ $"鍑哄簱鏁伴噺: {originalOutboundQty} -> {stockDetail.OutboundQuantity}");
+
+ // 鍒涘缓鏂伴攣瀹氫俊鎭�
+ var newLockInfo = new Dt_OutStockLockInfo
+ {
+ OrderNo = lockInfo.OrderNo,
+ OrderDetailId = lockInfo.OrderDetailId, // 缁戝畾鍒板悓涓�涓鍗曟槑缁�
+ OutboundBatchNo = lockInfo.OutboundBatchNo,
+ MaterielCode = lockInfo.MaterielCode,
+ MaterielName = lockInfo.MaterielName,
+ StockId = lockInfo.StockId,
+ OrderQuantity = splitQuantity,
+ AssignQuantity = splitQuantity,
+ PickedQty = 0,
+ LocationCode = lockInfo.LocationCode,
+ PalletCode = lockInfo.PalletCode,
+ TaskNum = lockInfo.TaskNum,
+ Status = (int)OutLockStockStatusEnum.鍑哄簱涓�,
+ Unit = lockInfo.Unit,
+ SupplyCode = lockInfo.SupplyCode,
+ OrderType = lockInfo.OrderType,
+ CurrentBarcode = newBarcode,
+ IsSplitted = 1,
+ ParentLockId = lockInfo.Id,
+ Operator = App.User.UserName,
+ FactoryArea = lockInfo.FactoryArea,
+ lineNo = lockInfo.lineNo,
+ WarehouseCode = lockInfo.WarehouseCode,
+ BarcodeQty = lockInfo.BarcodeQty,
+ BarcodeUnit = lockInfo.BarcodeUnit,
+ };
+
+ await _outStockLockInfoService.Db.Insertable(newLockInfo).ExecuteCommandAsync();
+ _logger.LogInformation($"鍒涘缓鏂伴攣瀹氫俊鎭垚鍔� - 鏉＄爜: {newBarcode}, 鍒嗛厤鏁伴噺: {splitQuantity}");
+
+ // 鏇存柊鍘熼攣瀹氫俊鎭�
+ lockInfo.AssignQuantity = remainQty;
+ lockInfo.OrderQuantity = remainQty;
+
+ await _outStockLockInfoService.Db.Updateable(lockInfo).ExecuteCommandAsync();
+ _logger.LogInformation($"鏇存柊鍘熼攣瀹氫俊鎭� - 鍒嗛厤鏁伴噺: {originalLockAssignQty} -> {lockInfo.AssignQuantity}, " +
+ $"璁㈠崟鏁伴噺: {originalLockOrderQty} -> {lockInfo.OrderQuantity}");
+
+ // 閲嶈锛氭墜鍔ㄦ媶鍖呬笉鏀瑰彉璁㈠崟鏄庣粏鐨勬�诲垎閰嶆暟閲�
+ // 楠岃瘉璁㈠崟鏄庣粏鐨勬�诲垎閰嶆暟閲忔槸鍚︿繚鎸佷笉鍙�
+ await ValidateOrderDetailAllocationAfterSplit(lockInfo.OrderDetailId, originalLockAssignQty);
+
+ // 璁板綍鎷嗗寘鍘嗗彶
+ await RecordSplitHistory(lockInfo, stockDetail, splitQuantity, newBarcode, false, originalStockQty);
+
+ // 鍒涘缓鎷嗗寘缁撴灉鍒楄〃
+ var splitResults = CreateSplitResults(lockInfo, splitQuantity, remainQty, newBarcode, stockDetail.Barcode);
+
+ // 楠岃瘉鎷嗗寘鍚庢暟鎹竴鑷存��
+ await ValidateDataConsistencyAfterSplit(lockInfo.OrderDetailId, originalLockAssignQty, originalLockOrderQty);
+
+ _logger.LogInformation($"鎵嬪姩鎷嗗寘閫昏緫鎵ц瀹屾垚 - 鍘熸潯鐮�: {stockDetail.Barcode}, 鏂版潯鐮�: {newBarcode}, 鎷嗗寘鏁伴噺: {splitQuantity}");
+
+ return splitResults;
+ }
+ catch (Exception ex)
+ {
+ _logger.LogError($"鎵嬪姩鎷嗗寘閫昏緫鎵ц澶辫触 - 鍘熸潯鐮�: {stockDetail.Barcode}, 鎷嗗寘鏁伴噺: {splitQuantity}, Error: {ex.Message}");
+ throw;
+ }
+ }
+ /// <summary>
+ /// 楠岃瘉鎷嗗寘鍚庤鍗曟槑缁嗙殑鍒嗛厤鏁伴噺鏄惁淇濇寔涓嶅彉
+ /// </summary>
+ private async Task ValidateOrderDetailAllocationAfterSplit(long orderDetailId, decimal originalTotalAssignQty)
+ {
+ try
+ {
+ // 鑾峰彇璁㈠崟鏄庣粏鐨勬墍鏈夐攣瀹氫俊鎭殑鎬诲垎閰嶆暟閲�
+ var allLocks = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
+ .Where(x => x.OrderDetailId == orderDetailId)
+ .ToListAsync();
+
+ decimal totalLockAssignQty = allLocks.Sum(x => x.AssignQuantity);
+
+ _logger.LogInformation($"鎷嗗寘鍚庡垎閰嶆暟閲忛獙璇� - 璁㈠崟鏄庣粏ID: {orderDetailId}");
+ _logger.LogInformation($"鍘熷鎬诲垎閰嶆暟閲�: {originalTotalAssignQty}, 褰撳墠鎬诲垎閰嶆暟閲�: {totalLockAssignQty}");
+
+ // 鎵嬪姩鎷嗗寘鍚庢�诲垎閰嶆暟閲忓簲璇ヤ繚鎸佷笉鍙�
+ if (Math.Abs(originalTotalAssignQty - totalLockAssignQty) > 0.01m)
+ {
+ _logger.LogWarning($"鎷嗗寘鍚庢�诲垎閰嶆暟閲忓彂鐢熷彉鍖� - 鏈熸湜: {originalTotalAssignQty}, 瀹為檯: {totalLockAssignQty}");
+
+ // 濡傛灉鍙樺寲寰堝皬锛屽彲鑳芥槸绮惧害闂锛岃褰曚絾涓嶆姏鍑哄紓甯�
+ if (Math.Abs(originalTotalAssignQty - totalLockAssignQty) > 1.0m)
+ {
+ throw new InvalidOperationException($"鎷嗗寘鍚庢�诲垎閰嶆暟閲忓紓甯稿彉鍖栵紝鏈熸湜: {originalTotalAssignQty}, 瀹為檯: {totalLockAssignQty}");
+ }
+ }
+ else
+ {
+ _logger.LogInformation($"鎷嗗寘鍚庡垎閰嶆暟閲忛獙璇侀�氳繃 - 鎬诲垎閰嶆暟閲忎繚鎸佷笉鍙�");
+ }
+ }
+ catch (Exception ex)
+ {
+ _logger.LogError($"楠岃瘉鎷嗗寘鍚庡垎閰嶆暟閲忓け璐� - OrderDetailId: {orderDetailId}, Error: {ex.Message}");
+ throw;
+ }
+ }
+ /// <summary>
+ /// 楠岃瘉鎷嗗寘鍚庢暟鎹竴鑷存��
+ /// </summary>
+ private async Task ValidateDataConsistencyAfterSplit(long orderDetailId, decimal expectedAllocatedQty, decimal expectedLockQty)
+ {
+ // 閲嶆柊鑾峰彇璁㈠崟鏄庣粏鏁版嵁
+ var orderDetail = await _outboundOrderDetailService.Db.Queryable<Dt_OutboundOrderDetail>()
+ .FirstAsync(x => x.Id == orderDetailId);
+
+ if (orderDetail == null)
+ return;
+
+ // 璁＄畻鎵�鏈夐攣瀹氫俊鎭殑鎬诲垎閰嶆暟閲�
+ var allLocks = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
+ .Where(x => x.OrderDetailId == orderDetailId)
+ .ToListAsync();
+
+ decimal totalLockAssignQty = allLocks.Sum(x => x.AssignQuantity);
+
+ _logger.LogInformation($"鏁版嵁涓�鑷存�ч獙璇� - 璁㈠崟鏄庣粏鍒嗛厤鏁伴噺: {orderDetail.AllocatedQuantity}, 閿佸畾淇℃伅鎬诲垎閰嶆暟閲�: {totalLockAssignQty}");
+
+ // 濡傛灉鏁版嵁涓嶄竴鑷达紝璁板綍璀﹀憡
+ if (Math.Abs(orderDetail.AllocatedQuantity - totalLockAssignQty) > 0.01m)
+ {
+ _logger.LogWarning($"鏁版嵁涓嶄竴鑷� - 璁㈠崟鏄庣粏鍒嗛厤鏁伴噺: {orderDetail.AllocatedQuantity}, 閿佸畾淇℃伅鎬诲垎閰嶆暟閲�: {totalLockAssignQty}");
+ }
+
+ // 楠岃瘉鍒嗛厤鏁伴噺娌℃湁寮傚父鍙樺寲
+ if (Math.Abs(orderDetail.AllocatedQuantity - expectedAllocatedQty) > 0.01m)
+ {
+ _logger.LogWarning($"鍒嗛厤鏁伴噺寮傚父鍙樺寲 - 鏈熸湜: {expectedAllocatedQty}, 瀹為檯: {orderDetail.AllocatedQuantity}");
+ }
+
+ if (Math.Abs(orderDetail.LockQuantity - expectedLockQty) > 0.01m)
+ {
+ _logger.LogWarning($"閿佸畾鏁伴噺寮傚父鍙樺寲 - 鏈熸湜: {expectedLockQty}, 瀹為檯: {orderDetail.LockQuantity}");
+ }
+ }
+ #endregion
+
+
+
+ #region 鍙栨秷鎷嗗寘
+
+ /// <summary>
+ /// 鍙栨秷鎷嗗寘
/// </summary>
public async Task<WebResponseContent> CancelSplitPackage(string orderNo, string palletCode, string newBarcode)
{
@@ -599,66 +1016,257 @@
}
/// <summary>
- /// 鎵ц鍙栨秷鎷嗗寘閫昏緫 - 淇鐗堟湰
+ /// 鎵ц鍙栨秷鎷嗗寘閫昏緫
/// </summary>
private async Task ExecuteCancelSplitLogic(Dt_SplitPackageRecord splitRecord,
Dt_OutStockLockInfo originalLockInfo, Dt_OutStockLockInfo newLockInfo,
Dt_StockInfoDetail newStockDetail)
{
- // 1. 鎭㈠鍘熼攣瀹氫俊鎭�
- // 娉ㄦ剰锛氳繖閲岄渶瑕佺疮鍔狅紝鑰屼笉鏄畝鍗曠殑璧嬪�硷紝鍥犱负鍙兘鏈夊娆℃媶鍖�
+ _logger.LogInformation($"寮�濮嬫墽琛屽彇娑堟媶鍖呴�昏緫 - 鍘熸潯鐮�: {splitRecord.OriginalBarcode}, 鏂版潯鐮�: {splitRecord.NewBarcode}, 鎷嗗寘鏁伴噺: {splitRecord.SplitQty}");
+
+ try
+ {
+ // 鏍规嵁鎷嗗寘绫诲瀷璋冪敤涓嶅悓鐨勫鐞嗘柟娉�
+ if (splitRecord.IsAutoSplit)
+ {
+ await HandleAutoSplitCancel(splitRecord, originalLockInfo, newLockInfo, newStockDetail);
+ }
+ else
+ {
+ await HandleManualSplitCancel(splitRecord, originalLockInfo, newLockInfo, newStockDetail);
+ }
+
+ // 楠岃瘉鍙栨秷鎷嗗寘鍚庢暟鎹竴鑷存��
+ await ValidateDataConsistencyAfterCancelSplit(originalLockInfo.OrderDetailId,
+ originalLockInfo.AssignQuantity, originalLockInfo.OrderQuantity,
+ splitRecord.IsAutoSplit, splitRecord.SplitQty);
+
+ // 妫�鏌ュ苟鏇存柊鎵规鍜岃鍗曠姸鎬�
+ await CheckAndUpdateBatchStatus(originalLockInfo.BatchNo);
+ await CheckAndUpdateOrderStatus(originalLockInfo.OrderNo);
+
+ _logger.LogInformation($"鍙栨秷鎷嗗寘閫昏緫鎵ц瀹屾垚");
+ }
+ catch (Exception ex)
+ {
+ _logger.LogError($"鍙栨秷鎷嗗寘閫昏緫鎵ц澶辫触: {ex.Message}");
+ throw;
+ }
+ }
+
+ /// <summary>
+ /// 澶勭悊鑷姩鎷嗗寘鍙栨秷
+ /// </summary>
+ private async Task HandleAutoSplitCancel(Dt_SplitPackageRecord splitRecord,
+ Dt_OutStockLockInfo originalLockInfo, Dt_OutStockLockInfo newLockInfo,
+ Dt_StockInfoDetail newStockDetail)
+ {
+ _logger.LogInformation($"澶勭悊鑷姩鎷嗗寘鍙栨秷 - 鍘熸潯鐮�: {splitRecord.OriginalBarcode}, 鏂版潯鐮�: {splitRecord.NewBarcode}");
+
+ // 鑾峰彇璁㈠崟鏄庣粏
+ var orderDetail = await _outboundOrderDetailService.Db.Queryable<Dt_OutboundOrderDetail>()
+ .FirstAsync(x => x.Id == originalLockInfo.OrderDetailId);
+
+ if (orderDetail == null)
+ throw new InvalidOperationException("鏈壘鍒拌鍗曟槑缁�");
+
+ // 1. 鎭㈠璁㈠崟鏄庣粏鐨勫垎閰嶆暟閲忥紙鑷姩鎷嗗寘浼氬鍔犲垎閰嶆暟閲忥級
+ decimal originalAllocatedQty = orderDetail.AllocatedQuantity;
+ decimal originalLockQty = orderDetail.LockQuantity;
+
+ orderDetail.AllocatedQuantity -= splitRecord.SplitQty;
+ orderDetail.LockQuantity -= splitRecord.SplitQty;
+
+ // 杈圭晫妫�鏌�
+ if (orderDetail.AllocatedQuantity < 0) orderDetail.AllocatedQuantity = 0;
+ if (orderDetail.LockQuantity < 0) orderDetail.LockQuantity = 0;
+
+ await _outboundOrderDetailService.Db.Updateable(orderDetail).ExecuteCommandAsync();
+ _logger.LogInformation($"鑷姩鎷嗗寘鍙栨秷鎭㈠璁㈠崟鏄庣粏 - 鍒嗛厤鏁伴噺: {originalAllocatedQty} -> {orderDetail.AllocatedQuantity}");
+
+ // 2. 鎭㈠鍘熷簱瀛橈紙灏嗘媶鍖呯殑鏁伴噺鍔犲洖鍘熷簱瀛橈級
+ var originalStock = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
+ .FirstAsync(x => x.Barcode == splitRecord.OriginalBarcode && x.StockId == splitRecord.StockId);
+
+ if (originalStock != null)
+ {
+ decimal originalStockQty = originalStock.StockQuantity;
+ originalStock.StockQuantity += splitRecord.SplitQty;
+
+ // 濡傛灉鍘熷簱瀛樼姸鎬佹槸鍑哄簱瀹屾垚锛屾仮澶嶄负鍑哄簱閿佸畾
+ if (originalStock.Status == (int)StockStatusEmun.鍑哄簱瀹屾垚)
+ {
+ originalStock.Status = (int)StockStatusEmun.鍑哄簱閿佸畾;
+ }
+
+ await _stockInfoDetailService.Db.Updateable(originalStock).ExecuteCommandAsync();
+ _logger.LogInformation($"鑷姩鎷嗗寘鍙栨秷鎭㈠鍘熷簱瀛� - 鏉＄爜: {originalStock.Barcode}, 鏁伴噺: {originalStockQty} -> {originalStock.StockQuantity}");
+ }
+
+ // 3. 鍒犻櫎鏂伴攣瀹氫俊鎭拰搴撳瓨鏄庣粏
+ await DeleteNewSplitRecords(newLockInfo, newStockDetail);
+ }
+
+ /// <summary>
+ /// 澶勭悊鎵嬪姩鎷嗗寘鍙栨秷
+ /// </summary>
+ private async Task HandleManualSplitCancel(Dt_SplitPackageRecord splitRecord,
+ Dt_OutStockLockInfo originalLockInfo, Dt_OutStockLockInfo newLockInfo,
+ Dt_StockInfoDetail newStockDetail)
+ {
+ _logger.LogInformation($"澶勭悊鎵嬪姩鎷嗗寘鍙栨秷 - 鍘熸潯鐮�: {splitRecord.OriginalBarcode}, 鏂版潯鐮�: {splitRecord.NewBarcode}");
+
+ // 1. 鎭㈠鍘熼攣瀹氫俊鎭殑鍒嗛厤鏁伴噺
+ decimal originalAssignQty = originalLockInfo.AssignQuantity;
+ decimal originalOrderQty = originalLockInfo.OrderQuantity;
+
originalLockInfo.AssignQuantity += splitRecord.SplitQty;
originalLockInfo.OrderQuantity += splitRecord.SplitQty;
- // 濡傛灉鍘熼攣瀹氫俊鎭殑鐘舵�佹槸鎷ｉ�夊畬鎴愶紝闇�瑕侀噸鏂拌缃负鍑哄簱涓�
+ // 鎭㈠鐘舵��
if (originalLockInfo.Status == (int)OutLockStockStatusEnum.鎷ｉ�夊畬鎴�)
{
originalLockInfo.Status = (int)OutLockStockStatusEnum.鍑哄簱涓�;
}
await _outStockLockInfoService.Db.Updateable(originalLockInfo).ExecuteCommandAsync();
+ _logger.LogInformation($"鎵嬪姩鎷嗗寘鍙栨秷鎭㈠鍘熼攣瀹氫俊鎭� - 鍒嗛厤鏁伴噺: {originalAssignQty} -> {originalLockInfo.AssignQuantity}");
// 2. 鎭㈠鍘熷簱瀛樻槑缁�
var originalStock = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
.FirstAsync(x => x.Barcode == splitRecord.OriginalBarcode && x.StockId == splitRecord.StockId);
- originalStock.StockQuantity += splitRecord.SplitQty;
-
- // 濡傛灉鍘熷簱瀛樼姸鎬佹槸鍑哄簱瀹屾垚锛岄渶瑕侀噸鏂拌缃负鍑哄簱閿佸畾
- if (originalStock.Status == (int)StockStatusEmun.鍑哄簱瀹屾垚)
+ if (originalStock != null)
{
- originalStock.Status = (int)StockStatusEmun.鍑哄簱閿佸畾;
+ decimal originalStockQty = originalStock.StockQuantity;
+ originalStock.StockQuantity += splitRecord.SplitQty;
+
+ // 鎭㈠搴撳瓨鐘舵��
+ if (originalStock.Status == (int)StockStatusEmun.鍑哄簱瀹屾垚)
+ {
+ originalStock.Status = (int)StockStatusEmun.鍑哄簱閿佸畾;
+ }
+
+ await _stockInfoDetailService.Db.Updateable(originalStock).ExecuteCommandAsync();
+ _logger.LogInformation($"鎵嬪姩鎷嗗寘鍙栨秷鎭㈠鍘熷簱瀛� - 鏉＄爜: {originalStock.Barcode}, 鏁伴噺: {originalStockQty} -> {originalStock.StockQuantity}");
}
- await _stockInfoDetailService.Db.Updateable(originalStock).ExecuteCommandAsync();
-
- // 3. 鍒犻櫎鏂伴攣瀹氫俊鎭�
- await _outStockLockInfoService.Db.Deleteable<Dt_OutStockLockInfo>()
- .Where(x => x.Id == newLockInfo.Id)
- .ExecuteCommandAsync();
-
- // 4. 鍒犻櫎鏂板簱瀛樻槑缁�
- await _stockInfoDetailService.Db.Deleteable<Dt_StockInfoDetail>()
- .Where(x => x.Barcode == newLockInfo.CurrentBarcode)
- .ExecuteCommandAsync();
-
- // 5. 鏍囪鎷嗗寘璁板綍涓哄凡鎾ら攢
- splitRecord.IsReverted = true;
- splitRecord.RevertTime = DateTime.Now;
- splitRecord.RevertOperator = App.User.UserName;
- await _splitPackageService.Db.Updateable(splitRecord).ExecuteCommandAsync();
-
- // 6. 妫�鏌ュ苟鏇存柊鎵规鍜岃鍗曠姸鎬�
- await CheckAndUpdateBatchStatus(originalLockInfo.BatchNo);
- await CheckAndUpdateOrderStatus(originalLockInfo.OrderNo);
+ // 3. 鍒犻櫎鏂伴攣瀹氫俊鎭拰搴撳瓨鏄庣粏
+ await DeleteNewSplitRecords(newLockInfo, newStockDetail);
}
/// <summary>
- /// 楠岃瘉鍙栨秷鎷嗗寘璇锋眰 - 澧炲己鐗堟湰
+ /// 鍒犻櫎鏂版媶鍖呰褰曠浉鍏崇殑鏁版嵁
+ /// </summary>
+ private async Task DeleteNewSplitRecords(Dt_OutStockLockInfo newLockInfo, Dt_StockInfoDetail newStockDetail)
+ {
+ // 鍒犻櫎鏂伴攣瀹氫俊鎭�
+ if (newLockInfo != null)
+ {
+ _logger.LogInformation($"鍒犻櫎鏂伴攣瀹氫俊鎭� - 鏉＄爜: {newLockInfo.CurrentBarcode}, 鍒嗛厤鏁伴噺: {newLockInfo.AssignQuantity}");
+ await _outStockLockInfoService.Db.Deleteable<Dt_OutStockLockInfo>()
+ .Where(x => x.Id == newLockInfo.Id)
+ .ExecuteCommandAsync();
+ }
+
+ // 鍒犻櫎鏂板簱瀛樻槑缁�
+ if (newStockDetail != null)
+ {
+ _logger.LogInformation($"鍒犻櫎鏂板簱瀛樻槑缁� - 鏉＄爜: {newStockDetail.Barcode}, 搴撳瓨鏁伴噺: {newStockDetail.StockQuantity}");
+ await _stockInfoDetailService.Db.Deleteable<Dt_StockInfoDetail>()
+ .Where(x => x.Barcode == newStockDetail.Barcode)
+ .ExecuteCommandAsync();
+ }
+ }
+ /// <summary>
+ /// 楠岃瘉鍙栨秷鎷嗗寘鍚庢暟鎹竴鑷存�� - 鏈�鏂扮増鏈�
+ /// </summary>
+ private async Task ValidateDataConsistencyAfterCancelSplit(long orderDetailId, decimal originalAllocatedQty, decimal originalLockQty, bool isAutoSplit, decimal splitQuantity)
+ {
+ // 閲嶆柊鑾峰彇璁㈠崟鏄庣粏鏁版嵁
+ var orderDetail = await _outboundOrderDetailService.Db.Queryable<Dt_OutboundOrderDetail>()
+ .FirstAsync(x => x.Id == orderDetailId);
+
+ if (orderDetail == null)
+ return;
+
+ // 璁＄畻鎵�鏈夐攣瀹氫俊鎭殑鎬诲垎閰嶆暟閲�
+ var allLocks = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
+ .Where(x => x.OrderDetailId == orderDetailId)
+ .ToListAsync();
+
+ decimal totalLockAssignQty = allLocks.Sum(x => x.AssignQuantity);
+
+ _logger.LogInformation($"鍙栨秷鎷嗗寘鍚庢暟鎹竴鑷存�ч獙璇� - 璁㈠崟鏄庣粏鍒嗛厤鏁伴噺: {orderDetail.AllocatedQuantity}, 閿佸畾淇℃伅鎬诲垎閰嶆暟閲�: {totalLockAssignQty}");
+
+ // 鏍规嵁鎷嗗寘绫诲瀷璁＄畻鏈熸湜鍊�
+ decimal expectedAllocatedQty;
+ decimal expectedLockQty;
+
+ if (isAutoSplit)
+ {
+ // 鑷姩鎷嗗寘鍙栨秷锛氬垎閰嶆暟閲忓簲璇ュ噺灏戞媶鍖呮暟閲�
+ expectedAllocatedQty = originalAllocatedQty - splitQuantity;
+ expectedLockQty = originalLockQty - splitQuantity;
+
+ _logger.LogInformation($"鍙栨秷鑷姩鎷嗗寘鏈熸湜鍊� - 鍒嗛厤鏁伴噺: {expectedAllocatedQty}, 閿佸畾鏁伴噺: {expectedLockQty}");
+ }
+ else
+ {
+ // 鎵嬪姩鎷嗗寘鍙栨秷锛氬垎閰嶆暟閲忓簲璇ヤ繚鎸佷笉鍙�
+ expectedAllocatedQty = originalAllocatedQty;
+ expectedLockQty = originalLockQty;
+
+ _logger.LogInformation($"鍙栨秷鎵嬪姩鎷嗗寘鏈熸湜鍊� - 鍒嗛厤鏁伴噺: {expectedAllocatedQty}, 閿佸畾鏁伴噺: {expectedLockQty}");
+ }
+
+ // 杈圭晫妫�鏌ワ細纭繚鏈熸湜鍊间笉涓鸿礋鏁�
+ if (expectedAllocatedQty < 0)
+ {
+ _logger.LogWarning($"鏈熸湜鍒嗛厤鏁伴噺涓鸿礋鏁帮紝閲嶇疆涓�0銆傝绠楀��: {expectedAllocatedQty}");
+ expectedAllocatedQty = 0;
+ }
+
+ if (expectedLockQty < 0)
+ {
+ _logger.LogWarning($"鏈熸湜閿佸畾鏁伴噺涓鸿礋鏁帮紝閲嶇疆涓�0銆傝绠楀��: {expectedLockQty}");
+ expectedLockQty = 0;
+ }
+
+ // 楠岃瘉鍒嗛厤鏁伴噺
+ if (Math.Abs(orderDetail.AllocatedQuantity - expectedAllocatedQty) > 0.01m)
+ {
+ _logger.LogWarning($"鍙栨秷鎷嗗寘鍚庡垎閰嶆暟閲忓紓甯� - 鏈熸湜: {expectedAllocatedQty}, 瀹為檯: {orderDetail.AllocatedQuantity}");
+ }
+
+ // 楠岃瘉閿佸畾鏁伴噺
+ if (Math.Abs(orderDetail.LockQuantity - expectedLockQty) > 0.01m)
+ {
+ _logger.LogWarning($"鍙栨秷鎷嗗寘鍚庨攣瀹氭暟閲忓紓甯� - 鏈熸湜: {expectedLockQty}, 瀹為檯: {orderDetail.LockQuantity}");
+ }
+
+ // 楠岃瘉璁㈠崟鏄庣粏鍒嗛厤鏁伴噺涓庨攣瀹氫俊鎭�诲垎閰嶆暟閲忕殑涓�鑷存��
+ if (Math.Abs(orderDetail.AllocatedQuantity - totalLockAssignQty) > 0.01m)
+ {
+ _logger.LogWarning($"鍙栨秷鎷嗗寘鍚庢暟鎹笉涓�鑷� - 璁㈠崟鏄庣粏鍒嗛厤鏁伴噺: {orderDetail.AllocatedQuantity}, 閿佸畾淇℃伅鎬诲垎閰嶆暟閲�: {totalLockAssignQty}");
+ }
+
+ // 璁板綍璇︾粏鐨勪竴鑷存�ф姤鍛�
+ _logger.LogInformation($"鍙栨秷鎷嗗寘鏁版嵁涓�鑷存�ф姤鍛� - " +
+ $"璁㈠崟鏄庣粏鍒嗛厤鏁伴噺: {orderDetail.AllocatedQuantity}, " +
+ $"璁㈠崟鏄庣粏閿佸畾鏁伴噺: {orderDetail.LockQuantity}, " +
+ $"閿佸畾淇℃伅鎬诲垎閰嶆暟閲�: {totalLockAssignQty}, " +
+ $"鎷嗗寘绫诲瀷: {(isAutoSplit ? "鑷姩" : "鎵嬪姩")}, " +
+ $"鎷嗗寘鏁伴噺: {splitQuantity}");
+ }
+ /// <summary>
+ /// 楠岃瘉鍙栨秷鎷嗗寘璇锋眰
/// </summary>
private async Task<ValidationResult<(Dt_SplitPackageRecord, Dt_OutStockLockInfo, Dt_StockInfoDetail)>> ValidateCancelSplitRequest(
string orderNo, string palletCode, string newBarcode)
{
+ _logger.LogInformation($"寮�濮嬮獙璇佸彇娑堟媶鍖呰姹� - 璁㈠崟: {orderNo}, 鎵樼洏: {palletCode}, 鏉＄爜: {newBarcode}");
+
// 鏌ユ壘鎷嗗寘璁板綍
var splitRecord = await _splitPackageService.Db.Queryable<Dt_SplitPackageRecord>()
.Where(x => x.NewBarcode == newBarcode &&
@@ -668,6 +1276,8 @@
if (splitRecord == null)
return ValidationResult<(Dt_SplitPackageRecord, Dt_OutStockLockInfo, Dt_StockInfoDetail)>.Error("鏈壘鍒版媶鍖呰褰�");
+
+ _logger.LogInformation($"鎵惧埌鎷嗗寘璁板綍 - 鍘熸潯鐮�: {splitRecord.OriginalBarcode}, 鏂版潯鐮�: {splitRecord.NewBarcode}, 鎷嗗寘鏁伴噺: {splitRecord.SplitQty}");
// 鏌ユ壘鏂伴攣瀹氫俊鎭�
var newLockInfo = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
@@ -679,13 +1289,35 @@
if (newLockInfo == null)
return ValidationResult<(Dt_SplitPackageRecord, Dt_OutStockLockInfo, Dt_StockInfoDetail)>.Error("鏈壘鍒版柊閿佸畾淇℃伅");
- // 妫�鏌ユ柊鏉＄爜鏄惁宸茶鍒嗘嫞
- var pickingRecord = await Db.Queryable<Dt_PickingRecord>()
- .Where(x => x.Barcode == newBarcode && !x.IsCancelled)
- .FirstAsync();
+ _logger.LogInformation($"鎵惧埌鏂伴攣瀹氫俊鎭� - 鐘舵��: {newLockInfo.Status}, 宸叉嫞閫�: {newLockInfo.PickedQty}, 鍒嗛厤鏁伴噺: {newLockInfo.AssignQuantity}");
- if (pickingRecord != null)
- return ValidationResult<(Dt_SplitPackageRecord, Dt_OutStockLockInfo, Dt_StockInfoDetail)>.Error("璇ユ潯鐮佸凡琚垎鎷ｏ紝鏃犳硶鍙栨秷鎷嗗寘");
+ // 妫�鏌ユ柊鏉＄爜鏄惁宸茶鍒嗘嫞
+ var newBarcodePickingRecords = await Db.Queryable<Dt_PickingRecord>()
+ .Where(x => x.Barcode == newBarcode && x.OrderNo == orderNo && !x.IsCancelled)
+ .ToListAsync();
+
+ if (newBarcodePickingRecords.Any())
+ {
+ var totalPickedQty = newBarcodePickingRecords.Sum(x => x.PickQuantity);
+ _logger.LogWarning($"鏂版潯鐮� {newBarcode} 宸茶鍒嗘嫞锛屾�绘嫞閫夋暟閲�: {totalPickedQty}");
+ return ValidationResult<(Dt_SplitPackageRecord, Dt_OutStockLockInfo, Dt_StockInfoDetail)>.Error(
+ $"鏂版潯鐮佸凡琚垎鎷ｏ紙宸叉嫞閫夋暟閲忥細{totalPickedQty}锛夛紝璇峰厛鍙栨秷鍒嗘嫞锛岀劧鍚庡啀鍙栨秷鎷嗗寘");
+ }
+
+ // 妫�鏌ュ師鏉＄爜鏄惁宸茶鍒嗘嫞
+ var originalBarcodePickingRecords = await Db.Queryable<Dt_PickingRecord>()
+ .Where(x => x.Barcode == splitRecord.OriginalBarcode && x.OrderNo == orderNo && !x.IsCancelled)
+ .ToListAsync();
+
+ if (originalBarcodePickingRecords.Any())
+ {
+ var totalPickedQty = originalBarcodePickingRecords.Sum(x => x.PickQuantity);
+ _logger.LogWarning($"鍘熸潯鐮� {splitRecord.OriginalBarcode} 宸茶鍒嗘嫞锛屾�绘嫞閫夋暟閲�: {totalPickedQty}");
+ return ValidationResult<(Dt_SplitPackageRecord, Dt_OutStockLockInfo, Dt_StockInfoDetail)>.Error(
+ $"鍘熸潯鐮佸凡琚垎鎷ｏ紙宸叉嫞閫夋暟閲忥細{totalPickedQty}锛夛紝璇峰厛鍙栨秷鍒嗘嫞锛岀劧鍚庡啀鍙栨秷鎷嗗寘");
+ }
+
+ _logger.LogInformation($"鏂版棫鏉＄爜鍧囨湭琚垎鎷ｏ紝鍙互鍙栨秷鎷嗗寘");
// 妫�鏌ユ柊鏉＄爜鏄惁琚啀娆℃媶鍖�
var childSplitRecords = await _splitPackageService.Db.Queryable<Dt_SplitPackageRecord>()
@@ -695,12 +1327,18 @@
if (childSplitRecords.Any())
{
var childBarcodes = string.Join(", ", childSplitRecords.Select(x => x.NewBarcode));
+ _logger.LogWarning($"鏉＄爜 {newBarcode} 宸茶鍐嶆鎷嗗寘锛岀敓鎴愮殑鏂版潯鐮�: {childBarcodes}");
return ValidationResult<(Dt_SplitPackageRecord, Dt_OutStockLockInfo, Dt_StockInfoDetail)>.Error(
$"璇ユ潯鐮佸凡琚啀娆℃媶鍖咃紝鐢熸垚鐨勬柊鏉＄爜锛歿childBarcodes}锛岃鍏堝彇娑堝悗缁媶鍖�");
}
var newStockDetail = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
.FirstAsync(x => x.Barcode == newBarcode);
+
+ if (newStockDetail == null)
+ return ValidationResult<(Dt_SplitPackageRecord, Dt_OutStockLockInfo, Dt_StockInfoDetail)>.Error("鏈壘鍒版柊搴撳瓨鏄庣粏");
+
+ _logger.LogInformation($"鍙栨秷鎷嗗寘楠岃瘉閫氳繃 - 鏉＄爜: {newBarcode}");
return ValidationResult<(Dt_SplitPackageRecord, Dt_OutStockLockInfo, Dt_StockInfoDetail)>.Success((splitRecord, newLockInfo, newStockDetail));
}
@@ -724,11 +1362,28 @@
if (!splitChain.Any())
return WebResponseContent.Instance.Error("鏈壘鍒版媶鍖呰褰�");
- // 2. 鎸夋媶鍖呴『搴忓�掑簭鍙栨秷锛堜粠鏈�鏂扮殑寮�濮嬪彇娑堬級
+ _logger.LogInformation($"鎵惧埌鎷嗗寘閾撅紝鍏� {splitChain.Count} 鏉¤褰�");
+
+ // 2. 鏀堕泦鎷嗗寘閾句腑娑夊強鐨勬墍鏈夋潯鐮侊紙鍖呮嫭鍘熸潯鐮佸拰鏂版潯鐮侊級
+ var allBarcodesInChain = new List<string> { startBarcode };
+ allBarcodesInChain.AddRange(splitChain.Select(x => x.NewBarcode));
+
+ // 3. 妫�鏌ユ媶鍖呴摼涓槸鍚︽湁宸茶鍒嗘嫞鐨勬潯鐮�
+ var pickedBarcodesInfo = await GetPickedBarcodesInfo(orderNo, allBarcodesInChain);
+
+ if (pickedBarcodesInfo.Any())
+ {
+ var pickedBarcodes = string.Join(", ", pickedBarcodesInfo.Select(x => $"{x.Barcode}(宸叉嫞閫墈x.PickedQty})"));
+ return WebResponseContent.Instance.Error(
+ $"浠ヤ笅鏉＄爜宸茶鍒嗘嫞锛岃鍏堝彇娑堝垎鎷ｏ細{pickedBarcodes}");
+ }
+
+ // 4. 鎸夋媶鍖呴『搴忓�掑簭鍙栨秷锛堜粠鏈�鏂扮殑寮�濮嬪彇娑堬級
var reversedChain = splitChain.OrderByDescending(x => x.SplitTime).ToList();
foreach (var splitRecord in reversedChain)
{
+ _logger.LogInformation($"鍙栨秷鎷嗗寘璁板綍 - 鍘熸潯鐮�: {splitRecord.OriginalBarcode}, 鏂版潯鐮�: {splitRecord.NewBarcode}");
await CancelSingleSplitPackage(splitRecord, palletCode);
}
@@ -744,6 +1399,133 @@
}
}
+ /// <summary>
+ /// 鑾峰彇鏉＄爜鐨勬媶鍖呭拰鎷ｉ�夌姸鎬�
+ /// </summary>
+ public async Task<WebResponseContent> GetBarcodeSplitAndPickStatus(string orderNo, string barcode)
+ {
+ try
+ {
+ // 1. 鑾峰彇鎷嗗寘淇℃伅
+ var splitChain = await GetSplitPackageChain(orderNo, barcode);
+ var isOriginalBarcode = !splitChain.Any(x => x.NewBarcode == barcode);
+
+ // 2. 鑾峰彇鎷ｉ�変俊鎭�
+ var pickingRecords = await Db.Queryable<Dt_PickingRecord>()
+ .Where(x => x.Barcode == barcode && x.OrderNo == orderNo && !x.IsCancelled)
+ .ToListAsync();
+
+ var totalPickedQty = pickingRecords.Sum(x => x.PickQuantity);
+
+ // 3. 鑾峰彇閿佸畾淇℃伅
+ var lockInfo = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
+ .Where(x => x.CurrentBarcode == barcode && x.OrderNo == orderNo)
+ .FirstAsync();
+
+ // 4. 鑾峰彇搴撳瓨淇℃伅
+ var stockDetail = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
+ .Where(x => x.Barcode == barcode)
+ .FirstAsync();
+
+ var statusInfo = new BarcodeStatusInfoDto
+ {
+ Barcode = barcode,
+ OrderNo = orderNo,
+ IsOriginalBarcode = isOriginalBarcode,
+ SplitChainCount = splitChain.Count,
+ HasBeenPicked = pickingRecords.Any(),
+ TotalPickedQuantity = totalPickedQty,
+ PickRecordCount = pickingRecords.Count,
+ LockInfoStatus = lockInfo?.Status ?? 0,
+ LockInfoPickedQty = lockInfo?.PickedQty ?? 0,
+ LockInfoAssignQty = lockInfo?.AssignQuantity ?? 0,
+ StockQuantity = stockDetail?.StockQuantity ?? 0,
+ StockStatus = stockDetail?.Status ?? 0,
+ CanCancelSplit = !pickingRecords.Any(), // 鏈鍒嗘嫞鎵嶈兘鍙栨秷鎷嗗寘
+ NeedCancelPickFirst = pickingRecords.Any() // 闇�瑕佸厛鍙栨秷鍒嗘嫞
+ };
+
+ // 5. 鑾峰彇鎿嶄綔寤鸿
+ statusInfo.OperationSuggestions = GetOperationSuggestions(statusInfo);
+
+ return WebResponseContent.Instance.OK("鑾峰彇鐘舵�佹垚鍔�", statusInfo);
+ }
+ catch (Exception ex)
+ {
+ _logger.LogError($"鑾峰彇鏉＄爜鐘舵�佸け璐� - OrderNo: {orderNo}, Barcode: {barcode}, Error: {ex.Message}");
+ return WebResponseContent.Instance.Error("鑾峰彇鏉＄爜鐘舵�佸け璐�");
+ }
+ }
+ /// <summary>
+ /// 鑾峰彇鎿嶄綔寤鸿
+ /// </summary>
+ private List<string> GetOperationSuggestions(BarcodeStatusInfoDto statusInfo)
+ {
+ var suggestions = new List<string>();
+
+ if (statusInfo.HasBeenPicked)
+ {
+ suggestions.Add($"璇ユ潯鐮佸凡琚垎鎷ｏ紙鏁伴噺锛歿statusInfo.TotalPickedQuantity}锛夛紝濡傞渶鍙栨秷鎷嗗寘锛岃鍏堝彇娑堝垎鎷�");
+
+ if (statusInfo.IsOriginalBarcode)
+ {
+ suggestions.Add("杩欐槸鍘熸潯鐮侊紝鍙栨秷鍒嗘嫞鍚庡皢鎭㈠涓哄彲鍒嗘嫞鐘舵��");
+ }
+ else
+ {
+ suggestions.Add("杩欐槸鎷嗗寘鐢熸垚鐨勬柊鏉＄爜锛屽彇娑堝垎鎷ｅ悗鎵嶈兘鍙栨秷鎷嗗寘");
+ }
+ }
+ else
+ {
+ if (statusInfo.IsOriginalBarcode && statusInfo.SplitChainCount > 0)
+ {
+ suggestions.Add("杩欐槸鍘熸潯鐮侊紝鍙互鍙栨秷鎷嗗寘閾�");
+ }
+ else if (!statusInfo.IsOriginalBarcode)
+ {
+ suggestions.Add("杩欐槸鎷嗗寘鐢熸垚鐨勬柊鏉＄爜锛屽彲浠ュ崟鐙彇娑堟媶鍖�");
+ }
+ }
+
+ if (statusInfo.LockInfoStatus == (int)OutLockStockStatusEnum.鎷ｉ�夊畬鎴�)
+ {
+ suggestions.Add("閿佸畾鐘舵�侊細鎷ｉ�夊畬鎴�");
+ }
+ else if (statusInfo.LockInfoStatus == (int)OutLockStockStatusEnum.鍑哄簱涓�)
+ {
+ suggestions.Add("閿佸畾鐘舵�侊細鍑哄簱涓�");
+ }
+
+ return suggestions;
+ }
+ /// <summary>
+ /// 鑾峰彇宸茶鍒嗘嫞鐨勬潯鐮佷俊鎭�
+ /// </summary>
+ private async Task<List<PickedBarcodeInfo>> GetPickedBarcodesInfo(string orderNo, List<string> barcodes)
+ {
+ var pickedBarcodes = new List<PickedBarcodeInfo>();
+
+ foreach (var barcode in barcodes)
+ {
+ var pickingRecords = await Db.Queryable<Dt_PickingRecord>()
+ .Where(x => x.Barcode == barcode && x.OrderNo == orderNo && !x.IsCancelled)
+ .ToListAsync();
+
+ if (pickingRecords.Any())
+ {
+ var totalPickedQty = pickingRecords.Sum(x => x.PickQuantity);
+ pickedBarcodes.Add(new PickedBarcodeInfo
+ {
+ Barcode = barcode,
+ PickedQty = totalPickedQty,
+ PickRecordCount = pickingRecords.Count
+ });
+ }
+ }
+
+ return pickedBarcodes;
+ }
/// <summary>
/// 鑾峰彇鎷嗗寘閾� - 鏌ユ壘鏌愪釜鏉＄爜鐨勬墍鏈夋媶鍖呰褰曪紙鍖呮嫭鍚庣画鎷嗗寘锛�
/// </summary>
@@ -788,6 +1570,27 @@
/// </summary>
private async Task CancelSingleSplitPackage(Dt_SplitPackageRecord splitRecord, string palletCode)
{
+ _logger.LogInformation($"寮�濮嬪彇娑堝崟涓媶鍖呰褰� - 鍘熸潯鐮�: {splitRecord.OriginalBarcode}, 鏂版潯鐮�: {splitRecord.NewBarcode}");
+
+ // 鍐嶆楠岃瘉鍒嗘嫞鐘舵�侊紙闃叉骞跺彂鎿嶄綔锛�
+ var newBarcodePickingRecords = await Db.Queryable<Dt_PickingRecord>()
+ .Where(x => x.Barcode == splitRecord.NewBarcode && !x.IsCancelled)
+ .ToListAsync();
+
+ if (newBarcodePickingRecords.Any())
+ {
+ throw new InvalidOperationException($"鏂版潯鐮� {splitRecord.NewBarcode} 鍦ㄩ獙璇佸悗琚垎鎷ｏ紝鏃犳硶鍙栨秷鎷嗗寘");
+ }
+
+ var originalBarcodePickingRecords = await Db.Queryable<Dt_PickingRecord>()
+ .Where(x => x.Barcode == splitRecord.OriginalBarcode && !x.IsCancelled)
+ .ToListAsync();
+
+ if (originalBarcodePickingRecords.Any())
+ {
+ throw new InvalidOperationException($"鍘熸潯鐮� {splitRecord.OriginalBarcode} 鍦ㄩ獙璇佸悗琚垎鎷ｏ紝鏃犳硶鍙栨秷鎷嗗寘");
+ }
+
// 鏌ユ壘鐩稿叧鏁版嵁
var newLockInfo = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
.Where(x => x.CurrentBarcode == splitRecord.NewBarcode &&
@@ -802,6 +1605,8 @@
// 鎵ц鍙栨秷閫昏緫
await ExecuteCancelSplitLogic(splitRecord, originalLockInfo, newLockInfo, newStockDetail);
+
+ _logger.LogInformation($"鍙栨秷鍗曚釜鎷嗗寘璁板綍瀹屾垚 - 鍘熸潯鐮�: {splitRecord.OriginalBarcode}, 鏂版潯鐮�: {splitRecord.NewBarcode}");
}
#endregion
@@ -827,7 +1632,8 @@
NewBarcode = x.NewBarcode,
SplitQuantity = x.SplitQty,
Operator = x.Operator,
- IsReverted = x.IsReverted
+ IsReverted = x.IsReverted,
+ IsAutoSplit = x.IsAutoSplit
}).ToList()
};
@@ -916,93 +1722,2597 @@
#endregion
- #region DTO绫�
-
-
-
- public class SplitPackageChainInfoDto
+ #region 缁熶竴鍥炲簱閫昏緫
+ private async Task<Dt_Task> GetCurrentTask(string orderNo, string palletCode)
{
- public string OriginalBarcode { get; set; }
- public string RootBarcode { get; set; } // 鏂板锛氭牴鏉＄爜
- public int TotalSplitTimes { get; set; }
- public string ChainType { get; set; } // "root" 鎴� "branch"
- public List<SplitChainItemDto> SplitChain { get; set; }
- }
+ // 鍏堝皾璇曢�氳繃璁㈠崟鍙峰拰鎵樼洏鍙锋煡鎵句换鍔�
+ var task = await _taskRepository.Db.Queryable<Dt_Task>()
+ .Where(x => x.OrderNo == orderNo && x.PalletCode == palletCode)
+ .FirstAsync();
- public class SplitChainItemDto
+ if (task == null)
+ {
+ // 濡傛灉鎵句笉鍒帮紝鍐嶉�氳繃鎵樼洏鍙锋煡鎵�
+ task = await _taskRepository.Db.Queryable<Dt_Task>()
+ .Where(x => x.PalletCode == palletCode)
+ .FirstAsync();
+ }
+
+ return task;
+ }
+ private async Task<PalletStatusAnalysis> AnalyzePalletStatus(string orderNo, string palletCode, int stockId)
{
- public DateTime SplitTime { get; set; }
- public string OriginalBarcode { get; set; }
- public string NewBarcode { get; set; }
- public decimal SplitQuantity { get; set; }
- public string Operator { get; set; }
- public bool IsReverted { get; set; }
+ var result = new PalletStatusAnalysis
+ {
+ OrderNo = orderNo,
+ PalletCode = palletCode,
+ StockId = stockId
+ };
+
+ // 鍒嗘瀽鏈垎鎷ｇ殑鍑哄簱閿佸畾璁板綍
+ var remainingLocks = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
+ .Where(it => it.OrderNo == orderNo &&
+ it.PalletCode == palletCode &&
+ it.Status == (int)OutLockStockStatusEnum.鍑哄簱涓�)
+ .ToListAsync();
+
+ if (remainingLocks.Any())
+ {
+ result.HasRemainingLocks = true;
+ result.RemainingLocks = remainingLocks;
+ result.RemainingLocksReturnQty = remainingLocks.Sum(x => x.AssignQuantity - x.PickedQty);
+ _logger.LogInformation($"鍙戠幇{remainingLocks.Count}鏉℃湭鍒嗘嫞閿佸畾璁板綍锛屾�绘暟閲�: {result.RemainingLocksReturnQty}");
+ }
+
+ // 鍒嗘瀽鎵樼洏涓婄殑搴撳瓨璐х墿
+ var palletStockGoods = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
+ .Where(it => it.StockId == stockId &&
+ (it.Status == StockStatusEmun.鍏ュ簱纭.ObjToInt() ||
+ it.Status == StockStatusEmun.鍏ュ簱瀹屾垚.ObjToInt() ||
+ it.Status == StockStatusEmun.鍑哄簱閿佸畾.ObjToInt()))
+ .Where(it => it.StockQuantity > 0)
+ .ToListAsync();
+
+ if (palletStockGoods.Any())
+ {
+ result.HasPalletStockGoods = true;
+ result.PalletStockGoods = palletStockGoods;
+ result.PalletStockReturnQty = palletStockGoods.Sum(x => x.StockQuantity);
+ _logger.LogInformation($"鍙戠幇{palletStockGoods.Count}涓簱瀛樿揣鐗╋紝鎬绘暟閲�: {result.PalletStockReturnQty}");
+
+ // 璁板綍璇︾粏鐘舵�佸垎甯�
+ var statusGroups = palletStockGoods.GroupBy(x => x.Status);
+ foreach (var group in statusGroups)
+ {
+ _logger.LogInformation($"搴撳瓨鐘舵�亄group.Key}: {group.Count()}涓揣鐗╋紝鏁伴噺: {group.Sum(x => x.StockQuantity)}");
+ }
+ }
+
+ //鍒嗘瀽鎷嗗寘璁板綍
+ var splitRecords = await _splitPackageService.Db.Queryable<Dt_SplitPackageRecord>()
+ .Where(it => it.OrderNo == orderNo &&
+ it.PalletCode == palletCode &&
+ !it.IsReverted && it.Status != (int)SplitPackageStatusEnum.宸叉嫞閫� &&
+ it.Status != (int)SplitPackageStatusEnum.宸插洖搴�)
+ .ToListAsync();
+
+ if (splitRecords.Any())
+ {
+ result.HasSplitRecords = true;
+ result.SplitRecords = splitRecords;
+ result.SplitReturnQty = await CalculateSplitReturnQuantity(splitRecords, stockId);
+
+ _logger.LogInformation($"鍙戠幇{splitRecords.Count}鏉℃湭鎷ｉ�夋媶鍖呰褰曪紝鎬绘暟閲�: {result.SplitReturnQty}");
+ }
+
+ // 4. 璁＄畻鎬诲洖搴撴暟閲忓拰绌烘墭鐩樼姸鎬�
+ result.TotalReturnQty = result.RemainingLocksReturnQty + result.PalletStockReturnQty + result.SplitReturnQty;
+ result.HasItemsToReturn = result.TotalReturnQty > 0;
+ result.IsEmptyPallet = !result.HasItemsToReturn;
+
+ // 5. 妫�鏌ユ槸鍚︽湁杩涜涓殑浠诲姟
+ result.HasActiveTasks = await _taskRepository.Db.Queryable<Dt_Task>()
+ .Where(x => x.OrderNo == orderNo && x.TaskType == TaskTypeEnum.InPick.ObjToInt() &&
+ x.PalletCode == palletCode &&
+ x.TaskStatus == (int)TaskStatusEnum.New)
+ .AnyAsync();
+
+ _logger.LogInformation($"鎵樼洏鐘舵�佸垎鏋愬畬鎴� - 璁㈠崟: {orderNo}, 鎵樼洏: {palletCode}, " +
+ $"鎬诲洖搴撴暟閲�: {result.TotalReturnQty}, 鏄惁绌烘墭鐩�: {result.IsEmptyPallet}, " +
+ $"鏈夎繘琛屼腑浠诲姟: {result.HasActiveTasks}");
+
+ return result;
}
+ private async Task<decimal> CalculateSplitReturnQuantity(List<Dt_SplitPackageRecord> splitRecords, int stockId)
+ {
+ decimal totalQty = 0;
+ var processedBarcodes = new HashSet<string>();
- #endregion
+ foreach (var splitRecord in splitRecords)
+ {
+ if (splitRecord.Status != (int)SplitPackageStatusEnum.宸叉挙閿�)
+ continue;
+ // 妫�鏌ュ師鏉＄爜
+ if (!processedBarcodes.Contains(splitRecord.OriginalBarcode))
+ {
+ var originalStock = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
+ .Where(it => it.Barcode == splitRecord.OriginalBarcode && it.StockId == stockId &&
+ it.Status != StockStatusEmun.鍑哄簱瀹屾垚.ObjToInt())
+ .FirstAsync();
- #endregion
+ if (originalStock != null && originalStock.StockQuantity > 0)
+ {
+ totalQty += originalStock.StockQuantity;
+ processedBarcodes.Add(splitRecord.OriginalBarcode);
+ }
+ }
- #region 鍒嗘壒鍥炲簱
+ // 妫�鏌ユ柊鏉＄爜
+ if (!processedBarcodes.Contains(splitRecord.NewBarcode))
+ {
+ var newStock = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
+ .Where(it => it.Barcode == splitRecord.NewBarcode && it.StockId == stockId && it.Status != StockStatusEmun.鍑哄簱瀹屾垚.ObjToInt())
+ .FirstAsync();
+
+ if (newStock != null && newStock.StockQuantity > 0)
+ {
+ totalQty += newStock.StockQuantity;
+ processedBarcodes.Add(splitRecord.NewBarcode);
+ }
+ }
+ }
+
+ return totalQty;
+ }
/// <summary>
- /// 鍒嗘壒鍥炲簱 - 閲婃斁鏈嫞閫夌殑搴撳瓨
+ /// 缁熶竴鍥炲簱鏂规硶 - 澶勭悊鎵樼洏涓婃墍鏈夊墿浣欒揣鐗�
/// </summary>
- public async Task<WebResponseContent> BatchReturnStock(string orderNo, string palletCode)
+ //public async Task<WebResponseContent> ExecutePalletReturn(string orderNo, string palletCode, string returnReason = "鍒嗘壒鍥炲簱")
+ //{
+ // try
+ // {
+ // int stockId = 0;
+ // Dt_StockInfo stockInfo = null;
+ // PalletStatusAnalysis statusAnalysis = null;
+ // _unitOfWorkManage.BeginTran();
+
+ // if (string.IsNullOrEmpty(orderNo) || string.IsNullOrEmpty(palletCode))
+ // return WebResponseContent.Instance.Error("璁㈠崟鍙峰拰鎵樼洏鐮佷笉鑳戒负绌�");
+
+ // // 鑾峰彇搴撳瓨淇℃伅
+ // stockInfo = await _stockInfoService.Db.Queryable<Dt_StockInfo>()
+ // .FirstAsync(x => x.PalletCode == palletCode);
+ // if (stockInfo == null)
+ // return WebResponseContent.Instance.Error($"鏈壘鍒版墭鐩� {palletCode} 瀵瑰簲鐨勫簱瀛樹俊鎭�");
+
+ // stockId = stockInfo.Id;
+
+ // var beforeValidationResult = await ValidateReturnData(orderNo, palletCode, stockId, true);
+ // if (!beforeValidationResult)
+ // {
+ // _logger.LogWarning("鍥炲簱鍓嶆暟鎹獙璇佸彂鐜伴棶棰橈紝浣嗙户缁墽琛屽洖搴撴搷浣�");
+ // }
+ // _logger.LogInformation($"姝ラ4瀹屾垚: 鍥炲簱鍓嶆暟鎹獙璇亄(beforeValidationResult ? "閫氳繃" : "鍙戠幇闂")}");
+
+
+ // // 鍒嗘瀽鎵樼洏鐘舵��
+ // statusAnalysis = await AnalyzePalletStatusForReturn(orderNo, palletCode, stockInfo.Id);
+ // _logger.LogInformation($"銆愭楠�6銆戞墭鐩樼姸鎬佸垎鏋愬畬鎴�");
+ // _logger.LogInformation($" - 鏄惁鏈夊洖搴撶墿鍝�: {statusAnalysis.HasItemsToReturn}");
+ // _logger.LogInformation($" - 鏄惁绌烘墭鐩�: {statusAnalysis.IsEmptyPallet}");
+ // _logger.LogInformation($" - 鎬诲洖搴撴暟閲�: {statusAnalysis.TotalReturnQty}");
+ // _logger.LogInformation($" - 鏉＄爜鏁伴噺: {statusAnalysis.AllBarcodes.Count}");
+
+ // if (!statusAnalysis.HasItemsToReturn)
+ // {
+ // _logger.LogInformation($"銆愭楠�7銆戞棤鍥炲簱鐗╁搧锛屽鐞嗙┖鎵樼洏");
+ // var result = await HandleEmptyPalletReturn(orderNo, palletCode, stockInfo);
+ // if (result.Status)
+ // {
+ // _unitOfWorkManage.CommitTran();
+ // _logger.LogInformation($"銆愮┖鎵樼洏鍥炲簱鎴愬姛銆戣鍗�: {orderNo}, 鎵樼洏: {palletCode}");
+ // }
+ // else
+ // {
+ // _unitOfWorkManage.RollbackTran();
+ // _logger.LogError($"銆愮┖鎵樼洏鍥炲簱澶辫触銆戝師鍥�: {result.Message}");
+ // }
+ // return result;
+ // }
+
+ // _logger.LogInformation($"寮�濮嬪洖搴撴搷浣� - 璁㈠崟: {orderNo}, 鎵樼洏: {palletCode}, 鍥炲簱鏁伴噺: {statusAnalysis.TotalReturnQty}");
+
+ // try
+ // {
+ // // 鎵ц鍥炲簱鏁版嵁鎿嶄綔
+ // await ExecuteReturnDataOperations(statusAnalysis);
+ // }
+ // catch (Exception ex)
+ // {
+ // _logger.LogError($"鍥炲簱鏁版嵁鎿嶄綔澶辫触: {ex.Message}");
+ // try
+ // {
+ // await ExecuteSimpleReturnDataOperations(statusAnalysis);
+ // _logger.LogInformation($"绠�鍖栧洖搴撴暟鎹搷浣滄垚鍔�");
+ // }
+ // catch (Exception simpleEx)
+ // {
+ // _logger.LogError($"绠�鍖栧洖搴撴暟鎹搷浣滀篃澶辫触 - {simpleEx.Message}");
+ // throw new InvalidOperationException($"鍥炲簱鏁版嵁鎿嶄綔澶辫触锛屼富鏂规硶: {ex.Message}, 绠�鍖栨柟娉�: {simpleEx.Message}", ex);
+ // }
+ // }
+
+ // // 鏇存柊璁㈠崟鐘舵��
+ // await UpdateOrderStatusAfterReturn(orderNo);
+
+ // _unitOfWorkManage.CommitTran();
+
+ // _logger.LogInformation($"姝ラ10: 寮�濮嬪洖搴撳悗鏁版嵁楠岃瘉");
+ // var afterValidationResult = await ValidateReturnData(orderNo, palletCode, stockId, false);
+ // if (!afterValidationResult)
+ // {
+ // _logger.LogWarning("鍥炲簱鍚庢暟鎹獙璇佸彂鐜伴棶棰橈紝寤鸿妫�鏌ユ暟鎹竴鑷存��");
+ // }
+ // _logger.LogInformation($"姝ラ10瀹屾垚: 鍥炲簱鍚庢暟鎹獙璇亄(afterValidationResult ? "閫氳繃" : "鍙戠幇闂")}");
+
+ // try
+ // {
+ // await CreateReturnTask(orderNo, palletCode, stockInfo);
+ // _logger.LogInformation($"姝ラ11鎴愬姛: 鍥炲簱浠诲姟鍒涘缓鎴愬姛");
+ // }
+ // catch (Exception taskEx)
+ // {
+ // // 浠诲姟鍒涘缓澶辫触涓嶅奖鍝嶅洖搴撴暟鎹搷浣滅殑鎴愬姛锛屽彧璁板綍閿欒
+ // _logger.LogError($"姝ラ11璀﹀憡: 鍥炲簱浠诲姟鍒涘缓澶辫触 - {taskEx.Message}");
+ // _logger.LogError($"鍥炲簱鏁版嵁鎿嶄綔宸叉垚鍔燂紝浣嗕换鍔″垱寤哄け璐ワ紝鍙兘闇�瑕佹墜鍔ㄥ鐞�");
+ // }
+
+ // _logger.LogInformation($"銆愬洖搴撴垚鍔熴�戣鍗�: {orderNo}, 鎵樼洏: {palletCode}, 鍥炲簱鏁伴噺: {statusAnalysis.TotalReturnQty}");
+
+ // return WebResponseContent.Instance.OK($"鍥炲簱鎿嶄綔鎴愬姛锛屽叡鍥炲簱鏁伴噺锛歿statusAnalysis.TotalReturnQty}", new
+ // {
+ // ReturnQuantity = statusAnalysis.TotalReturnQty,
+ // ReturnBarcodes = statusAnalysis.AllBarcodes,
+ // Reason = returnReason,
+ // PalletCode = palletCode,
+ // OrderNo = orderNo
+ // });
+ // }
+ // catch (Exception ex)
+ // {
+ // _unitOfWorkManage.RollbackTran();
+ // _logger.LogError($"銆愬洖搴撳け璐ャ�戣鍗�: {orderNo}, 鎵樼洏: {palletCode}, 閿欒绫诲瀷: {ex.GetType().Name}");
+ // _logger.LogError($"銆愰敊璇俊鎭�憑ex.Message}");
+ // _logger.LogError($"銆愬爢鏍堜俊鎭�憑ex.StackTrace}");
+
+ // if (ex.InnerException != null)
+ // {
+ // _logger.LogError($"銆愬唴閮ㄩ敊璇�憑ex.InnerException.Message}");
+ // }
+ // return WebResponseContent.Instance.Error($"鍥炲簱鎿嶄綔澶辫触: {ex.Message}");
+ // }
+ //}
+
+ /// <summary>
+ /// 缁熶竴鍥炲簱鏂规硶
+ /// </summary>
+ public async Task<WebResponseContent> ExecutePalletReturn(string orderNo, string palletCode, string returnReason = "鍒嗘壒鍥炲簱")
{
try
{
+ _logger.LogInformation($"銆愬寮哄洖搴撳紑濮嬨�戣鍗�: {orderNo}, 鎵樼洏: {palletCode}");
+
_unitOfWorkManage.BeginTran();
- // 鏌ユ壘鎵樼洏涓婃湭瀹屾垚鐨勯攣瀹氳褰�
- var unfinishedLocks = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
+ // 1. 鍩虹楠岃瘉
+ if (string.IsNullOrEmpty(orderNo) || string.IsNullOrEmpty(palletCode))
+ return WebResponseContent.Instance.Error("璁㈠崟鍙峰拰鎵樼洏鐮佷笉鑳戒负绌�");
+
+ // 2. 鑾峰彇搴撳瓨淇℃伅
+ var stockInfo = await _stockInfoService.Db.Queryable<Dt_StockInfo>()
+ .FirstAsync(x => x.PalletCode == palletCode);
+
+ if (stockInfo == null)
+ return WebResponseContent.Instance.Error($"鏈壘鍒版墭鐩� {palletCode} 瀵瑰簲鐨勫簱瀛樹俊鎭�");
+
+ int stockId = stockInfo.Id;
+
+ // 3. 鎵ц鍥炲簱鍓嶆暟鎹獙璇�
+ var validationResult = await ValidateDataBeforeReturn(orderNo, palletCode, stockId);
+ if (!validationResult.IsValid)
+ {
+ _logger.LogWarning($"鍥炲簱鍓嶆暟鎹獙璇佸け璐�: {validationResult.ErrorMessage}");
+ // 鍙互鏍规嵁瀹為檯鎯呭喌鍐冲畾鏄惁缁х画
+ }
+
+ // 4. 鍒嗘瀽鎵樼洏鐘舵��
+ var statusAnalysis = await AnalyzePalletStatusForReturn(orderNo, palletCode, stockInfo.Id);
+
+ if (!statusAnalysis.HasItemsToReturn)
+ {
+ try
+ {
+ _logger.LogInformation($"銆愭棤鍥炲簱鐗╁搧銆戝鐞嗙┖鎵樼洏");
+ var result = await HandleEmptyPalletReturn(orderNo, palletCode, stockInfo);
+ _unitOfWorkManage.CommitTran();
+ return result;
+ }
+ catch (Exception ex)
+ {
+ _unitOfWorkManage.RollbackTran();
+ _logger.LogError($"绌虹鍥炲簱澶辫触: {ex.Message}");
+ return WebResponseContent.Instance.Error($"绌虹鍥炲簱澶辫触锛歿ex.Message}");
+ }
+ }
+
+ _logger.LogInformation($"銆愬紑濮嬪洖搴撱�戞�诲洖搴撴暟閲�: {statusAnalysis.TotalReturnQty}, 鏉＄爜鏁�: {statusAnalysis.AllBarcodes.Count}");
+
+ // 5. 鎵ц鍥炲簱鎿嶄綔
+ try
+ {
+ await ExecuteEnhancedReturnOperations(statusAnalysis);
+ }
+ catch (Exception ex)
+ {
+ _logger.LogError($"涓诲洖搴撴柟娉曞け璐�: {ex.Message}");
+ // 灏濊瘯绠�鍖栨柟娉�
+ await ExecuteSimpleReturnDataOperations(statusAnalysis);
+ }
+
+ // 6. 鏇存柊璁㈠崟鐘舵��
+ await UpdateOrderStatusAfterReturn(orderNo);
+
+ _unitOfWorkManage.CommitTran();
+
+ // 7. 鍒涘缓鍥炲簱浠诲姟
+ try
+ {
+ await CreateReturnTask(orderNo, palletCode, stockInfo);
+ }
+ catch (Exception taskEx)
+ {
+ _logger.LogError($"鍥炲簱浠诲姟鍒涘缓澶辫触: {taskEx.Message}");
+ // 浠诲姟鍒涘缓澶辫触涓嶅奖鍝嶆暟鎹洖搴�
+ }
+ _unitOfWorkManage.CommitTran();
+ // 8. 鍥炲簱鍚庨獙璇�
+ await ValidateDataAfterReturn(orderNo, palletCode, stockId);
+
+ return WebResponseContent.Instance.OK($"鍥炲簱鎴愬姛锛屽洖搴撴暟閲忥細{statusAnalysis.TotalReturnQty}", new
+ {
+ ReturnQuantity = statusAnalysis.TotalReturnQty,
+ ReturnBarcodes = statusAnalysis.AllBarcodes,
+ Reason = returnReason,
+ PalletCode = palletCode,
+ OrderNo = orderNo
+ });
+ }
+ catch (Exception ex)
+ {
+ _unitOfWorkManage.RollbackTran();
+ _logger.LogError($"鍥炲簱澶辫触: {ex.Message}");
+ return WebResponseContent.Instance.Error($"鍥炲簱澶辫触锛歿ex.Message}");
+ }
+ }
+
+ /// <summary>
+ /// 澧炲己鐨勫洖搴撳墠鏁版嵁楠岃瘉
+ /// </summary>
+ private async Task<ValidationResult<bool>> ValidateDataBeforeReturn(string orderNo, string palletCode, int stockId)
+ {
+ var errors = new List<string>();
+
+ try
+ {
+ // 1. 楠岃瘉搴撳瓨鏁版嵁
+ var stockDetails = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
+ .Where(x => x.StockId == stockId)
+ .ToListAsync();
+
+ // 妫�鏌ュ簱瀛樻暟閲忔槸鍚︿负璐熸暟
+ var negativeStocks = stockDetails.Where(x => x.StockQuantity < 0).ToList();
+ if (negativeStocks.Any())
+ {
+ errors.Add($"鍙戠幇璐熸暟搴撳瓨: {string.Join(", ", negativeStocks.Select(x => $"{x.Barcode}:{x.StockQuantity}"))}");
+ }
+
+ // 2. 楠岃瘉閿佸畾璁板綍
+ var lockInfos = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
+ .Where(x => x.OrderNo == orderNo && x.PalletCode == palletCode)
+ .ToListAsync();
+
+ // 妫�鏌ュ凡鎷ｉ�夋暟閲忔槸鍚﹀ぇ浜庡垎閰嶆暟閲�
+ var invalidLocks = lockInfos.Where(x => x.PickedQty > x.AssignQuantity).ToList();
+ if (invalidLocks.Any())
+ {
+ errors.Add($"鍙戠幇宸叉嫞閫夋暟閲忓ぇ浜庡垎閰嶆暟閲忕殑閿佸畾璁板綍");
+ }
+
+ // 3. 楠岃瘉鎷嗗寘璁板綍
+ var splitRecords = await _splitPackageService.Db.Queryable<Dt_SplitPackageRecord>()
+ .Where(x => x.OrderNo == orderNo && x.PalletCode == palletCode)
+ .ToListAsync();
+
+ // 妫�鏌ュ惊鐜媶鍖�
+ var barcodeMap = new Dictionary<string, string>();
+ foreach (var record in splitRecords.Where(x => !x.IsReverted))
+ {
+ if (!barcodeMap.ContainsKey(record.OriginalBarcode))
+ barcodeMap[record.OriginalBarcode] = record.NewBarcode;
+ }
+
+ // 妫�鏌ュ惊鐜紩鐢�
+ foreach (var record in splitRecords)
+ {
+ var current = record.OriginalBarcode;
+ var visited = new HashSet<string>();
+
+ while (barcodeMap.ContainsKey(current))
+ {
+ if (visited.Contains(current))
+ {
+ errors.Add($"鍙戠幇寰幆鎷嗗寘寮曠敤: {record.OriginalBarcode}");
+ break;
+ }
+ visited.Add(current);
+ current = barcodeMap[current];
+ }
+ }
+
+ if (errors.Any())
+ {
+ return ValidationResult<bool>.Error($"鍥炲簱鍓嶆暟鎹獙璇佸彂鐜伴棶棰�: {string.Join("; ", errors)}");
+ }
+
+ return ValidationResult<bool>.Success(true);
+ }
+ catch (Exception ex)
+ {
+ _logger.LogError($"鏁版嵁楠岃瘉澶辫触: {ex.Message}");
+ return ValidationResult<bool>.Error($"鏁版嵁楠岃瘉寮傚父: {ex.Message}");
+ }
+ }
+
+ /// <summary>
+ /// 鎵ц澧炲己鐨勫洖搴撴搷浣�
+ /// </summary>
+ private async Task ExecuteEnhancedReturnOperations(PalletStatusAnalysis statusAnalysis)
+ {
+ _logger.LogInformation($"鎵ц澧炲己鍥炲簱鎿嶄綔 - 璁㈠崟: {statusAnalysis.OrderNo}, 鎵樼洏: {statusAnalysis.PalletCode}");
+
+ // 澶勭悊宸插垎閰嶇殑閿佸畾璁板綍
+ if (statusAnalysis.HasRemainingLocks)
+ {
+ await HandleAllocatedLocksReturn(statusAnalysis.RemainingLocks);
+ }
+
+ // 澶勭悊鏈垎閰嶇殑閿佸畾璁板綍
+ if (statusAnalysis.HasUnallocatedLocks)
+ {
+ await HandleUnallocatedLocksReturn(statusAnalysis.UnallocatedLocks);
+ }
+
+ // 澶勭悊鏈垎閰嶇殑搴撳瓨璐х墿
+ if (statusAnalysis.HasPalletStockGoods)
+ {
+ await HandleUnallocatedStockReturn(statusAnalysis.PalletStockGoods);
+ }
+
+ // 澶勭悊鎷嗗寘璁板綍
+ if (statusAnalysis.HasSplitRecords)
+ {
+ await HandleSplitRecordsReturn(statusAnalysis.SplitRecords, statusAnalysis.StockId);
+ }
+ }
+
+ /// <summary>
+ /// 鍥炲簱鍚庢暟鎹獙璇�
+ /// </summary>
+ private async Task ValidateDataAfterReturn(string orderNo, string palletCode, int stockId)
+ {
+ try
+ {
+ _logger.LogInformation($"寮�濮嬪洖搴撳悗鏁版嵁楠岃瘉");
+
+ // 1. 楠岃瘉搴撳瓨鐘舵��
+ var stockDetails = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
+ .Where(x => x.StockId == stockId)
+ .ToListAsync();
+
+ var stillOutboundLocked = stockDetails.Where(x =>
+ x.Status == (int)StockStatusEmun.鍑哄簱閿佸畾 && x.StockQuantity > 0).ToList();
+
+ if (stillOutboundLocked.Any())
+ {
+ _logger.LogWarning($"鍥炲簱鍚庝粛鏈夊嚭搴撻攣瀹氱姸鎬佺殑搴撳瓨: {stillOutboundLocked.Count}涓�");
+ }
+
+ // 2. 楠岃瘉閿佸畾璁板綍鐘舵��
+ var lockInfos = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
+ .Where(x => x.OrderNo == orderNo && x.PalletCode == palletCode)
+ .ToListAsync();
+
+ var notReturnedLocks = lockInfos.Where(x =>
+ x.Status != (int)OutLockStockStatusEnum.宸插洖搴� &&
+ x.Status != (int)OutLockStockStatusEnum.宸插彇璧�).ToList();
+
+ if (notReturnedLocks.Any())
+ {
+ _logger.LogWarning($"鍥炲簱鍚庝粛鏈夋湭鍥炲簱鐘舵�佺殑閿佸畾璁板綍: {notReturnedLocks.Count}鏉�");
+ }
+
+ // 3. 鏁版嵁涓�鑷存�ч獙璇�
+ decimal totalStock = stockDetails.Sum(x => x.StockQuantity);
+ _logger.LogInformation($"鍥炲簱鍚庡簱瀛樻�婚噺: {totalStock}");
+
+ _logger.LogInformation($"鍥炲簱鍚庢暟鎹獙璇佸畬鎴�");
+ }
+ catch (Exception ex)
+ {
+ _logger.LogError($"鍥炲簱鍚庨獙璇佸け璐�: {ex.Message}");
+ }
+ }
+
+
+ /// <summary>
+ /// 楠岃瘉鍥炲簱鍓嶅悗鏁版嵁涓�鑷存��
+ /// </summary>
+ private async Task<bool> ValidateReturnData(string orderNo, string palletCode, int stockId, bool isBefore = true)
+ {
+ string phase = isBefore ? "鍥炲簱鍓�" : "鍥炲簱鍚�";
+ try
+ {
+
+ _logger.LogInformation($"銆恵phase}鏁版嵁楠岃瘉銆戝紑濮� - 璁㈠崟: {orderNo}, 鎵樼洏: {palletCode}");
+
+ // 1. 妫�鏌ュ簱瀛樻槑缁�
+ var stockDetails = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
+ .Where(x => x.StockId == stockId)
+ .ToListAsync();
+
+ decimal totalStockQty = stockDetails.Sum(x => x.StockQuantity);
+ _logger.LogInformation($"{phase}搴撳瓨鎬婚噺: {totalStockQty}");
+
+ // 2. 妫�鏌ラ攣瀹氳褰�
+ var lockInfos = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
+ .Where(x => x.OrderNo == orderNo && x.PalletCode == palletCode)
+ .ToListAsync();
+
+ // 妫�鏌ラ攣瀹氳褰曠姸鎬佸垎甯�
+ var statusGroups = lockInfos.GroupBy(x => x.Status)
+ .Select(g => new { Status = g.Key, Count = g.Count() })
+ .ToList();
+
+ foreach (var group in statusGroups)
+ {
+ _logger.LogInformation($"{phase}閿佸畾鐘舵�� {GetLockStatusName(group.Status)}: {group.Count} 鏉�");
+ }
+
+ // 3. 鍩烘湰楠岃瘉
+ bool isValid = true;
+
+ // 楠岃瘉1: 濡傛灉閿佸畾璁板綍鐘舵�佷负"鎷ｉ�夊畬鎴�"锛屽搴斿簱瀛樺簲璇ヤ负0
+ var completedLocks = lockInfos.Where(x => x.Status == (int)OutLockStockStatusEnum.鎷ｉ�夊畬鎴�).ToList();
+ foreach (var lockInfo in completedLocks)
+ {
+ if (!string.IsNullOrEmpty(lockInfo.CurrentBarcode))
+ {
+ var stock = stockDetails.FirstOrDefault(x => x.Barcode == lockInfo.CurrentBarcode);
+ if (stock != null && stock.StockQuantity > 0)
+ {
+ _logger.LogWarning($"{phase}楠岃瘉璀﹀憡 - 閿佸畾ID {lockInfo.Id} 鎷ｉ�夊畬鎴愪絾搴撳瓨涓嶄负0: {stock.StockQuantity}");
+ }
+ }
+ }
+
+ // 楠岃瘉2: 搴撳瓨鐘舵�佷竴鑷存��
+ foreach (var stock in stockDetails)
+ {
+ if (stock.Status == (int)StockStatusEmun.鍑哄簱閿佸畾 && stock.StockQuantity == 0)
+ {
+ _logger.LogWarning($"{phase}楠岃瘉璀﹀憡 - 鏉＄爜 {stock.Barcode} 鐘舵�佷负鍑哄簱閿佸畾浣嗗簱瀛樹负0");
+ }
+ }
+
+ _logger.LogInformation($"銆恵phase}鏁版嵁楠岃瘉銆戝畬鎴� - 鐘舵��: {(isValid ? "閫氳繃" : "鏈夎鍛�")}");
+ return isValid;
+ }
+ catch (Exception ex)
+ {
+ _logger.LogError($"{phase} 鏁版嵁楠岃瘉澶辫触: {ex.Message}");
+ return false;
+ }
+ }
+
+ private string GetLockStatusName(int status)
+ {
+ return status switch
+ {
+ 1 => "鍑哄簱涓�",
+ 2 => "鎷ｉ�夊畬鎴�",
+ 3 => "宸插洖搴�",
+ 4 => "宸插彇璧�",
+ _ => $"鏈煡({status})"
+ };
+ }
+ /// <summary>
+ /// 绠�鍖栧洖搴撴暟鎹搷浣滐紙褰撲富鏂规硶澶辫触鏃朵娇鐢級
+ /// </summary>
+ private async Task ExecuteSimpleReturnDataOperations(PalletStatusAnalysis statusAnalysis)
+ {
+ _logger.LogInformation($"銆愮畝鍖栧洖搴撱�戝紑濮嬫墽琛岀畝鍖栧洖搴撴搷浣�");
+
+ try
+ {
+ // 鑾峰彇璇ユ墭鐩樼殑鎵�鏈夋潯鐮�
+ var allStockDetails = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
+ .Where(x => x.StockId == statusAnalysis.StockId && x.StockQuantity > 0)
+ .ToListAsync();
+
+ _logger.LogInformation($"鎵惧埌 {allStockDetails.Count} 涓湁搴撳瓨鐨勬潯鐮�");
+
+ foreach (var stockDetail in allStockDetails)
+ {
+ // 鎭㈠鎵�鏈夊簱瀛樼姸鎬佷负鍏ュ簱瀹屾垚
+ if (stockDetail.Status == (int)StockStatusEmun.鍑哄簱閿佸畾)
+ {
+ stockDetail.Status = (int)StockStatusEmun.鍏ュ簱瀹屾垚;
+
+ await _stockInfoDetailService.Db.Updateable(stockDetail).ExecuteCommandAsync();
+ _logger.LogInformation($"绠�鍖栧洖搴� - 鏉＄爜: {stockDetail.Barcode}, 鏁伴噺: {stockDetail.StockQuantity}");
+ }
+ }
+
+ // 鏇存柊鎵�鏈夐攣瀹氳褰曚负宸插洖搴�
+ var allLocks = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
+ .Where(x => x.OrderNo == statusAnalysis.OrderNo &&
+ x.PalletCode == statusAnalysis.PalletCode &&
+ (x.Status == (int)OutLockStockStatusEnum.鍑哄簱涓� ||
+ x.Status == (int)OutLockStockStatusEnum.鎷ｉ�夊畬鎴�))
+ .ToListAsync();
+
+ foreach (var lockInfo in allLocks)
+ {
+ lockInfo.Status = (int)OutLockStockStatusEnum.宸插洖搴�;
+ lockInfo.Operator = App.User.UserName;
+
+ await _outStockLockInfoService.Db.Updateable(lockInfo).ExecuteCommandAsync();
+ _logger.LogInformation($"绠�鍖栧洖搴� - 閿佸畾璁板綍: {lockInfo.Id}");
+ }
+
+ _logger.LogInformation($"銆愮畝鍖栧洖搴撱�戝畬鎴� - 澶勭悊 {allStockDetails.Count} 涓潯鐮�, {allLocks.Count} 鏉￠攣瀹氳褰�");
+ }
+ catch (Exception ex)
+ {
+ _logger.LogError($"绠�鍖栧洖搴撳け璐�: {ex.Message}");
+ throw;
+ }
+ }
+ /// <summary>
+ /// 鎵ц鍥炲簱鏁版嵁鎿嶄綔 - 绠�鍖栫増鏈�
+ /// </summary>
+ private async Task ExecuteReturnDataOperations(PalletStatusAnalysis statusAnalysis)
+ {
+ _logger.LogInformation($"寮�濮嬫墽琛屽洖搴撴暟鎹搷浣� - 璁㈠崟: {statusAnalysis.OrderNo}, 鎵樼洏: {statusAnalysis.PalletCode}");
+
+ try
+ {
+ // 浣跨敤 HashSet 閬垮厤閲嶅澶勭悊鏉＄爜
+ var processedBarcodes = new HashSet<string>();
+ decimal totalReturnedQty = 0;
+
+ // 1. 澶勭悊宸插垎閰嶇殑鏈垎鎷ｉ攣瀹氳褰�
+ if (statusAnalysis.HasRemainingLocks)
+ {
+ _logger.LogInformation($"澶勭悊 {statusAnalysis.RemainingLocks.Count} 鏉″凡鍒嗛厤鏈垎鎷ｉ攣瀹氳褰�");
+
+ foreach (var lockInfo in statusAnalysis.RemainingLocks)
+ {
+ if (string.IsNullOrEmpty(lockInfo.CurrentBarcode) || processedBarcodes.Contains(lockInfo.CurrentBarcode))
+ {
+ _logger.LogInformation($"璺宠繃閲嶅鎴栫┖鏉＄爜鐨勯攣瀹氳褰� - ID: {lockInfo.Id}");
+ continue;
+ }
+
+ // 璁＄畻鍥炲簱鏁伴噺锛堟湭鎷ｉ�夌殑閮ㄥ垎锛�
+ decimal returnQty = lockInfo.AssignQuantity - lockInfo.PickedQty;
+
+ if (returnQty > 0)
+ {
+ _logger.LogInformation($"澶勭悊閿佸畾璁板綍鍥炲簱 - ID: {lockInfo.Id}, 鏉＄爜: {lockInfo.CurrentBarcode}, 鍥炲簱鏁伴噺: {returnQty}");
+
+ // 澶勭悊搴撳瓨
+ await ProcessStockForReturn(lockInfo.CurrentBarcode, statusAnalysis.StockId, returnQty);
+
+ // 鏍囪涓哄凡鍥炲簱
+ lockInfo.Status = (int)OutLockStockStatusEnum.宸插洖搴�;
+ lockInfo.Operator = App.User.UserName;
+
+
+ await _outStockLockInfoService.Db.Updateable(lockInfo).ExecuteCommandAsync();
+
+ // 鍑忓皯璁㈠崟鏄庣粏鐨勫垎閰嶆暟閲�
+ if (lockInfo.OrderDetailId > 0)
+ {
+ var orderDetail = await _outboundOrderDetailService.Db.Queryable<Dt_OutboundOrderDetail>().FirstAsync(x => x.Id == lockInfo.OrderDetailId);
+ await ReduceOrderDetailAllocation(orderDetail, returnQty);
+ }
+
+ processedBarcodes.Add(lockInfo.CurrentBarcode);
+ totalReturnedQty += returnQty;
+
+ _logger.LogInformation($"閿佸畾璁板綍鍥炲簱瀹屾垚 - ID: {lockInfo.Id}, 鍥炲簱鏁伴噺: {returnQty}");
+ }
+ else
+ {
+ _logger.LogInformation($"閿佸畾璁板綍鏃犻渶鍥炲簱 - ID: {lockInfo.Id}, 宸叉嫞閫夊畬鎴�");
+ }
+ }
+ }
+
+ // 2. 澶勭悊鏈垎閰嶇殑搴撳瓨璐х墿
+ if (statusAnalysis.HasPalletStockGoods)
+ {
+ _logger.LogInformation($"澶勭悊 {statusAnalysis.PalletStockGoods.Count} 涓湭鍒嗛厤搴撳瓨璐х墿");
+
+ foreach (var stockDetail in statusAnalysis.PalletStockGoods)
+ {
+ if (string.IsNullOrEmpty(stockDetail.Barcode) || processedBarcodes.Contains(stockDetail.Barcode))
+ {
+ _logger.LogInformation($"璺宠繃閲嶅鎴栫┖鏉＄爜鐨勫簱瀛� - 搴撳瓨ID: {stockDetail.Id}");
+ continue;
+ }
+
+ if (stockDetail.StockQuantity > 0)
+ {
+ decimal returnQty = stockDetail.StockQuantity;
+ _logger.LogInformation($"澶勭悊鏈垎閰嶅簱瀛樺洖搴� - 鏉＄爜: {stockDetail.Barcode}, 鍥炲簱鏁伴噺: {returnQty}");
+
+ // 鐩存帴鎭㈠搴撳瓨鐘舵��
+ stockDetail.Status = (int)StockStatusEmun.鍏ュ簱瀹屾垚;
+
+ await _stockInfoDetailService.Db.Updateable(stockDetail).ExecuteCommandAsync();
+
+ processedBarcodes.Add(stockDetail.Barcode);
+ totalReturnedQty += returnQty;
+
+ _logger.LogInformation($"鏈垎閰嶅簱瀛樺洖搴撳畬鎴� - 鏉＄爜: {stockDetail.Barcode}, 鏁伴噺: {returnQty}");
+ }
+ }
+ }
+
+ // 3. 澶勭悊鎷嗗寘璁板綍鐩稿叧鐨勬潯鐮�
+ if (statusAnalysis.HasSplitRecords)
+ {
+ _logger.LogInformation($"澶勭悊 {statusAnalysis.SplitRecords.Count} 鏉℃媶鍖呰褰�");
+
+ // 鏀堕泦鎷嗗寘鐩稿叧鐨勬墍鏈夋潯鐮�
+ var splitBarcodes = new List<string>();
+ foreach (var splitRecord in statusAnalysis.SplitRecords)
+ {
+ if (!string.IsNullOrEmpty(splitRecord.OriginalBarcode))
+ splitBarcodes.Add(splitRecord.OriginalBarcode);
+ if (!string.IsNullOrEmpty(splitRecord.NewBarcode))
+ splitBarcodes.Add(splitRecord.NewBarcode);
+ }
+
+ // 鍘婚噸
+ splitBarcodes = splitBarcodes.Distinct().ToList();
+
+ foreach (var barcode in splitBarcodes)
+ {
+ if (processedBarcodes.Contains(barcode))
+ {
+ _logger.LogInformation($"鎷嗗寘鏉＄爜宸插鐞�: {barcode}");
+ continue;
+ }
+
+ // 鏌ユ壘搴撳瓨
+ var stockDetail = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
+ .FirstAsync(x => x.Barcode == barcode && x.StockId == statusAnalysis.StockId);
+
+ if (stockDetail != null && stockDetail.StockQuantity > 0)
+ {
+ decimal returnQty = stockDetail.StockQuantity;
+ _logger.LogInformation($"澶勭悊鎷嗗寘鐩稿叧搴撳瓨鍥炲簱 - 鏉＄爜: {barcode}, 鍥炲簱鏁伴噺: {returnQty}");
+
+ // 鎭㈠搴撳瓨鐘舵��
+ if (stockDetail.Status == (int)StockStatusEmun.鍑哄簱閿佸畾)
+ {
+ stockDetail.Status = (int)StockStatusEmun.鍏ュ簱瀹屾垚;
+
+ await _stockInfoDetailService.Db.Updateable(stockDetail).ExecuteCommandAsync();
+
+ processedBarcodes.Add(barcode);
+ totalReturnedQty += returnQty;
+
+ _logger.LogInformation($"鎷嗗寘搴撳瓨鍥炲簱瀹屾垚 - 鏉＄爜: {barcode}, 鏁伴噺: {returnQty}");
+ }
+ }
+ }
+ }
+
+ _logger.LogInformation($"鍥炲簱鏁版嵁鎿嶄綔瀹屾垚 - 鎬诲洖搴撴暟閲�: {totalReturnedQty}, 澶勭悊鏉＄爜鏁�: {processedBarcodes.Count}");
+ }
+ catch (Exception ex)
+ {
+ _logger.LogError($"鍥炲簱鏁版嵁鎿嶄綔澶辫触 - 璁㈠崟: {statusAnalysis.OrderNo}, 鎵樼洏: {statusAnalysis.PalletCode}, Error: {ex.Message}");
+ throw;
+ }
+ }
+ /// <summary>
+ /// 澶勭悊搴撳瓨鍥炲簱 - 绠�鍖栭�昏緫
+ /// </summary>
+ private async Task ProcessStockForReturn(string barcode, int stockId, decimal returnQty)
+ {
+ try
+ {
+ var stockDetail = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
+ .FirstAsync(x => x.Barcode == barcode && x.StockId == stockId);
+
+ if (stockDetail == null)
+ {
+ _logger.LogWarning($"鏈壘鍒板簱瀛樻槑缁� - 鏉＄爜: {barcode}");
+ return;
+ }
+
+ // 璁板綍鍘熷鍊�
+ decimal originalStockQty = stockDetail.StockQuantity;
+ decimal originalOutboundQty = stockDetail.OutboundQuantity;
+ int originalStatus = stockDetail.Status;
+
+ // 绠�鍖栧鐞嗭細濡傛灉搴撳瓨鏁伴噺澶т簬0锛屾仮澶嶄负鍏ュ簱瀹屾垚鐘舵��
+ if (stockDetail.StockQuantity > 0)
+ {
+ stockDetail.Status = (int)StockStatusEmun.鍏ュ簱瀹屾垚;
+ }
+
+ // 璋冩暣鍑哄簱鏁伴噺锛堥伩鍏嶅嚭鐜拌礋鏁帮級
+ if (stockDetail.OutboundQuantity > 0)
+ {
+ stockDetail.OutboundQuantity = Math.Max(0, stockDetail.OutboundQuantity - returnQty);
+ }
+ await _stockInfoDetailService.Db.Updateable(stockDetail).ExecuteCommandAsync();
+
+ _logger.LogInformation($"搴撳瓨鍥炲簱澶勭悊 - 鏉＄爜: {barcode}, 鐘舵��: {originalStatus} -> {stockDetail.Status}, " +
+ $"搴撳瓨: {originalStockQty} -> {stockDetail.StockQuantity}, " +
+ $"鍑哄簱: {originalOutboundQty} -> {stockDetail.OutboundQuantity}");
+ }
+ catch (Exception ex)
+ {
+ _logger.LogError($"澶勭悊搴撳瓨鍥炲簱澶辫触 - 鏉＄爜: {barcode}, Error: {ex.Message}");
+ throw;
+ }
+ }
+ /// <summary>
+ /// 涓洪攣瀹氳褰曞噺灏戣鍗曟槑缁嗙殑鍒嗛厤鏁伴噺
+ /// </summary>
+ private async Task ReduceOrderDetailAllocationForLock(long orderDetailId, decimal reduceQty)
+ {
+ if (orderDetailId <= 0)
+ return;
+
+ var orderDetail = await _outboundOrderDetailService.Db.Queryable<Dt_OutboundOrderDetail>()
+ .FirstAsync(x => x.Id == orderDetailId);
+
+ if (orderDetail == null)
+ return;
+
+ decimal originalAllocated = orderDetail.AllocatedQuantity;
+ decimal originalLock = orderDetail.LockQuantity;
+
+ // 楠岃瘉鍑忓皯鏁伴噺涓嶄細瀵艰嚧璐熸暟
+ if (orderDetail.AllocatedQuantity < reduceQty)
+ {
+ _logger.LogWarning($"鍒嗛厤鏁伴噺涓嶈冻锛岃皟鏁村噺灏戞暟閲� - 鍘熻鍒掑噺灏�: {reduceQty}, 瀹為檯鍙敤: {orderDetail.AllocatedQuantity}");
+ reduceQty = orderDetail.AllocatedQuantity;
+ }
+
+ // 鍑忓皯鍒嗛厤鏁伴噺鍜岄攣瀹氭暟閲�
+ orderDetail.AllocatedQuantity -= reduceQty;
+ orderDetail.LockQuantity -= reduceQty;
+
+ // 纭繚鏁伴噺涓嶄細涓鸿礋鏁�
+ if (orderDetail.AllocatedQuantity < 0)
+ {
+ _logger.LogWarning($"鍒嗛厤鏁伴噺鍑虹幇璐熸暟锛岄噸缃负0銆傚師鍊�: {orderDetail.AllocatedQuantity + reduceQty}, 鍑忓皯: {reduceQty}");
+ orderDetail.AllocatedQuantity = 0;
+ }
+
+ if (orderDetail.LockQuantity < 0)
+ {
+ _logger.LogWarning($"閿佸畾鏁伴噺鍑虹幇璐熸暟锛岄噸缃负0銆傚師鍊�: {orderDetail.LockQuantity + reduceQty}, 鍑忓皯: {reduceQty}");
+ orderDetail.LockQuantity = 0;
+ }
+
+ // 鏇存柊鎵规鍒嗛厤鐘舵��
+ await UpdateBatchAllocateStatus(orderDetail);
+
+ await _outboundOrderDetailService.Db.Updateable(orderDetail).ExecuteCommandAsync();
+
+ _logger.LogInformation($"鍑忓皯璁㈠崟鏄庣粏鍒嗛厤 - OrderDetailId: {orderDetail.Id}, " +
+ $"鍒嗛厤鏁伴噺: {originalAllocated} -> {orderDetail.AllocatedQuantity}, " +
+ $"閿佸畾鏁伴噺: {originalLock} -> {orderDetail.LockQuantity}, " +
+ $"鍑忓皯鏁伴噺: {reduceQty}");
+ }
+
+ /// <summary>
+ /// 澶勭悊鏈垎閰嶇殑閿佸畾璁板綍鍥炲簱
+ /// 涓嶉渶瑕佸噺灏戣鍗曟槑缁嗙殑鍒嗛厤鏁伴噺
+ /// </summary>
+ private async Task HandleUnallocatedLocksReturn(List<Dt_OutStockLockInfo> unallocatedLocks)
+ {
+ _logger.LogInformation($"寮�濮嬪鐞嗘湭鍒嗛厤閿佸畾璁板綍鍥炲簱 - 鍏� {unallocatedLocks.Count} 鏉¤褰�");
+
+ foreach (var lockInfo in unallocatedLocks)
+ {
+ // 璁＄畻鍥炲簱鏁伴噺锛堟湭鎷ｉ�夌殑閮ㄥ垎锛�
+ decimal returnQty = lockInfo.AssignQuantity - lockInfo.PickedQty;
+
+ if (returnQty <= 0)
+ {
+ _logger.LogInformation($"璺宠繃鏈垎閰嶉攣瀹氳褰� - 閿佸畾ID: {lockInfo.Id}, 宸叉嫞閫夊畬鎴愭垨鏃犻渶鍥炲簱");
+ continue;
+ }
+
+ _logger.LogInformation($"澶勭悊鏈垎閰嶉攣瀹氳褰曞洖搴� - 閿佸畾ID: {lockInfo.Id}, 鏉＄爜: {lockInfo.CurrentBarcode}, 鍥炲簱鏁伴噺: {returnQty}");
+
+ // 鎭㈠搴撳瓨鐘舵��
+ var stockDetail = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
+ .FirstAsync(x => x.Barcode == lockInfo.CurrentBarcode && x.StockId == lockInfo.StockId);
+
+ if (stockDetail != null)
+ {
+ // 鎭㈠搴撳瓨鏁伴噺
+ decimal originalStockQty = stockDetail.StockQuantity;
+ stockDetail.StockQuantity += returnQty;
+
+ // 鎭㈠搴撳瓨鐘舵��
+ if (stockDetail.Status == (int)StockStatusEmun.鍑哄簱瀹屾垚)
+ {
+ stockDetail.Status = (int)StockStatusEmun.鍏ュ簱瀹屾垚;
+ }
+ else if (stockDetail.Status == (int)StockStatusEmun.鍑哄簱閿佸畾)
+ {
+ stockDetail.Status = (int)StockStatusEmun.鍏ュ簱瀹屾垚;
+ }
+
+ await _stockInfoDetailService.Db.Updateable(stockDetail).ExecuteCommandAsync();
+ _logger.LogInformation($"鎭㈠搴撳瓨 - 鏉＄爜: {stockDetail.Barcode}, 搴撳瓨鏁伴噺: {originalStockQty} -> {stockDetail.StockQuantity}");
+ }
+
+ // 鏇存柊閿佸畾璁板綍鐘舵�佷负宸插洖搴�
+ lockInfo.Status = (int)OutLockStockStatusEnum.宸插洖搴�;
+ lockInfo.Operator = App.User.UserName;
+
+ await _outStockLockInfoService.Db.Updateable(lockInfo).ExecuteCommandAsync();
+
+ _logger.LogInformation($"鏇存柊鏈垎閰嶉攣瀹氱姸鎬� - 閿佸畾ID: {lockInfo.Id}, 鐘舵��: 鍑哄簱涓� -> 宸插洖搴�");
+ }
+
+ _logger.LogInformation($"鏈垎閰嶉攣瀹氳褰曞洖搴撳鐞嗗畬鎴� - 鍏卞鐞� {unallocatedLocks.Count} 鏉¤褰�");
+ }
+
+ private async Task HandleAllocatedLocksReturn(List<Dt_OutStockLockInfo> allocatedLocks)
+ {
+ _logger.LogInformation($"寮�濮嬪鐞嗗凡鍒嗛厤閿佸畾璁板綍鍥炲簱 - 鍏� {allocatedLocks.Count} 鏉¤褰�");
+
+ // 鎸夎鍗曟槑缁嗗垎缁勫鐞�
+ var orderDetailGroups = allocatedLocks.GroupBy(x => x.OrderDetailId);
+
+ foreach (var group in orderDetailGroups)
+ {
+ var orderDetailId = group.Key;
+ var groupLocks = group.ToList();
+
+ _logger.LogInformation($"澶勭悊璁㈠崟鏄庣粏 {orderDetailId} 鐨� {groupLocks.Count} 鏉￠攣瀹氳褰�");
+
+ // 鑾峰彇璁㈠崟鏄庣粏
+ var orderDetail = await _outboundOrderDetailService.Db.Queryable<Dt_OutboundOrderDetail>()
+ .FirstAsync(x => x.Id == orderDetailId);
+
+ if (orderDetail == null)
+ {
+ _logger.LogWarning($"鏈壘鍒拌鍗曟槑缁� - OrderDetailId: {orderDetailId}");
+ continue;
+ }
+
+ decimal totalReturnQtyForDetail = 0;
+
+ foreach (var lockInfo in groupLocks)
+ {
+ // 璁＄畻鍥炲簱鏁伴噺锛堟湭鎷ｉ�夌殑閮ㄥ垎锛�
+ decimal returnQty = lockInfo.AssignQuantity - lockInfo.PickedQty;
+
+ if (returnQty <= 0)
+ {
+ _logger.LogInformation($"璺宠繃閿佸畾璁板綍 - 閿佸畾ID: {lockInfo.Id}, 宸叉嫞閫夊畬鎴愭垨鏃犻渶鍥炲簱");
+ continue;
+ }
+
+ _logger.LogInformation($"澶勭悊宸插垎閰嶉攣瀹氳褰曞洖搴� - 閿佸畾ID: {lockInfo.Id}, 鏉＄爜: {lockInfo.CurrentBarcode}, 鍥炲簱鏁伴噺: {returnQty}");
+
+ // 鎭㈠搴撳瓨鐘舵��
+ await RestoreStockForLockInfo(lockInfo, returnQty);
+
+ // 鏇存柊閿佸畾璁板綍鐘舵�佷负宸插洖搴�
+ lockInfo.Status = (int)OutLockStockStatusEnum.宸插洖搴�;
+ lockInfo.Operator = App.User.UserName;
+
+ await _outStockLockInfoService.Db.Updateable(lockInfo).ExecuteCommandAsync();
+
+ _logger.LogInformation($"鏇存柊宸插垎閰嶉攣瀹氱姸鎬� - 閿佸畾ID: {lockInfo.Id}, 鐘舵��: 鍑哄簱涓� -> 宸插洖搴�");
+
+ totalReturnQtyForDetail += returnQty;
+ }
+
+ // 鍑忓皯璁㈠崟鏄庣粏鐨勫垎閰嶆暟閲�
+ if (totalReturnQtyForDetail > 0)
+ {
+ await ReduceOrderDetailAllocation(orderDetail, totalReturnQtyForDetail);
+ }
+ }
+
+ _logger.LogInformation($"宸插垎閰嶉攣瀹氳褰曞洖搴撳鐞嗗畬鎴� - 鍏卞鐞� {allocatedLocks.Count} 鏉¤褰�");
+ }
+ /// <summary>
+ /// 鎭㈠閿佸畾璁板綍瀵瑰簲鐨勫簱瀛�
+ /// </summary>
+ private async Task RestoreStockForLockInfo(Dt_OutStockLockInfo lockInfo, decimal returnQty)
+ {
+ var stockDetail = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
+ .FirstAsync(x => x.Barcode == lockInfo.CurrentBarcode && x.StockId == lockInfo.StockId);
+
+ if (stockDetail != null)
+ {
+ // 璁板綍鎭㈠鍓嶇殑搴撳瓨鐘舵��
+ decimal originalStockQty = stockDetail.StockQuantity;
+ decimal originalOutboundQty = stockDetail.OutboundQuantity;
+
+ // 鎭㈠搴撳瓨鏁伴噺锛氬嚭搴撴暟閲忓噺灏戯紝搴撳瓨鏁伴噺澧炲姞
+ stockDetail.OutboundQuantity -= returnQty;
+ stockDetail.StockQuantity += returnQty;
+
+ // 纭繚鏁伴噺涓嶄細涓鸿礋鏁�
+ if (stockDetail.OutboundQuantity < 0)
+ {
+ _logger.LogWarning($"鍑哄簱鏁伴噺鍑虹幇璐熸暟锛岄噸缃负0銆傚師鍊�: {stockDetail.OutboundQuantity + returnQty}");
+ stockDetail.OutboundQuantity = 0;
+ }
+
+ // 鎭㈠搴撳瓨鐘舵�佷负鍙敤鐘舵��
+ if (stockDetail.Status == (int)StockStatusEmun.鍑哄簱閿佸畾)
+ {
+ stockDetail.Status = (int)StockStatusEmun.鍏ュ簱瀹屾垚;
+ _logger.LogInformation($"搴撳瓨鐘舵�佹洿鏂颁负鍏ュ簱瀹屾垚 - 鏉＄爜: {stockDetail.Barcode}");
+ }
+
+ await _stockInfoDetailService.Db.Updateable(stockDetail).ExecuteCommandAsync();
+
+ _logger.LogInformation($"鎭㈠搴撳瓨鐘舵�� - 鏉＄爜: {stockDetail.Barcode}, " +
+ $"搴撳瓨鏁伴噺: {originalStockQty} -> {stockDetail.StockQuantity}, " +
+ $"鍑哄簱鏁伴噺: {originalOutboundQty} -> {stockDetail.OutboundQuantity}");
+ }
+ else
+ {
+ _logger.LogWarning($"鏈壘鍒板搴旂殑搴撳瓨淇℃伅 - 鏉＄爜: {lockInfo.CurrentBarcode}, StockId: {lockInfo.StockId}");
+ }
+ }
+ /// <summary>
+ /// 鍒涘缓鍥炲簱浠诲姟
+ /// </summary>
+ private async Task CreateReturnTask(string orderNo, string palletCode, Dt_StockInfo stockInfo)
+ {
+ // 鑾峰彇褰撳墠浠诲姟淇℃伅
+ var currentTask = await _taskRepository.Db.Queryable<Dt_Task>()
+ .Where(x => x.OrderNo == orderNo && x.PalletCode == palletCode)
+ .FirstAsync();
+
+ if (currentTask != null)
+ {
+ // 鍒嗛厤鏂拌揣浣�
+ var newLocation = _locationInfoService.AssignLocation(stockInfo.LocationType);
+
+ var returnTask = new Dt_Task()
+ {
+ CurrentAddress = stations[currentTask.TargetAddress],
+ Grade = 0,
+ PalletCode = palletCode,
+ NextAddress = "",
+ OrderNo = orderNo,
+ Roadway = newLocation.RoadwayNo,
+ SourceAddress = stations[currentTask.TargetAddress],
+ TargetAddress = newLocation.LocationCode,
+ TaskStatus = TaskStatusEnum.New.ObjToInt(),
+ TaskType = TaskTypeEnum.InPick.ObjToInt(),
+ PalletType = stockInfo.PalletType,
+ WarehouseId = currentTask.WarehouseId
+ };
+ var targetAddress = currentTask.TargetAddress;
+
+ try
+ {
+ await _taskRepository.Db.Insertable(returnTask).ExecuteCommandAsync();
+
+ _logger.LogInformation($"CreateReturnTaskAndHandleESS 鍒嗘壒鍒犻櫎鍘嗗彶浠诲姟: {orderNo} 锛� {currentTask.TaskNum}");
+ // 鍒犻櫎鍘熷鍑哄簱浠诲姟
+ //_taskRepository.DeleteAndMoveIntoHty(originalTask, OperateTypeEnum.鑷姩瀹屾垚);
+ var result = _task_HtyService.DeleteAndMoveIntoHty(currentTask, OperateTypeEnum.浜哄伐鍒犻櫎);
+ await _taskRepository.Db.Deleteable(currentTask).ExecuteCommandAsync();
+
+ if (!result)
+ {
+ await _taskRepository.Db.Deleteable(currentTask).ExecuteCommandAsync();
+ }
+ _logger.LogInformation($"CreateReturnTaskAndHandleESS 鍒嗘壒鍒犻櫎鍘嗗彶浠诲姟: {orderNo} 锛� {currentTask.TaskNum},褰卞搷琛� {result}");
+
+ }
+ catch (Exception ex)
+ {
+ _logger.LogInformation($"鍒涘缓鍥炲簱浠诲姟澶辫触 - 璁㈠崟: {orderNo}, 鎵樼洏: {palletCode}");
+ throw new Exception($"鍒涘缓鍥炲簱浠诲姟澶辫触 - 璁㈠崟: {orderNo}, 鎵樼洏: {palletCode}");
+
+ }
+ // 鍙戦�丒SS鍛戒护
+ await SendESSCommands(palletCode, targetAddress, returnTask);
+
+ _logger.LogInformation($"鍒涘缓鍥炲簱浠诲姟鎴愬姛 - 璁㈠崟: {orderNo}, 鎵樼洏: {palletCode}");
+ }
+ }
+ /// <summary>
+ /// 鏇存柊鍥炲簱鍚庣殑璁㈠崟鐘舵��
+ /// </summary>
+ private async Task UpdateOrderStatusAfterReturn(string orderNo)
+ {
+ // 妫�鏌ヨ鍗曟槸鍚﹁繕鏈夋湭瀹屾垚鐨勯攣瀹氳褰�
+ var activeLocks = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
+ .Where(x => x.OrderNo == orderNo &&
+ (x.Status == (int)OutLockStockStatusEnum.鍑哄簱涓� ||
+ x.Status == (int)OutLockStockStatusEnum.鍥炲簱涓�))
+ .ToListAsync();
+
+ if (!activeLocks.Any())
+ {
+ // 鎵�鏈夐攣瀹氳褰曢兘宸插畬鎴愭垨宸插洖搴擄紝鏇存柊璁㈠崟鐘舵��
+ await _outboundOrderService.Db.Updateable<Dt_OutboundOrder>()
+ .SetColumns(x => new Dt_OutboundOrder
+ {
+ OrderStatus = (int)OutOrderStatusEnum.鍑哄簱瀹屾垚,
+ })
+ .Where(x => x.OrderNo == orderNo)
+ .ExecuteCommandAsync();
+
+ _logger.LogInformation($"鏇存柊璁㈠崟鐘舵�佷负鍑哄簱瀹屾垚 - 璁㈠崟: {orderNo}");
+ }
+ }
+
+ /// <summary>
+ /// 澶勭悊绌烘墭鐩樺洖搴�
+ /// </summary>
+ private async Task<WebResponseContent> HandleEmptyPalletReturn(string orderNo, string palletCode, Dt_StockInfo stockInfo)
+ {
+ _logger.LogInformation($"澶勭悊绌烘墭鐩樺洖搴� - 璁㈠崟: {orderNo}, 鎵樼洏: {palletCode}");
+
+ try
+ {
+ // 娓呯悊闆跺簱瀛樻暟鎹�
+ await CleanupZeroStockData(stockInfo.Id);
+
+ // 鍒涘缓绌烘墭鐩樺簱瀛樿褰�
+ var emptyStockInfo = new Dt_StockInfo()
+ {
+ PalletType = PalletTypeEnum.Empty.ObjToInt(),
+ StockStatus = StockStatusEmun.缁勭洏鏆傚瓨.ObjToInt(),
+ PalletCode = palletCode,
+ LocationType = stockInfo.LocationType
+ };
+ emptyStockInfo.Details = new List<Dt_StockInfoDetail>();
+ _stockInfoService.AddMaterielGroup(emptyStockInfo);
+
+ // 鍒涘缓绌烘墭鐩樺洖搴撲换鍔�
+ await CreateReturnTask(orderNo, palletCode, emptyStockInfo);
+
+ return WebResponseContent.Instance.OK("绌烘墭鐩樺洖搴撴垚鍔�");
+ }
+ catch (Exception ex)
+ {
+ _logger.LogError($"绌烘墭鐩樺洖搴撳け璐�: {ex.Message}");
+ return WebResponseContent.Instance.Error($"绌烘墭鐩樺洖搴撳け璐�: {ex.Message}");
+ }
+ }
+ /// <summary>
+ /// 鍒嗘瀽鎵樼洏鐘舵�佺敤浜庡洖搴�
+ /// 纭繚涓嶄細閿欒璇嗗埆闇�瑕佸洖搴撶殑鐗╁搧
+ /// </summary>
+
+ /// <summary>
+ /// 鍒嗘瀽鎵樼洏鐘舵�佺敤浜庡洖搴� - 瀹屾暣鐗堟湰
+ /// 纭繚涓嶄細閿欒璇嗗埆闇�瑕佸洖搴撶殑鐗╁搧锛岄伩鍏嶉噸澶嶈绠�
+ /// </summary>
+ private async Task<PalletStatusAnalysis> AnalyzePalletStatusForReturn(string orderNo, string palletCode, int stockId)
+ {
+ var result = new PalletStatusAnalysis
+ {
+ OrderNo = orderNo,
+ PalletCode = palletCode,
+ StockId = stockId,
+ AllBarcodes = new List<string>(),
+ RemainingLocks = new List<Dt_OutStockLockInfo>(),
+ UnallocatedLocks = new List<Dt_OutStockLockInfo>(),
+ PalletStockGoods = new List<Dt_StockInfoDetail>(),
+ SplitRecords = new List<Dt_SplitPackageRecord>()
+ };
+
+ _logger.LogInformation($"寮�濮嬪垎鏋愭墭鐩樼姸鎬佺敤浜庡洖搴� - 璁㈠崟: {orderNo}, 鎵樼洏: {palletCode}, StockId: {stockId}");
+
+ try
+ {
+ // 1. 鍒嗘瀽鎵�鏈夐攣瀹氳褰曪紙鐘舵�佷负鍑哄簱涓級
+ var allUnfinishedLocks = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
.Where(x => x.OrderNo == orderNo &&
x.PalletCode == palletCode &&
x.Status == (int)OutLockStockStatusEnum.鍑哄簱涓�)
.ToListAsync();
- if (!unfinishedLocks.Any())
- return WebResponseContent.Instance.Error("璇ユ墭鐩樻病鏈夋湭瀹屾垚鐨勯攣瀹氳褰�");
-
- // 鎸夋壒娆″垎缁勫鐞�
- var batchGroups = unfinishedLocks.GroupBy(x => x.BatchNo);
-
- foreach (var batchGroup in batchGroups)
+ if (allUnfinishedLocks.Any())
{
- var batchNo = batchGroup.Key;
- var batchLocks = batchGroup.ToList();
+ _logger.LogInformation($"鎵惧埌 {allUnfinishedLocks.Count} 鏉″嚭搴撲腑鐘舵�佺殑閿佸畾璁板綍");
- // 閲婃斁搴撳瓨鍜岄攣瀹氳褰�
- foreach (var lockInfo in batchLocks)
+ // 鍖哄垎宸插垎閰嶅拰鏈垎閰嶇殑閿佸畾璁板綍
+ var allocatedLocks = allUnfinishedLocks
+ .Where(x => x.IsUnallocated != 1 && x.OrderDetailId > 0)
+ .ToList();
+
+ var unallocatedLocks = allUnfinishedLocks
+ .Where(x => x.IsUnallocated == 1 || x.OrderDetailId == 0)
+ .ToList();
+
+ // 澶勭悊宸插垎閰嶇殑閿佸畾璁板綍
+ if (allocatedLocks.Any())
{
- await ReleaseLockAndStock(lockInfo);
+ result.HasRemainingLocks = true;
+ result.RemainingLocks = allocatedLocks;
+ result.RemainingLocksReturnQty = allocatedLocks.Sum(x => x.AssignQuantity - x.PickedQty);
+
+ foreach (var lockInfo in allocatedLocks)
+ {
+ if (!string.IsNullOrEmpty(lockInfo.CurrentBarcode))
+ {
+ result.AllBarcodes.Add(lockInfo.CurrentBarcode);
+ }
+ }
+
+ _logger.LogInformation($"鍙戠幇{allocatedLocks.Count}鏉″凡鍒嗛厤鏈垎鎷ｉ攣瀹氳褰曪紝鎬绘暟閲�: {result.RemainingLocksReturnQty}");
}
- // 鏇存柊鎵规鐘舵��
- await UpdateBatchStatusForReturn(batchNo, batchLocks);
+ // 澶勭悊鏈垎閰嶇殑閿佸畾璁板綍锛堝鑷姩鎷嗗寘浜х敓鐨勶級
+ if (unallocatedLocks.Any())
+ {
+ result.HasUnallocatedLocks = true;
+ result.UnallocatedLocks = unallocatedLocks;
+ result.UnallocatedLocksReturnQty = unallocatedLocks.Sum(x => x.AssignQuantity - x.PickedQty);
- // 鏇存柊璁㈠崟鏄庣粏鐨勫凡鍒嗛厤鏁伴噺
- await UpdateOrderDetailAfterReturn(batchLocks);
+ foreach (var lockInfo in unallocatedLocks)
+ {
+ if (!string.IsNullOrEmpty(lockInfo.CurrentBarcode))
+ {
+ result.AllBarcodes.Add(lockInfo.CurrentBarcode);
+ }
+ }
+
+ _logger.LogInformation($"鍙戠幇{unallocatedLocks.Count}鏉℃湭鍒嗛厤閿佸畾璁板綍锛屾�绘暟閲�: {result.UnallocatedLocksReturnQty}");
+ }
}
+ else
+ {
+ _logger.LogInformation($"鏈壘鍒板嚭搴撲腑鐘舵�佺殑閿佸畾璁板綍");
+ }
+
+ // 2. 鍒嗘瀽鎵樼洏涓婄殑鍓╀綑搴撳瓨璐х墿锛堢姸鎬佷负鍑哄簱閿佸畾浣嗘湭鍒嗛厤锛�
+ var allStockDetails = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
+ .Where(x => x.StockId == stockId &&
+ x.Status == (int)StockStatusEmun.鍑哄簱閿佸畾 &&
+ x.StockQuantity > 0)
+ .ToListAsync();
+
+ if (allStockDetails.Any())
+ {
+ _logger.LogInformation($"鎵惧埌 {allStockDetails.Count} 涓嚭搴撻攣瀹氱姸鎬佺殑搴撳瓨璐х墿");
+
+ // 杩囨护鎺夊凡缁忚閿佸畾璁板綍鍗犵敤鐨勫簱瀛�
+ var lockedBarcodes = allUnfinishedLocks.Select(x => x.CurrentBarcode).Where(b => !string.IsNullOrEmpty(b)).ToList();
+ var unlockedStockGoods = allStockDetails
+ .Where(x => !lockedBarcodes.Contains(x.Barcode))
+ .ToList();
+
+ _logger.LogInformation($"杩囨护鍚庡墿浣� {unlockedStockGoods.Count} 涓湭琚攣瀹氱殑搴撳瓨璐х墿");
+
+ // 杩涗竴姝ヨ繃婊わ細妫�鏌ヨ繖浜涘簱瀛樻槸鍚︽湁鍏宠仈鐨勯攣瀹氳褰曪紙鍖呮嫭鐘舵�佷笉鏄嚭搴撲腑鐨勶級
+ var trulyUnallocatedGoods = new List<Dt_StockInfoDetail>();
+ foreach (var stock in unlockedStockGoods)
+ {
+ var hasActiveLock = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
+ .Where(x => x.CurrentBarcode == stock.Barcode &&
+ (x.Status == (int)OutLockStockStatusEnum.鍑哄簱涓� ||
+ x.Status == (int)OutLockStockStatusEnum.鎷ｉ�夊畬鎴�))
+ .AnyAsync();
+
+ if (!hasActiveLock)
+ {
+ trulyUnallocatedGoods.Add(stock);
+ }
+ else
+ {
+ _logger.LogInformation($"鏉＄爜 {stock.Barcode} 鏈夋椿璺冪殑閿佸畾璁板綍锛岃烦杩囦綔涓烘湭鍒嗛厤搴撳瓨");
+ }
+ }
+
+ if (trulyUnallocatedGoods.Any())
+ {
+ result.HasPalletStockGoods = true;
+ result.PalletStockGoods = trulyUnallocatedGoods;
+ result.PalletStockReturnQty = trulyUnallocatedGoods.Sum(x => x.StockQuantity);
+
+ foreach (var stock in trulyUnallocatedGoods)
+ {
+ result.AllBarcodes.Add(stock.Barcode);
+ }
+
+ _logger.LogInformation($"鍙戠幇{trulyUnallocatedGoods.Count}涓湡姝ｆ湭鍒嗛厤搴撳瓨璐х墿锛屾�绘暟閲�: {result.PalletStockReturnQty}");
+
+ // 璁板綍姣忎釜璐х墿鐨勮缁嗕俊鎭�
+ foreach (var stock in trulyUnallocatedGoods)
+ {
+ _logger.LogInformation($"鏈垎閰嶅簱瀛� - 鏉＄爜: {stock.Barcode}, 鐗╂枡: {stock.MaterielCode}, 鏁伴噺: {stock.StockQuantity}");
+ }
+ }
+ }
+ else
+ {
+ _logger.LogInformation($"鏈壘鍒板嚭搴撻攣瀹氱姸鎬佺殑搴撳瓨璐х墿");
+ }
+
+ // 3. 鍒嗘瀽鎷嗗寘璁板綍锛堢姸鎬佷笉鏄凡鎷ｉ�夊拰宸插洖搴撶殑锛�
+ var splitRecords = await _splitPackageService.Db.Queryable<Dt_SplitPackageRecord>()
+ .Where(x => x.OrderNo == orderNo &&
+ x.PalletCode == palletCode &&
+ !x.IsReverted &&
+ x.Status != (int)SplitPackageStatusEnum.宸叉嫞閫� &&
+ x.Status != (int)SplitPackageStatusEnum.宸插洖搴�)
+ .ToListAsync();
+
+ if (splitRecords.Any())
+ {
+ result.HasSplitRecords = true;
+ result.SplitRecords = splitRecords;
+
+ // 璁＄畻鎷嗗寘璁板綍鐩稿叧鐨勫洖搴撴暟閲忥紙閬垮厤閲嶅璁＄畻锛�
+ var splitBarcodes = new HashSet<string>();
+ decimal splitReturnQty = 0;
+
+ foreach (var splitRecord in splitRecords)
+ {
+ // 鍘熸潯鐮�
+ if (!string.IsNullOrEmpty(splitRecord.OriginalBarcode) && !splitBarcodes.Contains(splitRecord.OriginalBarcode))
+ {
+ var originalStock = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
+ .FirstAsync(x => x.Barcode == splitRecord.OriginalBarcode && x.StockId == stockId);
+
+ if (originalStock != null && originalStock.StockQuantity > 0)
+ {
+ splitReturnQty += originalStock.StockQuantity;
+
+ // 娣诲姞鍒版墍鏈夋潯鐮佸垪琛紙濡傛灉娌℃湁閲嶅锛�
+ if (!result.AllBarcodes.Contains(splitRecord.OriginalBarcode))
+ {
+ result.AllBarcodes.Add(splitRecord.OriginalBarcode);
+ }
+
+ splitBarcodes.Add(splitRecord.OriginalBarcode);
+ _logger.LogInformation($"鎷嗗寘璁板綍 - 鍘熸潯鐮�: {splitRecord.OriginalBarcode}, 鏁伴噺: {originalStock.StockQuantity}");
+ }
+ }
+
+ // 鏂版潯鐮�
+ if (!string.IsNullOrEmpty(splitRecord.NewBarcode) && !splitBarcodes.Contains(splitRecord.NewBarcode))
+ {
+ var newStock = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
+ .FirstAsync(x => x.Barcode == splitRecord.NewBarcode && x.StockId == stockId);
+
+ if (newStock != null && newStock.StockQuantity > 0)
+ {
+ splitReturnQty += newStock.StockQuantity;
+
+ // 娣诲姞鍒版墍鏈夋潯鐮佸垪琛紙濡傛灉娌℃湁閲嶅锛�
+ if (!result.AllBarcodes.Contains(splitRecord.NewBarcode))
+ {
+ result.AllBarcodes.Add(splitRecord.NewBarcode);
+ }
+
+ splitBarcodes.Add(splitRecord.NewBarcode);
+ _logger.LogInformation($"鎷嗗寘璁板綍 - 鏂版潯鐮�: {splitRecord.NewBarcode}, 鏁伴噺: {newStock.StockQuantity}");
+ }
+ }
+
+ // 璁板綍鎷嗗寘淇℃伅
+ _logger.LogInformation($"鎷嗗寘璁板綍 - ID: {splitRecord.Id}, 鍘熸潯鐮�: {splitRecord.OriginalBarcode}, " +
+ $"鏂版潯鐮�: {splitRecord.NewBarcode}, 鎷嗗寘鏁伴噺: {splitRecord.SplitQty}, " +
+ $"鏄惁鑷姩: {splitRecord.IsAutoSplit}, 鏄惁鎾ら攢: {splitRecord.IsReverted}");
+ }
+
+ result.SplitReturnQty = splitReturnQty;
+ _logger.LogInformation($"鍙戠幇{splitRecords.Count}鏉℃媶鍖呰褰曪紝鍏宠仈 {splitBarcodes.Count} 涓潯鐮侊紝鎬绘暟閲�: {splitReturnQty}");
+ }
+ else
+ {
+ _logger.LogInformation($"鏈壘鍒伴渶瑕佸洖搴撶殑鎷嗗寘璁板綍");
+ }
+
+ // 4. 璁＄畻鎬诲洖搴撴暟閲忓拰绌烘墭鐩樼姸鎬�
+ result.TotalReturnQty = result.RemainingLocksReturnQty +
+ result.UnallocatedLocksReturnQty +
+ result.PalletStockReturnQty +
+ result.SplitReturnQty;
+
+ result.HasItemsToReturn = result.TotalReturnQty > 0;
+ result.IsEmptyPallet = !result.HasItemsToReturn;
+
+ // 鍘婚噸鎵�鏈夋潯鐮�
+ result.AllBarcodes = result.AllBarcodes.Distinct().ToList();
+
+ _logger.LogInformation($"鎵樼洏鐘舵�佸垎鏋愬畬鎴� - 璁㈠崟: {orderNo}, 鎵樼洏: {palletCode}");
+ _logger.LogInformation($"姹囨�讳俊鎭�:");
+ _logger.LogInformation($" - 宸插垎閰嶉攣瀹氳褰�: {result.RemainingLocks.Count} 鏉�, 鏁伴噺: {result.RemainingLocksReturnQty}");
+ _logger.LogInformation($" - 鏈垎閰嶉攣瀹氳褰�: {result.UnallocatedLocks.Count} 鏉�, 鏁伴噺: {result.UnallocatedLocksReturnQty}");
+ _logger.LogInformation($" - 鏈垎閰嶅簱瀛樿揣鐗�: {result.PalletStockGoods.Count} 涓�, 鏁伴噺: {result.PalletStockReturnQty}");
+ _logger.LogInformation($" - 鎷嗗寘璁板綍: {result.SplitRecords.Count} 鏉�, 鏁伴噺: {result.SplitReturnQty}");
+ _logger.LogInformation($" - 鎬诲洖搴撴暟閲�: {result.TotalReturnQty}");
+ _logger.LogInformation($" - 鏄惁绌烘墭鐩�: {result.IsEmptyPallet}");
+ _logger.LogInformation($" - 娑夊強鏉＄爜: {string.Join(", ", result.AllBarcodes)}");
+
+ // 5. 棰濆鐨勬暟鎹獙璇�
+ await ValidateAnalysisResults(result, stockId);
+
+ return result;
+ }
+ catch (Exception ex)
+ {
+ _logger.LogError($"鎵樼洏鐘舵�佸垎鏋愬け璐� - 璁㈠崟: {orderNo}, 鎵樼洏: {palletCode}, Error: {ex.Message}");
+ throw;
+ }
+ }
+
+ /// <summary>
+ /// 楠岃瘉鍒嗘瀽缁撴灉锛岀‘淇濇暟鎹竴鑷存��
+ /// </summary>
+ private async Task ValidateAnalysisResults(PalletStatusAnalysis analysis, int stockId)
+ {
+ _logger.LogInformation($"寮�濮嬮獙璇佸垎鏋愮粨鏋� - 璁㈠崟: {analysis.OrderNo}, 鎵樼洏: {analysis.PalletCode}");
+
+ try
+ {
+ // 1. 楠岃瘉閿佸畾璁板綍鍜屽簱瀛樻槑缁嗙殑鍖归厤
+ foreach (var lockInfo in analysis.RemainingLocks.Concat(analysis.UnallocatedLocks))
+ {
+ if (!string.IsNullOrEmpty(lockInfo.CurrentBarcode))
+ {
+ var stockDetail = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
+ .FirstAsync(x => x.Barcode == lockInfo.CurrentBarcode && x.StockId == lockInfo.StockId);
+
+ if (stockDetail == null)
+ {
+ _logger.LogWarning($"閿佸畾璁板綍 {lockInfo.Id} 鐨勬潯鐮� {lockInfo.CurrentBarcode} 鍦ㄥ簱瀛樻槑缁嗕腑涓嶅瓨鍦�");
+ }
+ else if (stockDetail.StockQuantity <= 0)
+ {
+ _logger.LogWarning($"閿佸畾璁板綍 {lockInfo.Id} 鐨勬潯鐮� {lockInfo.CurrentBarcode} 搴撳瓨鏁伴噺涓�0鎴栬礋鏁�");
+ }
+ }
+ }
+
+ // 2. 楠岃瘉鎬诲洖搴撴暟閲忕殑鍚堢悊鎬�
+ // 鑾峰彇鎵樼洏涓婄殑鎬诲簱瀛樻暟閲�
+ var totalStockOnPallet = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
+ .Where(x => x.StockId == stockId)
+ .SumAsync(x => x.StockQuantity);
+
+ if (analysis.TotalReturnQty > totalStockOnPallet)
+ {
+ _logger.LogWarning($"鎬诲洖搴撴暟閲� {analysis.TotalReturnQty} 澶т簬鎵樼洏鎬诲簱瀛� {totalStockOnPallet}锛屽彲鑳藉瓨鍦ㄨ绠楅敊璇�");
+ }
+
+ // 3. 楠岃瘉鏉＄爜鐨勫敮涓�鎬�
+ var duplicateBarcodes = analysis.AllBarcodes
+ .GroupBy(x => x)
+ .Where(g => g.Count() > 1)
+ .Select(g => g.Key)
+ .ToList();
+
+ if (duplicateBarcodes.Any())
+ {
+ _logger.LogWarning($"鍙戠幇閲嶅鐨勬潯鐮�: {string.Join(", ", duplicateBarcodes)}");
+ }
+
+ _logger.LogInformation($"鍒嗘瀽缁撴灉楠岃瘉瀹屾垚");
+ }
+ catch (Exception ex)
+ {
+ _logger.LogError($"鍒嗘瀽缁撴灉楠岃瘉澶辫触 - Error: {ex.Message}");
+ // 涓嶆姏鍑哄紓甯革紝鍙褰曢敊璇�
+ }
+ }
+
+ /// <summary>
+ /// 澶勭悊鏈垎鎷ｇ殑閿佸畾璁板綍鍥炲簱
+ /// 纭繚涓嶄細閿欒缁戝畾鏉＄爜鏁伴噺鍒伴攣瀹氭暟閲�
+ /// </summary>
+ private async Task HandleRemainingLocksReturn(List<Dt_OutStockLockInfo> remainingLocks)
+ {
+ _logger.LogInformation($"寮�濮嬪鐞嗘湭鍒嗘嫞閿佸畾璁板綍鍥炲簱 - 鍏� {remainingLocks.Count} 鏉¤褰�");
+
+ // 鎸夎鍗曟槑缁嗗垎缁勫鐞嗭紝纭繚璁㈠崟鏄庣粏鏁版嵁鐨勪竴鑷存��
+ var orderDetailGroups = remainingLocks.GroupBy(x => x.OrderDetailId);
+
+ foreach (var group in orderDetailGroups)
+ {
+ var orderDetailId = group.Key;
+ var groupLocks = group.ToList();
+
+ _logger.LogInformation($"澶勭悊璁㈠崟鏄庣粏 {orderDetailId} 鐨� {groupLocks.Count} 鏉￠攣瀹氳褰�");
+
+ // 鑾峰彇璁㈠崟鏄庣粏
+ var orderDetail = await _outboundOrderDetailService.Db.Queryable<Dt_OutboundOrderDetail>()
+ .FirstAsync(x => x.Id == orderDetailId);
+
+ if (orderDetail == null)
+ {
+ _logger.LogWarning($"鏈壘鍒拌鍗曟槑缁� - OrderDetailId: {orderDetailId}");
+ continue;
+ }
+
+ decimal totalReturnQtyForDetail = 0;
+
+ foreach (var lockInfo in groupLocks)
+ {
+ // 鍙鐞嗙姸鎬佷负鍑哄簱涓殑閿佸畾璁板綍
+ if (lockInfo.Status != (int)OutLockStockStatusEnum.鍑哄簱涓�)
+ {
+ _logger.LogInformation($"璺宠繃闈炲嚭搴撲腑鐘舵�佺殑閿佸畾璁板綍 - 閿佸畾ID: {lockInfo.Id}, 鐘舵��: {lockInfo.Status}");
+ continue;
+ }
+
+ // 璁＄畻鍥炲簱鏁伴噺锛堟湭鎷ｉ�夌殑閮ㄥ垎锛�
+ decimal returnQty = lockInfo.AssignQuantity - lockInfo.PickedQty;
+
+ if (returnQty <= 0)
+ {
+ _logger.LogInformation($"璺宠繃閿佸畾璁板綍 - 閿佸畾ID: {lockInfo.Id}, 宸叉嫞閫夊畬鎴愭垨鏃犻渶鍥炲簱");
+ continue;
+ }
+
+ _logger.LogInformation($"澶勭悊閿佸畾璁板綍鍥炲簱 - 閿佸畾ID: {lockInfo.Id}, 鏉＄爜: {lockInfo.CurrentBarcode}, 鍥炲簱鏁伴噺: {returnQty}");
+
+ // 鎭㈠搴撳瓨鐘舵��
+ var stockDetail = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
+ .FirstAsync(x => x.Barcode == lockInfo.CurrentBarcode && x.StockId == lockInfo.StockId);
+
+ if (stockDetail != null)
+ {
+ // 璁板綍鎭㈠鍓嶇殑搴撳瓨鐘舵��
+ decimal originalStockQty = stockDetail.StockQuantity;
+ decimal originalOutboundQty = stockDetail.OutboundQuantity;
+
+ // 鍙仮澶嶅疄闄呯殑搴撳瓨鏁伴噺锛屼笉鍒涘缓鏂扮殑鏉＄爜鎴栫粦瀹�
+ // 鎭㈠搴撳瓨鏁伴噺锛氬嚭搴撴暟閲忓噺灏戯紝搴撳瓨鏁伴噺澧炲姞
+ stockDetail.OutboundQuantity -= returnQty;
+ stockDetail.StockQuantity += returnQty;
+
+ // 纭繚鏁伴噺涓嶄細涓鸿礋鏁�
+ if (stockDetail.OutboundQuantity < 0)
+ {
+ _logger.LogWarning($"鍑哄簱鏁伴噺鍑虹幇璐熸暟锛岄噸缃负0銆傚師鍊�: {stockDetail.OutboundQuantity + returnQty}");
+ stockDetail.OutboundQuantity = 0;
+ }
+
+ // 鎭㈠搴撳瓨鐘舵�佷负鍙敤鐘舵��
+ if (stockDetail.Status == (int)StockStatusEmun.鍑哄簱閿佸畾)
+ {
+ stockDetail.Status = (int)StockStatusEmun.鍏ュ簱瀹屾垚;
+ _logger.LogInformation($"搴撳瓨鐘舵�佹洿鏂颁负鍏ュ簱瀹屾垚 - 鏉＄爜: {stockDetail.Barcode}");
+ }
+
+ await _stockInfoDetailService.Db.Updateable(stockDetail).ExecuteCommandAsync();
+
+ _logger.LogInformation($"鎭㈠搴撳瓨鐘舵�� - 鏉＄爜: {stockDetail.Barcode}, " +
+ $"搴撳瓨鏁伴噺: {originalStockQty} -> {stockDetail.StockQuantity}, " +
+ $"鍑哄簱鏁伴噺: {originalOutboundQty} -> {stockDetail.OutboundQuantity}");
+ }
+ else
+ {
+ _logger.LogWarning($"鏈壘鍒板搴旂殑搴撳瓨淇℃伅 - 鏉＄爜: {lockInfo.CurrentBarcode}, StockId: {lockInfo.StockId}");
+ // 閲嶈锛氬鏋滄壘涓嶅埌搴撳瓨淇℃伅锛岃烦杩囨閿佸畾璁板綍锛岄伩鍏嶆暟鎹笉涓�鑷�
+ continue;
+ }
+
+ // 鏇存柊閿佸畾璁板綍鐘舵�佷负宸插洖搴擄紝浣嗕笉淇敼鍒嗛厤鏁伴噺
+ // 鍒嗛厤鏁伴噺鍦ㄨ鍗曟槑缁嗗眰闈㈢粺涓�澶勭悊
+ var originalStatus = lockInfo.Status;
+ lockInfo.Status = (int)OutLockStockStatusEnum.宸插洖搴�;
+ lockInfo.Operator = App.User.UserName;
+
+ await _outStockLockInfoService.Db.Updateable(lockInfo).ExecuteCommandAsync();
+
+ _logger.LogInformation($"鏇存柊閿佸畾鐘舵�� - 閿佸畾ID: {lockInfo.Id}, 鐘舵��: {originalStatus} -> {lockInfo.Status}");
+
+ totalReturnQtyForDetail += returnQty;
+
+ _logger.LogInformation($"閿佸畾璁板綍鍥炲簱瀹屾垚 - 閿佸畾ID: {lockInfo.Id}, 鍥炲簱鏁伴噺: {returnQty}");
+ }
+
+ // 鍑忓皯璁㈠崟鏄庣粏鐨勫垎閰嶆暟閲�
+ if (totalReturnQtyForDetail > 0)
+ {
+ await ReduceOrderDetailAllocation(orderDetail, totalReturnQtyForDetail);
+ }
+ }
+
+ _logger.LogInformation($"鏈垎鎷ｉ攣瀹氳褰曞洖搴撳鐞嗗畬鎴� - 鍏卞鐞� {remainingLocks.Count} 鏉¤褰�");
+ }
+ /// <summary>
+ /// 澶勭悊鏈垎閰嶇殑搴撳瓨璐х墿鍥炲簱
+ /// 纭繚涓嶄細鍒涘缓鏂扮殑閿佸畾璁板綍
+ /// </summary>
+ private async Task HandleUnallocatedStockReturn(List<Dt_StockInfoDetail> stockGoods)
+ {
+ _logger.LogInformation($"寮�濮嬪鐞嗘湭鍒嗛厤搴撳瓨鍥炲簱 - 鍏� {stockGoods.Count} 涓揣鐗�");
+
+ foreach (var stockDetail in stockGoods)
+ {
+ if (stockDetail.StockQuantity <= 0)
+ {
+ _logger.LogInformation($"璺宠繃闆跺簱瀛樿揣鐗� - 鏉＄爜: {stockDetail.Barcode}");
+ continue;
+ }
+
+ _logger.LogInformation($"澶勭悊鏈垎閰嶅簱瀛樺洖搴� - 鏉＄爜: {stockDetail.Barcode}, 鏁伴噺: {stockDetail.StockQuantity}");
+
+ // 妫�鏌ユ槸鍚﹀凡缁忔湁瀵瑰簲鐨勯攣瀹氳褰�
+ var existingLock = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
+ .Where(x => x.CurrentBarcode == stockDetail.Barcode &&
+ x.Status == (int)OutLockStockStatusEnum.鍑哄簱涓�)
+ .FirstAsync();
+
+ if (existingLock != null)
+ {
+ _logger.LogWarning($"搴撳瓨鏉＄爜 {stockDetail.Barcode} 宸叉湁閿佸畾璁板綍锛岃烦杩囩洿鎺ュ洖搴撳鐞�");
+ continue;
+ }
+
+ // 璁板綍鎭㈠鍓嶇殑鐘舵��
+ var originalStatus = stockDetail.Status;
+
+ // 鐩存帴鎭㈠搴撳瓨鐘舵�佷负鍙敤鐘舵�侊紝涓嶅垱寤轰换浣曢攣瀹氳褰�
+ stockDetail.Status = (int)StockStatusEmun.鍏ュ簱瀹屾垚;
+
+ await _stockInfoDetailService.Db.Updateable(stockDetail).ExecuteCommandAsync();
+
+ _logger.LogInformation($"鏈垎閰嶅簱瀛樺洖搴撳畬鎴� - 鏉＄爜: {stockDetail.Barcode}, 鐘舵��: {originalStatus} -> {stockDetail.Status}");
+ }
+
+ _logger.LogInformation($"鏈垎閰嶅簱瀛樺洖搴撳鐞嗗畬鎴� - 鍏卞鐞� {stockGoods.Count} 涓揣鐗�");
+ }
+ /// <summary>
+ /// 鍑忓皯璁㈠崟鏄庣粏鐨勫垎閰嶆暟閲�
+ /// 纭繚鍒嗛厤鏁伴噺鐨勫噺灏戞槸鍑嗙‘鐨�
+ /// </summary>
+ private async Task ReduceOrderDetailAllocation(Dt_OutboundOrderDetail orderDetail, decimal reduceQty)
+ {
+ if (orderDetail == null)
+ return;
+
+ decimal originalAllocated = orderDetail.AllocatedQuantity;
+ decimal originalLock = orderDetail.LockQuantity;
+
+ // 楠岃瘉鍑忓皯鏁伴噺涓嶄細瀵艰嚧璐熸暟
+ if (orderDetail.AllocatedQuantity < reduceQty)
+ {
+ _logger.LogWarning($"鍒嗛厤鏁伴噺涓嶈冻锛岃皟鏁村噺灏戞暟閲� - 鍘熻鍒掑噺灏�: {reduceQty}, 瀹為檯鍙敤: {orderDetail.AllocatedQuantity}");
+ reduceQty = orderDetail.AllocatedQuantity;
+ }
+
+ // 鍑忓皯鍒嗛厤鏁伴噺鍜岄攣瀹氭暟閲�
+ orderDetail.AllocatedQuantity -= reduceQty;
+ orderDetail.LockQuantity -= reduceQty;
+
+ // 纭繚鏁伴噺涓嶄細涓鸿礋鏁�
+ if (orderDetail.AllocatedQuantity < 0)
+ {
+ _logger.LogWarning($"鍒嗛厤鏁伴噺鍑虹幇璐熸暟锛岄噸缃负0銆傚師鍊�: {orderDetail.AllocatedQuantity + reduceQty}, 鍑忓皯: {reduceQty}");
+ orderDetail.AllocatedQuantity = 0;
+ }
+
+ if (orderDetail.LockQuantity < 0)
+ {
+ _logger.LogWarning($"閿佸畾鏁伴噺鍑虹幇璐熸暟锛岄噸缃负0銆傚師鍊�: {orderDetail.LockQuantity + reduceQty}, 鍑忓皯: {reduceQty}");
+ orderDetail.LockQuantity = 0;
+ }
+
+ // 鏇存柊鎵规鍒嗛厤鐘舵��
+ await UpdateBatchAllocateStatus(orderDetail);
+
+ await _outboundOrderDetailService.Db.Updateable(orderDetail).ExecuteCommandAsync();
+
+ _logger.LogInformation($"鍑忓皯璁㈠崟鏄庣粏鍒嗛厤 - OrderDetailId: {orderDetail.Id}, " +
+ $"鍒嗛厤鏁伴噺: {originalAllocated} -> {orderDetail.AllocatedQuantity}, " +
+ $"閿佸畾鏁伴噺: {originalLock} -> {orderDetail.LockQuantity}, " +
+ $"鍑忓皯鏁伴噺: {reduceQty}");
+
+ // 楠岃瘉鏁版嵁涓�鑷存��
+ await ValidateOrderDetailConsistency(orderDetail.Id);
+ }
+ /// <summary>
+ /// 楠岃瘉璁㈠崟鏄庣粏鏁版嵁涓�鑷存��
+ /// </summary>
+ private async Task ValidateOrderDetailConsistency(long orderDetailId)
+ {
+ var orderDetail = await _outboundOrderDetailService.Db.Queryable<Dt_OutboundOrderDetail>()
+ .FirstAsync(x => x.Id == orderDetailId);
+
+ if (orderDetail == null)
+ return;
+
+ // 璁＄畻鎵�鏈夌浉鍏抽攣瀹氳褰曠殑鎬诲垎閰嶆暟閲�
+ var relatedLocks = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
+ .Where(x => x.OrderDetailId == orderDetailId &&
+ x.Status != (int)OutLockStockStatusEnum.宸插洖搴�)
+ .ToListAsync();
+
+ decimal totalLockAssignQty = relatedLocks.Sum(x => x.AssignQuantity);
+
+ // 楠岃瘉璁㈠崟鏄庣粏鍒嗛厤鏁伴噺涓庨攣瀹氳褰曟�诲垎閰嶆暟閲忕殑涓�鑷存��
+ if (Math.Abs(orderDetail.AllocatedQuantity - totalLockAssignQty) > 0.01m)
+ {
+ _logger.LogWarning($"鏁版嵁涓嶄竴鑷磋鍛� - OrderDetailId: {orderDetailId}, " +
+ $"璁㈠崟鏄庣粏鍒嗛厤鏁伴噺: {orderDetail.AllocatedQuantity}, " +
+ $"閿佸畾璁板綍鎬诲垎閰嶆暟閲�: {totalLockAssignQty}");
+ }
+ else
+ {
+ _logger.LogInformation($"鏁版嵁涓�鑷存�ч獙璇侀�氳繃 - OrderDetailId: {orderDetailId}");
+ }
+ }
+ /// <summary>
+ /// 鍒嗘壒鍥炲簱 - 璋冪敤缁熶竴鍥炲簱鏂规硶
+ /// </summary>
+ public async Task<WebResponseContent> BatchReturnStock(string orderNo, string palletCode)
+ {
+ return await ExecutePalletReturn(orderNo, palletCode, "鍒嗘壒鍥炲簱");
+ }
+
+ /// <summary>
+ /// 鍓╀綑鍥炲簱 - 璋冪敤缁熶竴鍥炲簱鏂规硶
+ /// </summary>
+ public async Task<WebResponseContent> ReturnRemaining(string orderNo, string palletCode, string reason)
+ {
+ return await ExecutePalletReturn(orderNo, palletCode, reason);
+ }
+
+ /// <summary>
+ /// 鍙栬蛋绌虹 - 鍏堟墽琛屽洖搴撳啀娓呯悊
+ /// </summary>
+ public async Task<WebResponseContent> RemoveEmptyPallet(string orderNo, string palletCode)
+ {
+ try
+ {
+ _logger.LogInformation($"銆愬彇璧扮┖绠卞紑濮嬨�戣鍗�: {orderNo}, 鎵樼洏: {palletCode}");
+
+ _unitOfWorkManage.BeginTran();
+
+ // 1. 鍏堝皾璇曟墽琛屽洖搴撴搷浣滐紝纭繚鎵�鏈夌墿鍝侀兘鍥炲簱
+ _logger.LogInformation($"姝ラ1: 鍏堟墽琛屽洖搴撴搷浣�");
+ var returnResult = await ExecutePalletReturn(orderNo, palletCode, "鍙栬蛋绌虹鍓嶅洖搴�");
+ if (!returnResult.Status)
+ {
+ // 鍥炲簱澶辫触锛屽彲鑳芥槸绌烘墭鐩樻垨鑰呮湁鍏朵粬闂
+ _logger.LogWarning($"鍥炲簱鎿嶄綔澶辫触: {returnResult.Message}");
+
+ // 缁х画楠岃瘉绌虹鍙栬蛋鏉′欢
+ }
+
+ // 2. 楠岃瘉绌虹鍙栬蛋鏉′欢锛堝繀椤诲叏閮ㄥ畬鎴愭嫞閫夛級
+ _logger.LogInformation($"姝ラ2: 楠岃瘉绌虹鍙栬蛋鏉′欢");
+ var validationResult = await ValidateEmptyPalletRemoval(orderNo, palletCode);
+ if (!validationResult.IsValid)
+ {
+ _unitOfWorkManage.RollbackTran();
+ _logger.LogError($"绌虹楠岃瘉澶辫触: {validationResult.ErrorMessage}");
+ return WebResponseContent.Instance.Error(validationResult.ErrorMessage);
+ }
+
+ var completedLocks = validationResult.Data;
+ _logger.LogInformation($"楠岃瘉閫氳繃锛屾壘鍒� {completedLocks.Count} 鏉″凡瀹屾垚璁板綍");
+
+ // 3. 娓呯悊宸插畬鎴愮殑閿佸畾璁板綍锛堟爣璁颁负宸插彇璧帮級
+ _logger.LogInformation($"姝ラ3: 娓呯悊閿佸畾璁板綍");
+ foreach (var lockInfo in completedLocks)
+ {
+ // 鍙鐞嗙姸鎬佷负鎷ｉ�夊畬鎴愮殑璁板綍锛堝凡鍙栬蛋鐨勮烦杩囷級
+ if (lockInfo.Status == (int)OutLockStockStatusEnum.鎷ｉ�夊畬鎴�)
+ {
+ // 鏍囪閿佸畾璁板綍涓哄凡鍙栬蛋
+ lockInfo.Status = (int)OutLockStockStatusEnum.宸插彇璧�;
+ lockInfo.Operator = App.User.UserName;
+ await _outStockLockInfoService.Db.Updateable(lockInfo).ExecuteCommandAsync();
+ _logger.LogInformation($"閿佸畾璁板綍鏍囪涓哄凡鍙栬蛋 - ID: {lockInfo.Id}");
+ }
+ }
+
+ // 4. 娓呯悊瀵瑰簲鐨勫簱瀛樿褰曠姸鎬�
+ _logger.LogInformation($"姝ラ4: 娓呯悊搴撳瓨璁板綍");
+ foreach (var lockInfo in completedLocks)
+ {
+ await CleanupStockInfo(lockInfo);
+ }
+
+ // 5. 鏇存柊鐩稿叧璁㈠崟鐘舵��
+ _logger.LogInformation($"姝ラ5: 鏇存柊璁㈠崟鐘舵��");
+ await UpdateOrderStatusAfterPalletRemoval(orderNo);
+
+ // 6. 璁板綍鎿嶄綔鍘嗗彶
+ _logger.LogInformation($"姝ラ6: 璁板綍鎿嶄綔鍘嗗彶");
+ await RecordEmptyPalletRemoval(orderNo, palletCode, completedLocks);
_unitOfWorkManage.CommitTran();
- return WebResponseContent.Instance.OK("鍒嗘壒鍥炲簱鎴愬姛");
+ _logger.LogInformation($"銆愬彇璧扮┖绠辨垚鍔熴�戣鍗�: {orderNo}, 鎵樼洏: {palletCode}");
+
+ return WebResponseContent.Instance.OK("鍙栬蛋绌虹鎴愬姛");
}
catch (Exception ex)
{
_unitOfWorkManage.RollbackTran();
- _logger.LogError($"鍒嗘壒鍥炲簱澶辫触 - OrderNo: {orderNo}, PalletCode: {palletCode}, Error: {ex.Message}");
- return WebResponseContent.Instance.Error($"鍒嗘壒鍥炲簱澶辫触锛歿ex.Message}");
+ _logger.LogError($"鍙栬蛋绌虹澶辫触 - OrderNo: {orderNo}, PalletCode: {palletCode}, Error: {ex.Message}");
+ return WebResponseContent.Instance.Error($"鍙栬蛋绌虹澶辫触锛歿ex.Message}");
+ }
+ }
+ /// <summary>
+ /// 鏀堕泦闇�瑕佸洖搴撶殑鏉＄爜
+ /// </summary>
+ private async Task<List<string>> CollectReturnBarcodes(PalletStatusAnalysis status)
+ {
+ var returnBarcodes = new HashSet<string>();
+
+ try
+ {
+ _logger.LogInformation($"寮�濮嬫敹闆嗗洖搴撴潯鐮� - 璁㈠崟: {status.OrderNo}, 鎵樼洏: {status.PalletCode}");
+
+ // 1. 鏀堕泦鏈垎鎷ｉ攣瀹氳褰曠殑鏉＄爜
+ if (status.HasRemainingLocks)
+ {
+ foreach (var lockInfo in status.RemainingLocks)
+ {
+ if (!string.IsNullOrEmpty(lockInfo.CurrentBarcode))
+ {
+ returnBarcodes.Add(lockInfo.CurrentBarcode);
+ _logger.LogInformation($"娣诲姞閿佸畾璁板綍鏉＄爜: {lockInfo.CurrentBarcode}");
+ }
+ }
+ }
+
+ // 2. 鏀堕泦鎵樼洏涓婂簱瀛樿揣鐗╃殑鏉＄爜
+ if (status.HasPalletStockGoods)
+ {
+ foreach (var stockDetail in status.PalletStockGoods)
+ {
+ if (!string.IsNullOrEmpty(stockDetail.Barcode) && stockDetail.StockQuantity > 0)
+ {
+ returnBarcodes.Add(stockDetail.Barcode);
+ _logger.LogInformation($"娣诲姞搴撳瓨璐х墿鏉＄爜: {stockDetail.Barcode}, 鏁伴噺: {stockDetail.StockQuantity}");
+ }
+ }
+ }
+
+ // 3. 鏀堕泦鎷嗗寘璁板綍鐩稿叧鐨勬潯鐮�
+ if (status.HasSplitRecords)
+ {
+ foreach (var splitRecord in status.SplitRecords)
+ {
+ // 娣诲姞鍘熸潯鐮�
+ if (!string.IsNullOrEmpty(splitRecord.OriginalBarcode))
+ {
+ var originalStock = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
+ .FirstAsync(x => x.Barcode == splitRecord.OriginalBarcode && x.StockId == status.StockId);
+
+ if (originalStock != null && originalStock.StockQuantity > 0)
+ {
+ returnBarcodes.Add(splitRecord.OriginalBarcode);
+ _logger.LogInformation($"娣诲姞鎷嗗寘鍘熸潯鐮�: {splitRecord.OriginalBarcode}, 鏁伴噺: {originalStock.StockQuantity}");
+ }
+ }
+
+ // 娣诲姞鏂版潯鐮�
+ if (!string.IsNullOrEmpty(splitRecord.NewBarcode))
+ {
+ var newStock = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
+ .FirstAsync(x => x.Barcode == splitRecord.NewBarcode && x.StockId == status.StockId);
+
+ if (newStock != null && newStock.StockQuantity > 0)
+ {
+ returnBarcodes.Add(splitRecord.NewBarcode);
+ _logger.LogInformation($"娣诲姞鎷嗗寘鏂版潯鐮�: {splitRecord.NewBarcode}, 鏁伴噺: {newStock.StockQuantity}");
+ }
+ }
+ }
+ }
+
+ _logger.LogInformation($"鍥炲簱鏉＄爜鏀堕泦瀹屾垚 - 鍏� {returnBarcodes.Count} 涓潯鐮�: {string.Join(", ", returnBarcodes)}");
+
+ return returnBarcodes.ToList();
+ }
+ catch (Exception ex)
+ {
+ _logger.LogError($"鏀堕泦鍥炲簱鏉＄爜澶辫触 - Error: {ex.Message}");
+ return returnBarcodes.ToList();
+ }
+ }
+ #endregion
+
+ #region 鍥炲簱鎿嶄綔鏍稿績鏂规硶
+
+ /// <summary>
+ /// 鎵ц鍥炲簱鎿嶄綔 - 澧炲己鐗堟湰
+ /// </summary>
+ private async Task ExecuteReturnOperations(string orderNo, string palletCode, Dt_StockInfo stockInfo,
+ Dt_Task task, PalletStatusAnalysis statusAnalysis)
+ {
+ _logger.LogInformation($"寮�濮嬫墽琛屽洖搴撴搷浣� - 璁㈠崟: {orderNo}, 鎵樼洏: {palletCode}");
+
+ // 澶勭悊鏈垎鎷ｇ殑閿佸畾璁板綍
+ if (statusAnalysis.HasRemainingLocks)
+ {
+ _logger.LogInformation($"澶勭悊 {statusAnalysis.RemainingLocks.Count} 鏉℃湭鍒嗘嫞閿佸畾璁板綍");
+ await HandleRemainingLocksReturn(statusAnalysis.RemainingLocks);
+ }
+
+ //澶勭悊鎵樼洏涓婄殑搴撳瓨璐х墿
+ if (statusAnalysis.HasPalletStockGoods)
+ {
+ _logger.LogInformation($"澶勭悊 {statusAnalysis.PalletStockGoods.Count} 涓簱瀛樿揣鐗�");
+ await HandlePalletStockGoodsReturn(statusAnalysis.PalletStockGoods, stockInfo.Id);
+ }
+
+ //澶勭悊鎷嗗寘璁板綍
+ if (statusAnalysis.HasSplitRecords)
+ {
+ _logger.LogInformation($"澶勭悊 {statusAnalysis.SplitRecords.Count} 鏉℃媶鍖呰褰�");
+ await HandleSplitRecordsReturn(statusAnalysis.SplitRecords, stockInfo.Id);
+ }
+
+ _logger.LogInformation($"鍥炲簱鎿嶄綔瀹屾垚 - 鎬诲洖搴撴暟閲�: {statusAnalysis.TotalReturnQty}");
+ }
+
+ /// <summary>
+ /// 澶勭悊鏈垎鎷ｇ殑閿佸畾璁板綍鍥炲簱
+ /// </summary>
+
+
+ /// <summary>
+ /// 澶勭悊鎵樼洏涓婄殑搴撳瓨璐х墿鍥炲簱
+ /// </summary>
+ private async Task HandlePalletStockGoodsReturn(List<Dt_StockInfoDetail> palletStockGoods, int stockId)
+ {
+ foreach (var stockDetail in palletStockGoods)
+ {
+ // 鍙鐞嗗嚭搴撻攣瀹氱姸鎬佺殑搴撳瓨
+ if (stockDetail.Status == (int)StockStatusEmun.鍑哄簱閿佸畾 && stockDetail.StockQuantity > 0)
+ {
+ // 鎭㈠搴撳瓨鐘舵�佷负鍙敤鐘舵��
+ stockDetail.Status = (int)StockStatusEmun.鍏ュ簱瀹屾垚;
+ await _stockInfoDetailService.Db.Updateable(stockDetail).ExecuteCommandAsync();
+
+ _logger.LogInformation($"鎭㈠搴撳瓨璐х墿 - 鏉＄爜: {stockDetail.Barcode}, 鏁伴噺: {stockDetail.StockQuantity}");
+ }
+ }
+ }
+
+ /// <summary>
+ /// 澶勭悊鎷嗗寘璁板綍鍥炲簱
+ /// </summary>
+ private async Task HandleSplitRecordsReturn(List<Dt_SplitPackageRecord> splitRecords, int stockId)
+ {
+ foreach (var splitRecord in splitRecords)
+ {
+ // 澶勭悊鏂版潯鐮�
+ var newLockInfo = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
+ .Where(x => x.CurrentBarcode == splitRecord.NewBarcode &&
+ x.Status == (int)OutLockStockStatusEnum.鍑哄簱涓�)
+ .FirstAsync();
+
+ if (newLockInfo != null)
+ {
+ await HandleSingleLockReturn(newLockInfo);
+ }
+
+ // 澶勭悊鍘熸潯鐮�
+ var originalLockInfo = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
+ .Where(x => x.CurrentBarcode == splitRecord.OriginalBarcode &&
+ x.Status == (int)OutLockStockStatusEnum.鍑哄簱涓�)
+ .FirstAsync();
+
+ if (originalLockInfo != null)
+ {
+ await HandleSingleLockReturn(originalLockInfo);
+ }
+
+ // 鏇存柊鎷嗗寘璁板綍鐘舵�佷负宸插洖搴�
+ splitRecord.Status = (int)SplitPackageStatusEnum.宸插洖搴�;
+ await _splitPackageService.Db.Updateable(splitRecord).ExecuteCommandAsync();
+ }
+ }
+
+ private async Task HandleSingleLockReturn(Dt_OutStockLockInfo lockInfo)
+ {
+ decimal returnQty = lockInfo.AssignQuantity - lockInfo.PickedQty;
+
+ if (returnQty <= 0)
+ {
+ _logger.LogInformation($"璺宠繃閿佸畾璁板綍 - 閿佸畾ID: {lockInfo.Id}, 宸叉嫞閫夊畬鎴愭垨鏃犻渶鍥炲簱");
+ return;
+ }
+
+ _logger.LogInformation($"澶勭悊鎷嗗寘鐩稿叧閿佸畾璁板綍 - 閿佸畾ID: {lockInfo.Id}, 鏉＄爜: {lockInfo.CurrentBarcode}, 鍥炲簱鏁伴噺: {returnQty}");
+
+ // 鎭㈠搴撳瓨
+ var stockDetail = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
+ .FirstAsync(x => x.Barcode == lockInfo.CurrentBarcode && x.StockId == lockInfo.StockId);
+
+ if (stockDetail != null)
+ {
+ decimal originalStockQty = stockDetail.StockQuantity;
+ decimal originalOutboundQty = stockDetail.OutboundQuantity;
+
+ stockDetail.StockQuantity += returnQty;
+ stockDetail.OutboundQuantity -= returnQty;
+
+ if (stockDetail.OutboundQuantity < 0)
+ {
+ stockDetail.OutboundQuantity = 0;
+ }
+
+ stockDetail.Status = (int)StockStatusEmun.鍏ュ簱瀹屾垚;
+ await _stockInfoDetailService.Db.Updateable(stockDetail).ExecuteCommandAsync();
+
+ _logger.LogInformation($"鎭㈠鎷嗗寘鐩稿叧搴撳瓨 - 鏉＄爜: {stockDetail.Barcode}, " +
+ $"搴撳瓨鏁伴噺: {originalStockQty} -> {stockDetail.StockQuantity}");
+ }
+
+ // 鏇存柊閿佸畾鐘舵��
+ lockInfo.Status = (int)OutLockStockStatusEnum.宸插洖搴�;
+ lockInfo.Operator = App.User.UserName;
+ await _outStockLockInfoService.Db.Updateable(lockInfo).ExecuteCommandAsync();
+
+ // 鍑忓皯璁㈠崟鏄庣粏鐨勫垎閰嶆暟閲�
+ if (lockInfo.OrderDetailId > 0)
+ {
+ var orderDetail = await _outboundOrderDetailService.Db.Queryable<Dt_OutboundOrderDetail>()
+ .FirstAsync(x => x.Id == lockInfo.OrderDetailId);
+
+ if (orderDetail != null)
+ {
+ await ReduceOrderDetailAllocation(orderDetail, returnQty);
+ }
+ }
+
+ _logger.LogInformation($"鎷嗗寘鐩稿叧閿佸畾璁板綍鍥炲簱瀹屾垚 - 閿佸畾ID: {lockInfo.Id}, 鍥炲簱鏁伴噺: {returnQty}");
+ }
+ /// <summary>
+ /// 閲婃斁鎵�鏈夐攣瀹氫互渚块噸鏂板垎閰�
+ /// </summary>
+ private async Task ReleaseAllLocksForReallocation(string orderNo, string palletCode, PalletStatusAnalysis statusAnalysis)
+ {
+ // 鏇存柊璁㈠崟鏄庣粏鐨勫凡鍒嗛厤鏁伴噺
+ if (statusAnalysis.HasRemainingLocks)
+ {
+ var orderDetailGroups = statusAnalysis.RemainingLocks.GroupBy(x => x.OrderDetailId);
+
+ foreach (var group in orderDetailGroups)
+ {
+ var orderDetailId = group.Key;
+ var returnedQty = group.Sum(x => x.AssignQuantity - x.PickedQty);
+
+ var orderDetail = await _outboundOrderDetailService.Db.Queryable<Dt_OutboundOrderDetail>()
+ .FirstAsync(x => x.Id == orderDetailId);
+
+ if (orderDetail != null)
+ {
+ orderDetail.AllocatedQuantity -= returnedQty;
+ orderDetail.LockQuantity = orderDetail.AllocatedQuantity;
+
+ await UpdateBatchAllocateStatus(orderDetail);
+ await _outboundOrderDetailService.Db.Updateable(orderDetail).ExecuteCommandAsync();
+
+ _logger.LogInformation($"鏇存柊璁㈠崟鏄庣粏 - OrderDetailId: {orderDetailId}, 鍑忓皯鍒嗛厤鏁伴噺: {returnedQty}");
+ }
+ }
+ }
+ }
+
+ /// <summary>
+ /// 鏀堕泦闇�瑕佸洖搴撶殑鏉＄爜锛堥伩鍏嶉噸澶嶏級
+ /// </summary>
+ private async Task<HashSet<string>> CollectBarcodesForReturn(string orderNo, string palletCode, int stockId)
+ {
+ var barcodes = new HashSet<string>();
+
+ try
+ {
+ _logger.LogInformation($"寮�濮嬫敹闆嗗洖搴撴潯鐮� - 璁㈠崟: {orderNo}, 鎵樼洏: {palletCode}, StockId: {stockId}");
+
+ // 1. 浠庨攣瀹氳褰曟敹闆�
+ var lockInfos = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
+ .Where(x => x.OrderNo == orderNo &&
+ x.PalletCode == palletCode &&
+ (x.Status == (int)OutLockStockStatusEnum.鍑哄簱涓�
+ // || x.Status == (int)OutLockStockStatusEnum.鍑哄簱閿佸畾)
+ ))
+ .ToListAsync();
+
+ foreach (var lockInfo in lockInfos)
+ {
+ if (!string.IsNullOrEmpty(lockInfo.CurrentBarcode))
+ {
+ barcodes.Add(lockInfo.CurrentBarcode);
+ _logger.LogInformation($"浠庨攣瀹氳褰曟坊鍔犳潯鐮�: {lockInfo.CurrentBarcode}");
+ }
+ }
+
+ // 2. 浠庡簱瀛樻槑缁嗘敹闆嗭紙鐘舵�佷负鍑哄簱閿佸畾鐨勶級
+ var stockDetails = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
+ .Where(x => x.StockId == stockId &&
+ x.Status == (int)StockStatusEmun.鍑哄簱閿佸畾 &&
+ x.StockQuantity > 0)
+ .ToListAsync();
+
+ foreach (var stockDetail in stockDetails)
+ {
+ if (!barcodes.Contains(stockDetail.Barcode) && !string.IsNullOrEmpty(stockDetail.Barcode))
+ {
+ barcodes.Add(stockDetail.Barcode);
+ _logger.LogInformation($"浠庡簱瀛樻槑缁嗘坊鍔犳潯鐮�: {stockDetail.Barcode}, 鏁伴噺: {stockDetail.StockQuantity}");
+ }
+ }
+
+ // 3. 浠庢媶鍖呰褰曟敹闆�
+ var splitRecords = await _splitPackageService.Db.Queryable<Dt_SplitPackageRecord>()
+ .Where(x => x.OrderNo == orderNo &&
+ x.PalletCode == palletCode &&
+ !x.IsReverted &&
+ x.Status != (int)SplitPackageStatusEnum.宸叉嫞閫�)
+ .ToListAsync();
+
+ foreach (var splitRecord in splitRecords)
+ {
+ // 娣诲姞鍘熸潯鐮�
+ if (!string.IsNullOrEmpty(splitRecord.OriginalBarcode) && !barcodes.Contains(splitRecord.OriginalBarcode))
+ {
+ barcodes.Add(splitRecord.OriginalBarcode);
+ _logger.LogInformation($"浠庢媶鍖呰褰曟坊鍔犲師鏉＄爜: {splitRecord.OriginalBarcode}");
+ }
+
+ // 娣诲姞鏂版潯鐮�
+ if (!string.IsNullOrEmpty(splitRecord.NewBarcode) && !barcodes.Contains(splitRecord.NewBarcode))
+ {
+ barcodes.Add(splitRecord.NewBarcode);
+ _logger.LogInformation($"浠庢媶鍖呰褰曟坊鍔犳柊鏉＄爜: {splitRecord.NewBarcode}");
+ }
+ }
+
+ _logger.LogInformation($"鏉＄爜鏀堕泦瀹屾垚 - 鍏� {barcodes.Count} 涓潯鐮�: {string.Join(", ", barcodes)}");
+
+ return barcodes;
+ }
+ catch (Exception ex)
+ {
+ _logger.LogError($"鏀堕泦鍥炲簱鏉＄爜澶辫触 - Error: {ex.Message}");
+ return barcodes;
+ }
+ }
+
+ /// <summary>
+ /// 缁熶竴澶勭悊鏉＄爜鍥炲簱锛堥伩鍏嶉噸澶嶅鐞嗭級
+ /// </summary>
+ private async Task ProcessBarcodeReturn(string barcode, int stockId, decimal returnQty, HashSet<string> processedBarcodes)
+ {
+ if (returnQty <= 0)
+ return;
+
+ // 妫�鏌ユ槸鍚﹀凡澶勭悊杩�
+ if (processedBarcodes.Contains(barcode))
+ {
+ _logger.LogInformation($"璺宠繃宸插鐞嗙殑鏉＄爜: {barcode}");
+ return;
+ }
+
+ // 鑾峰彇搴撳瓨鏄庣粏
+ var stockDetail = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
+ .FirstAsync(x => x.Barcode == barcode && x.StockId == stockId);
+
+ if (stockDetail == null)
+ {
+ _logger.LogWarning($"鏈壘鍒版潯鐮佸搴旂殑搴撳瓨鏄庣粏: {barcode}");
+ return;
+ }
+
+ // 璁板綍鍘熷鍊�
+ decimal originalStockQty = stockDetail.StockQuantity;
+ decimal originalOutboundQty = stockDetail.OutboundQuantity;
+ int originalStatus = stockDetail.Status;
+
+ _logger.LogInformation($"澶勭悊鏉＄爜鍥炲簱 - {barcode}: 鍘熷搴撳瓨={originalStockQty}, 鍘熷鍑哄簱={originalOutboundQty}, 鐘舵��={originalStatus}");
+
+ // 楠岃瘉鏁版嵁涓�鑷存��
+ if (originalOutboundQty < returnQty)
+ {
+ _logger.LogWarning($"鍑哄簱鏁伴噺灏忎簬鍥炲簱鏁伴噺锛岃皟鏁村洖搴撴暟閲� - 鏉＄爜: {barcode}, 鍑哄簱鏁伴噺: {originalOutboundQty}, 鍥炲簱鏁伴噺: {returnQty}");
+ returnQty = originalOutboundQty;
+ }
+
+ // 鏇存柊搴撳瓨锛氬嚭搴撴暟閲忓噺灏戯紝搴撳瓨鏁伴噺澧炲姞
+ stockDetail.OutboundQuantity -= returnQty;
+ stockDetail.StockQuantity += returnQty;
+
+ // 纭繚涓嶄細鍑虹幇璐熸暟
+ if (stockDetail.OutboundQuantity < 0)
+ {
+ _logger.LogWarning($"鍑哄簱鏁伴噺鍑虹幇璐熸暟锛岄噸缃负0 - 鏉＄爜: {barcode}");
+ stockDetail.OutboundQuantity = 0;
+ }
+
+ // 鏇存柊鐘舵��
+ if (stockDetail.OutboundQuantity <= 0 && stockDetail.StockQuantity > 0)
+ {
+ stockDetail.Status = (int)StockStatusEmun.鍏ュ簱瀹屾垚;
+ _logger.LogInformation($"搴撳瓨鐘舵�佹洿鏂颁负鍏ュ簱瀹屾垚 - 鏉＄爜: {barcode}");
+ }
+ else if (stockDetail.StockQuantity > 0)
+ {
+ stockDetail.Status = (int)StockStatusEmun.鍑哄簱閿佸畾;
+ _logger.LogInformation($"搴撳瓨鐘舵�佷繚鎸佷负鍑哄簱閿佸畾 - 鏉＄爜: {barcode}");
+ }
+
+ await _stockInfoDetailService.Db.Updateable(stockDetail).ExecuteCommandAsync();
+
+ // 鏍囪涓哄凡澶勭悊
+ processedBarcodes.Add(barcode);
+
+ _logger.LogInformation($"鏉＄爜鍥炲簱瀹屾垚 - {barcode}: " +
+ $"搴撳瓨 {originalStockQty} -> {stockDetail.StockQuantity}, " +
+ $"鍑哄簱 {originalOutboundQty} -> {stockDetail.OutboundQuantity}, " +
+ $"鐘舵�� {originalStatus} -> {stockDetail.Status}");
+ }
+
+ /// <summary>
+ /// 澶勭悊鎷嗗寘璁板綍鍥炲簱 - 閬垮厤閲嶅
+ /// </summary>
+ private async Task HandleSplitRecordsReturn(List<Dt_SplitPackageRecord> splitRecords, int stockId, HashSet<string> processedBarcodes)
+ {
+ if (!splitRecords.Any())
+ return;
+
+ _logger.LogInformation($"寮�濮嬪鐞嗘媶鍖呰褰曞洖搴� - 鍏� {splitRecords.Count} 鏉¤褰�");
+
+ foreach (var splitRecord in splitRecords)
+ {
+ // 鍙鐞嗘湭鎾ら攢鐨勬媶鍖呰褰�
+ if (splitRecord.IsReverted)
+ {
+ _logger.LogInformation($"璺宠繃宸叉挙閿�鐨勬媶鍖呰褰� - ID: {splitRecord.Id}");
+ continue;
+ }
+
+ // 澶勭悊鏂版潯鐮�
+ if (!string.IsNullOrEmpty(splitRecord.NewBarcode) && !processedBarcodes.Contains(splitRecord.NewBarcode))
+ {
+ var newStock = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
+ .FirstAsync(x => x.Barcode == splitRecord.NewBarcode && x.StockId == stockId);
+
+ if (newStock != null && newStock.StockQuantity > 0)
+ {
+ // 鎷嗗寘鐨勬柊鏉＄爜鍥炲簱鏁伴噺搴旇鏄叾搴撳瓨鏁伴噺
+ await ProcessBarcodeReturn(splitRecord.NewBarcode, stockId, newStock.StockQuantity, processedBarcodes);
+ }
+ }
+
+ // 澶勭悊鍘熸潯鐮�
+ if (!string.IsNullOrEmpty(splitRecord.OriginalBarcode) && !processedBarcodes.Contains(splitRecord.OriginalBarcode))
+ {
+ var originalStock = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
+ .FirstAsync(x => x.Barcode == splitRecord.OriginalBarcode && x.StockId == stockId);
+
+ if (originalStock != null && originalStock.StockQuantity > 0)
+ {
+ // 鍘熸潯鐮佺殑鍥炲簱鏁伴噺搴旇鏄媶鍖呭悗鍓╀綑鐨勬暟閲�
+ await ProcessBarcodeReturn(splitRecord.OriginalBarcode, stockId, originalStock.StockQuantity, processedBarcodes);
+ }
+ }
+
+ // 鏇存柊鎷嗗寘璁板綍鐘舵�佷负宸插洖搴�
+ splitRecord.Status = (int)SplitPackageStatusEnum.宸插洖搴�;
+ await _splitPackageService.Db.Updateable(splitRecord).ExecuteCommandAsync();
+
+ _logger.LogInformation($"鎷嗗寘璁板綍鐘舵�佹洿鏂颁负宸插洖搴� - 璁板綍ID: {splitRecord.Id}");
+ }
+
+ _logger.LogInformation($"鎷嗗寘璁板綍鍥炲簱澶勭悊瀹屾垚");
+ }
+
+ /// <summary>
+ /// 绠�鍖栫増鍥炲簱鏂规硶 - 缁曡繃澶嶆潅楠岃瘉
+ /// </summary>
+ public async Task<WebResponseContent> SimplePalletReturn(string orderNo, string palletCode, string returnReason = "绠�鍖栧洖搴�")
+ {
+ try
+ {
+ _logger.LogInformation($"銆愮畝鍖栧洖搴撳紑濮嬨�戣鍗�: {orderNo}, 鎵樼洏: {palletCode}");
+
+ _unitOfWorkManage.BeginTran();
+
+ // 1. 鑾峰彇搴撳瓨淇℃伅锛堣烦杩囧鏉傞獙璇侊級
+ var stockInfo = await _stockInfoService.Db.Queryable<Dt_StockInfo>()
+ .FirstAsync(x => x.PalletCode == palletCode);
+
+ if (stockInfo == null)
+ {
+ _unitOfWorkManage.RollbackTran();
+ return WebResponseContent.Instance.Error($"鏈壘鍒版墭鐩� {palletCode} 瀵瑰簲鐨勫簱瀛樹俊鎭�");
+ }
+
+ // 2. 鐩存帴鏌ユ壘闇�瑕佸洖搴撶殑鏉＄爜锛堢畝鍖栭�昏緫锛�
+ var barcodesToReturn = await GetBarcodesForSimpleReturn(orderNo, palletCode, stockInfo.Id);
+
+ if (!barcodesToReturn.Any())
+ {
+ try
+ {
+ _logger.LogInformation($"銆愭棤鍥炲簱鐗╁搧銆戝鐞嗙┖鎵樼洏");
+ var result = await HandleEmptyPalletReturn(orderNo, palletCode, stockInfo);
+ _unitOfWorkManage.CommitTran();
+ return result;
+ }
+ catch (Exception ex)
+ {
+ _unitOfWorkManage.RollbackTran();
+ _logger.LogError($"绌虹鍥炲簱澶辫触: {ex.Message}");
+ return WebResponseContent.Instance.Error($"绌虹鍥炲簱澶辫触锛歿ex.Message}");
+ }
+ }
+
+ // 3. 绠�鍖栧鐞嗘瘡涓潯鐮�
+ foreach (var barcode in barcodesToReturn)
+ {
+ await ProcessSimpleBarcodeReturn(barcode, stockInfo.Id);
+ }
+
+ // 4. 鏇存柊璁㈠崟鐘舵�侊紙绠�鍖栵級
+ await UpdateOrderStatusAfterReturn(orderNo);
+
+
+ // 5. 鍒涘缓鍥炲簱浠诲姟
+ await CreateReturnTask(orderNo, palletCode, stockInfo);
+
+ _unitOfWorkManage.CommitTran();
+ return WebResponseContent.Instance.OK($"绠�鍖栧洖搴撴垚鍔燂紝澶勭悊 {barcodesToReturn.Count} 涓潯鐮�");
+ }
+ catch (Exception ex)
+ {
+ _unitOfWorkManage.RollbackTran();
+ _logger.LogError($"绠�鍖栧洖搴撳け璐�: {ex.Message}");
+ return WebResponseContent.Instance.Error($"鍥炲簱澶辫触: {ex.Message}");
+ }
+ }
+ /// <summary>
+ /// 绠�鍖栬幏鍙栧洖搴撴潯鐮�
+ /// </summary>
+ private async Task<List<string>> GetBarcodesForSimpleReturn(string orderNo, string palletCode, int stockId)
+ {
+ var barcodes = new List<string>();
+
+ try
+ {
+ // 1. 浠庨攣瀹氳褰曡幏鍙�
+ var lockInfos = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
+ .Where(x => x.OrderNo == orderNo && x.PalletCode == palletCode)
+ .Select(x => x.CurrentBarcode)
+ .ToListAsync();
+
+ barcodes.AddRange(lockInfos.Where(b => !string.IsNullOrEmpty(b)));
+
+ // 2. 浠庡簱瀛樻槑缁嗚幏鍙�
+ var stockDetails = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
+ .Where(x => x.StockId == stockId && x.StockQuantity > 0)
+ .Select(x => x.Barcode)
+ .ToListAsync();
+
+ barcodes.AddRange(stockDetails.Where(b => !string.IsNullOrEmpty(b)));
+
+ // 鍘婚噸
+ return barcodes.Distinct().ToList();
+ }
+ catch (Exception ex)
+ {
+ _logger.LogError($"鑾峰彇鍥炲簱鏉＄爜澶辫触: {ex.Message}");
+ return barcodes;
+ }
+ }
+
+ /// <summary>
+ /// 绠�鍖栧鐞嗘潯鐮佸洖搴�
+ /// </summary>
+ private async Task ProcessSimpleBarcodeReturn(string barcode, int stockId)
+ {
+ try
+ {
+ // 1. 鑾峰彇搴撳瓨鏄庣粏
+ var stockDetail = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
+ .FirstAsync(x => x.Barcode == barcode && x.StockId == stockId);
+
+ if (stockDetail == null)
+ {
+ _logger.LogWarning($"鏈壘鍒版潯鐮佸搴旂殑搴撳瓨鏄庣粏: {barcode}");
+ return;
+ }
+
+ // 2. 濡傛灉鏄嚭搴撻攣瀹氱姸鎬侊紝鎭㈠涓哄叆搴撳畬鎴�
+ if (stockDetail.Status == (int)StockStatusEmun.鍑哄簱閿佸畾)
+ {
+ stockDetail.Status = (int)StockStatusEmun.鍏ュ簱瀹屾垚;
+ await _stockInfoDetailService.Db.Updateable(stockDetail).ExecuteCommandAsync();
+ _logger.LogInformation($"鏉＄爜鐘舵�佹仮澶� - {barcode}: 鍑哄簱閿佸畾 -> 鍏ュ簱瀹屾垚");
+ }
+
+ // 3. 鏇存柊鐩稿叧鐨勯攣瀹氳褰�
+ var lockInfos = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
+ .Where(x => x.CurrentBarcode == barcode &&
+ (x.Status == (int)OutLockStockStatusEnum.鍑哄簱涓� ||
+ x.Status == (int)OutLockStockStatusEnum.鎷ｉ�夊畬鎴�))
+ .ToListAsync();
+
+ foreach (var lockInfo in lockInfos)
+ {
+ lockInfo.Status = (int)OutLockStockStatusEnum.宸插洖搴�;
+ lockInfo.Operator = App.User.UserName;
+ await _outStockLockInfoService.Db.Updateable(lockInfo).ExecuteCommandAsync();
+ _logger.LogInformation($"閿佸畾璁板綍鐘舵�佹洿鏂� - ID: {lockInfo.Id}: 宸插洖搴�");
+ }
+ }
+ catch (Exception ex)
+ {
+ _logger.LogError($"澶勭悊鏉＄爜鍥炲簱澶辫触 - 鏉＄爜: {barcode}, Error: {ex.Message}");
+ }
+ }
+ #endregion
+
+ #region 杈呭姪鏂规硶
+
+ /// <summary>
+ /// 澶勭悊娌℃湁鍥炲簱鐗╁搧鐨勬儏鍐�
+ /// </summary>
+ private async Task<WebResponseContent> HandleNoReturnItems(string orderNo, string palletCode, Dt_Task originalTask, int stockId)
+ {
+ _logger.LogInformation($"鎵樼洏 {palletCode} 娌℃湁闇�瑕佸洖搴撶殑鐗╁搧");
+
+ // 妫�鏌ユ槸鍚︽槸绌烘墭鐩�
+ var statusAnalysis = await AnalyzePalletStatus(orderNo, palletCode, stockId);
+ if (statusAnalysis.IsEmptyPallet)
+ {
+ try
+ {
+ var locationtype = 0;
+ var stockInfo = await _stockInfoService.Db.Queryable<Dt_StockInfo>()
+ .Where(x => x.PalletCode == palletCode)
+ .FirstAsync();
+
+ if (stockInfo == null)
+ {
+ var firstLocation = await _locationInfoService.Db.Queryable<Dt_LocationInfo>().FirstAsync(x => x.LocationCode == originalTask.SourceAddress);
+ locationtype = firstLocation?.LocationType ?? 1;
+ }
+ else
+ {
+ locationtype = stockInfo.LocationType;
+ _stockInfoService.DeleteData(stockInfo);
+ }
+
+ var targetAddress = originalTask.TargetAddress;
+
+ await CleanupZeroStockData(stockId);
+
+
+ var emptystockInfo = new Dt_StockInfo() { PalletType = PalletTypeEnum.Empty.ObjToInt(), StockStatus = StockStatusEmun.缁勭洏鏆傚瓨.ObjToInt(), PalletCode = palletCode, LocationType = locationtype };
+ emptystockInfo.Details = new List<Dt_StockInfoDetail>();
+ _stockInfoService.AddMaterielGroup(emptystockInfo);
+ //绌烘墭鐩樺浣曞鐞� 杩樻湁涓�涓嚭搴撲换鍔¤澶勭悊銆�
+ originalTask.PalletType = PalletTypeEnum.Empty.ObjToInt();
+
+ await CreateReturnTaskAndHandleESS(orderNo, palletCode, originalTask, TaskTypeEnum.InEmpty, PalletTypeEnum.Empty.ObjToInt());
+
+ }
+ catch (Exception ex)
+ {
+ _logger.LogError($" HandleNoReturnItems 澶辫触: {ex.Message}");
+ return WebResponseContent.Instance.Error($" 鍥炲簱绌烘墭鐩樺け璐ワ紒");
+ }
+ return WebResponseContent.Instance.OK("绌烘墭鐩樺洖搴撲换鍔″垱寤烘垚鍔�");
+ }
+ else
+ {
+ return WebResponseContent.Instance.Error("鎵樼洏鐘舵�佸紓甯革細鏈夌墿鍝佷絾鏃犳硶璁＄畻鍥炲簱鏁伴噺");
+ }
+ }
+ private async Task CleanupZeroStockData(int stockId)
+ {
+ try
+ {
+ // 1. 鍒犻櫎搴撳瓨鏁伴噺涓�0鐨勬槑缁嗚褰�
+ var deleteDetailCount = await _stockInfoDetailService.Db.Deleteable<Dt_StockInfoDetail>()
+ .Where(x => x.StockId == stockId && x.StockQuantity == 0)
+ .ExecuteCommandAsync();
+
+ await _stockInfoService.Db.Deleteable<Dt_StockInfo>()
+ .Where(x => x.Id == stockId).ExecuteCommandAsync();
+
+ _logger.LogInformation($"娓呯悊闆跺簱瀛樻槑缁嗚褰� - StockId: {stockId}, 鍒犻櫎璁板綍鏁�: {deleteDetailCount}");
+
+
+
+ }
+ catch (Exception ex)
+ {
+ _logger.LogWarning($"娓呯悊闆跺簱瀛樻暟鎹け璐� - StockId: {stockId}, Error: {ex.Message}");
+ // 娉ㄦ剰锛氭竻鐞嗗け璐ヤ笉搴旇褰卞搷涓绘祦绋�
+ }
+ }
+ /// <summary>
+ /// 鏇存柊璁㈠崟鐘舵�侊紙鍥炲簱鍚庯級
+ /// </summary>
+ private async Task UpdateOrderStatusForReturn(string orderNo)
+ {
+ // 妫�鏌ヨ鍗曟槸鍚︽墍鏈夋墭鐩橀兘宸插畬鎴愭垨宸插洖搴�
+ var allLocks = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
+ .Where(x => x.OrderNo == orderNo)
+ .ToListAsync();
+
+ var activeLocks = allLocks.Where(x =>
+ x.Status == (int)OutLockStockStatusEnum.鍑哄簱涓� ||
+ x.Status == (int)OutLockStockStatusEnum.鍥炲簱涓�).ToList();
+
+ // 濡傛灉娌℃湁娲昏穬鐨勯攣瀹氳褰曪紝鏇存柊璁㈠崟鐘舵��
+ if (!activeLocks.Any())
+ {
+ await _outboundOrderService.Db.Updateable<Dt_OutboundOrder>()
+ .SetColumns(x => new Dt_OutboundOrder
+ {
+ OrderStatus = (int)OutOrderStatusEnum.鍑哄簱瀹屾垚,
+ })
+ .Where(x => x.OrderNo == orderNo)
+ .ExecuteCommandAsync();
+
+ _logger.LogInformation($"鏇存柊璁㈠崟鐘舵�佷负鍑哄簱瀹屾垚 - 璁㈠崟: {orderNo}");
}
}
#endregion
+
+
+
#region 楠岃瘉鏂规硶
private async Task<ValidationResult<(Dt_OutStockLockInfo, Dt_OutboundOrderDetail, Dt_StockInfoDetail, Dt_OutboundBatch)>> ValidatePickingRequest(
- string orderNo, string palletCode, string barcode)
+ string orderNo, string palletCode, string barcode)
{
+ _logger.LogInformation($"寮�濮嬮獙璇佸垎鎷ｈ姹� - 璁㈠崟: {orderNo}, 鎵樼洏: {palletCode}, 鏉＄爜: {barcode}");
+
// 鏌ユ壘閿佸畾淇℃伅
var lockInfo = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
.Where(x => x.OrderNo == orderNo &&
@@ -1014,6 +4324,13 @@
if (lockInfo == null)
return ValidationResult<(Dt_OutStockLockInfo, Dt_OutboundOrderDetail, Dt_StockInfoDetail, Dt_OutboundBatch)>.Error("鏈壘鍒版湁鏁堢殑閿佸畾淇℃伅");
+ if (lockInfo.IsUnallocated == 1 || lockInfo.OrderDetailId == 0)
+ {
+ return ValidationResult<(Dt_OutStockLockInfo, Dt_OutboundOrderDetail, Dt_StockInfoDetail, Dt_OutboundBatch)>.Error("璇ユ潯鐮佹槸鏈垎閰嶉攣瀹氳褰曪紝涓嶈兘鐩存帴鍒嗘嫞");
+ }
+
+ _logger.LogInformation($"鎵惧埌閿佸畾淇℃伅 - 鍒嗛厤鏁伴噺: {lockInfo.AssignQuantity}, 宸叉嫞閫�: {lockInfo.PickedQty}");
+
// 妫�鏌ユ槸鍚﹀凡缁忓垎鎷ｅ畬鎴�
if (lockInfo.PickedQty >= lockInfo.AssignQuantity)
return ValidationResult<(Dt_OutStockLockInfo, Dt_OutboundOrderDetail, Dt_StockInfoDetail, Dt_OutboundBatch)>.Error("璇ユ潯鐮佸凡鍒嗘嫞瀹屾垚");
@@ -1022,111 +4339,125 @@
var orderDetail = await _outboundOrderDetailService.Db.Queryable<Dt_OutboundOrderDetail>()
.FirstAsync(x => x.Id == lockInfo.OrderDetailId);
+ if (orderDetail == null)
+ return ValidationResult<(Dt_OutStockLockInfo, Dt_OutboundOrderDetail, Dt_StockInfoDetail, Dt_OutboundBatch)>.Error("鏈壘鍒拌鍗曟槑缁�");
+
+ _logger.LogInformation($"鎵惧埌璁㈠崟鏄庣粏 - 宸插垎閰嶆暟閲�: {orderDetail.AllocatedQuantity}, 閿佸畾鏁伴噺: {orderDetail.LockQuantity}");
+
+ // 妫�鏌ヨ鍗曟槑缁嗙殑宸插垎閰嶆暟閲忔槸鍚﹁冻澶�
+ decimal remainingToPick = lockInfo.AssignQuantity - lockInfo.PickedQty;
+
+ // 杩欓噷搴旇妫�鏌ラ攣瀹氫俊鎭殑鍒嗛厤鏁伴噺锛岃�屼笉鏄鍗曟槑缁嗙殑鍒嗛厤鏁伴噺
+ // 鍥犱负鎷嗗寘鍚庯紝閿佸畾淇℃伅鐨勫垎閰嶆暟閲忓彲鑳藉皬浜庤鍗曟槑缁嗙殑鍒嗛厤鏁伴噺
+ if (lockInfo.AssignQuantity < remainingToPick)
+ {
+ _logger.LogWarning($"閿佸畾淇℃伅鍒嗛厤鏁伴噺涓嶈冻 - 闇�瑕佹嫞閫�: {remainingToPick}, 閿佸畾淇℃伅鍒嗛厤鏁伴噺: {lockInfo.AssignQuantity}");
+ return ValidationResult<(Dt_OutStockLockInfo, Dt_OutboundOrderDetail, Dt_StockInfoDetail, Dt_OutboundBatch)>.Error(
+ $"閿佸畾淇℃伅鍒嗛厤鏁伴噺涓嶈冻锛岄渶瑕佹嫞閫夛細{remainingToPick}锛岄攣瀹氫俊鎭垎閰嶆暟閲忥細{lockInfo.AssignQuantity}");
+ }
+
+ // 妫�鏌ラ攣瀹氭暟閲忔槸鍚﹁冻澶�
+ if (orderDetail.LockQuantity < remainingToPick)
+ {
+ _logger.LogWarning($"璁㈠崟鏄庣粏閿佸畾鏁伴噺涓嶈冻 - 闇�瑕佹嫞閫�: {remainingToPick}, 鍙敤閿佸畾鏁伴噺: {orderDetail.LockQuantity}");
+ return ValidationResult<(Dt_OutStockLockInfo, Dt_OutboundOrderDetail, Dt_StockInfoDetail, Dt_OutboundBatch)>.Error(
+ $"璁㈠崟鏄庣粏閿佸畾鏁伴噺涓嶈冻锛岄渶瑕佹嫞閫夛細{remainingToPick}锛屽彲鐢ㄩ攣瀹氭暟閲忥細{orderDetail.LockQuantity}");
+ }
+
+ // 妫�鏌ヨ鍗曟槑缁嗗垎閰嶆暟閲忔槸鍚︿负璐熸暟
+ if (orderDetail.AllocatedQuantity < 0)
+ {
+ _logger.LogError($"璁㈠崟鏄庣粏鍒嗛厤鏁伴噺涓鸿礋鏁� - 褰撳墠鍊�: {orderDetail.AllocatedQuantity}");
+ return ValidationResult<(Dt_OutStockLockInfo, Dt_OutboundOrderDetail, Dt_StockInfoDetail, Dt_OutboundBatch)>.Error(
+ $"璁㈠崟鏄庣粏鍒嗛厤鏁伴噺寮傚父锛堣礋鏁帮級锛岃鑱旂郴绠＄悊鍛樺鐞�");
+ }
+
var stockDetail = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
.FirstAsync(x => x.Barcode == barcode && x.StockId == lockInfo.StockId);
- // 楠岃瘉搴撳瓨鏁伴噺
- if (stockDetail.StockQuantity < lockInfo.AssignQuantity)
- return ValidationResult<(Dt_OutStockLockInfo, Dt_OutboundOrderDetail, Dt_StockInfoDetail, Dt_OutboundBatch)>.Error(
- $"搴撳瓨鏁伴噺涓嶈冻锛岄渶瑕侊細{lockInfo.AssignQuantity}锛屽疄闄咃細{stockDetail.StockQuantity}");
+ if (stockDetail == null)
+ return ValidationResult<(Dt_OutStockLockInfo, Dt_OutboundOrderDetail, Dt_StockInfoDetail, Dt_OutboundBatch)>.Error("鏈壘鍒板搴旂殑搴撳瓨淇℃伅");
+ // 楠岃瘉搴撳瓨鏁伴噺
+ if (stockDetail.StockQuantity < remainingToPick)
+ return ValidationResult<(Dt_OutStockLockInfo, Dt_OutboundOrderDetail, Dt_StockInfoDetail, Dt_OutboundBatch)>.Error(
+ $"搴撳瓨鏁伴噺涓嶈冻锛岄渶瑕佹嫞閫夛細{remainingToPick}锛屽疄闄呭簱瀛橈細{stockDetail.StockQuantity}");
+
+ // 楠岃瘉搴撳瓨鐘舵��
+ //if (stockDetail.Status != (int)StockStatusEmun.鍑哄簱閿佸畾)
+ //{
+ // return ValidationResult<(Dt_OutStockLockInfo, Dt_OutboundOrderDetail, Dt_StockInfoDetail, Dt_OutboundBatch)>.Error(
+ // $"搴撳瓨鐘舵�佸紓甯革紝褰撳墠鐘舵�侊細{stockDetail.Status}锛屾湡鏈涚姸鎬侊細鍑哄簱閿佸畾");
+ //}
+
+ // 浣跨敤 OutboundBatchNo 鏌ユ壘鎵规
var batch = await _outboundBatchRepository.Db.Queryable<Dt_OutboundBatch>()
.FirstAsync(x => x.BatchNo == lockInfo.OutboundBatchNo);
+
+ _logger.LogInformation($"鍒嗘嫞楠岃瘉閫氳繃 - 鏉＄爜: {barcode}, 鍓╀綑闇�鎷ｉ��: {remainingToPick}, 鍙敤搴撳瓨: {stockDetail.StockQuantity}");
return ValidationResult<(Dt_OutStockLockInfo, Dt_OutboundOrderDetail, Dt_StockInfoDetail, Dt_OutboundBatch)>.Success((lockInfo, orderDetail, stockDetail, batch));
}
- private async Task<ValidationResult<(Dt_OutStockLockInfo, Dt_StockInfoDetail)>> ValidateSplitRequest(
- string orderNo, string palletCode, string originalBarcode, decimal splitQuantity)
+
+ /// <summary>
+ /// 妫�鏌ュ苟鎵ц鑷姩鎷嗗寘锛堝鏋滈渶瑕侊級
+ /// </summary>
+ private async Task<List<SplitResult>> CheckAndAutoSplitIfNeeded(Dt_OutStockLockInfo lockInfo, Dt_StockInfoDetail stockDetail, string palletCode)
{
- var lockInfo = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
- .Where(x => x.OrderNo == orderNo &&
- x.PalletCode == palletCode &&
- x.CurrentBarcode == originalBarcode &&
- x.Status == (int)OutLockStockStatusEnum.鍑哄簱涓�)
- .FirstAsync();
-
- if (lockInfo == null)
- return ValidationResult<(Dt_OutStockLockInfo, Dt_StockInfoDetail)>.Error("鏈壘鍒版湁鏁堢殑閿佸畾淇℃伅");
-
- var stockDetail = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
- .FirstAsync(x => x.Barcode == originalBarcode && x.StockId == lockInfo.StockId);
-
- if (stockDetail.StockQuantity < splitQuantity)
- return ValidationResult<(Dt_OutStockLockInfo, Dt_StockInfoDetail)>.Error("鎷嗗寘鏁伴噺涓嶈兘澶т簬搴撳瓨鏁伴噺");
-
- if (lockInfo.AssignQuantity - lockInfo.PickedQty < splitQuantity)
- return ValidationResult<(Dt_OutStockLockInfo, Dt_StockInfoDetail)>.Error("鎷嗗寘鏁伴噺涓嶈兘澶т簬鏈嫞閫夋暟閲�");
-
- return ValidationResult<(Dt_OutStockLockInfo, Dt_StockInfoDetail)>.Success((lockInfo, stockDetail));
- }
-
- #endregion
-
- #region 鏍稿績閫昏緫鏂规硶
-
- private async Task<PickingResult> ExecutePickingLogic(
- Dt_OutStockLockInfo lockInfo, Dt_OutboundOrderDetail orderDetail,
- Dt_StockInfoDetail stockDetail, decimal actualPickedQty)
- {
- // 鏇存柊閿佸畾淇℃伅
- lockInfo.PickedQty += actualPickedQty;
- if (lockInfo.PickedQty >= lockInfo.AssignQuantity)
+ if (lockInfo.IsUnallocated == 1 || lockInfo.OrderDetailId == 0)
{
- lockInfo.Status = (int)OutLockStockStatusEnum.鎷ｉ�夊畬鎴�;
+ _logger.LogInformation($"璺宠繃鏈垎閰嶉攣瀹氳褰曠殑鑷姩鎷嗗寘妫�鏌� - 閿佸畾ID: {lockInfo.Id}");
+ return null;
}
- await _outStockLockInfoService.Db.Updateable(lockInfo).ExecuteCommandAsync();
+ // 妫�鏌ユ槸鍚﹂渶瑕佽嚜鍔ㄦ媶鍖呯殑鏉′欢锛�
+ // 1. 搴撳瓨鏁伴噺澶т簬鍒嗛厤鏁伴噺
+ // 2. 閿佸畾淇℃伅鐘舵�佷负鍑哄簱涓�
+ // 3. 鏈嫞閫夋暟閲忕瓑浜庡垎閰嶆暟閲忥紙琛ㄧず杩樻湭寮�濮嬫嫞閫夛級
+ bool needAutoSplit = stockDetail.StockQuantity > lockInfo.AssignQuantity &&
+ lockInfo.Status == (int)OutLockStockStatusEnum.鍑哄簱涓� &&
+ lockInfo.PickedQty == 0;
- // 鏇存柊搴撳瓨
- stockDetail.StockQuantity -= actualPickedQty;
- stockDetail.OutboundQuantity += actualPickedQty;
+ if (!needAutoSplit)
+ return null;
- if (stockDetail.StockQuantity <= 0)
- {
- stockDetail.Status = (int)StockStatusEmun.鍑哄簱瀹屾垚;
- }
- await _stockInfoDetailService.Db.Updateable(stockDetail).ExecuteCommandAsync();
+ // 璁＄畻鎷嗗寘鏁伴噺 = 搴撳瓨鏁伴噺 - 鍒嗛厤鏁伴噺
+ decimal splitQuantity = stockDetail.StockQuantity - lockInfo.AssignQuantity;
- return new PickingResult
- {
- FinalLockInfo = lockInfo,
- ActualPickedQty = actualPickedQty
- };
+ // 鎵ц鑷姩鎷嗗寘
+ var splitResult = await ExecuteAutoSplitLogic(lockInfo, stockDetail, splitQuantity, palletCode);
+
+ return splitResult;
}
- private async Task<RevertPickingResult> RevertPickingData(Dt_PickingRecord pickingRecord)
- {
- // 鎭㈠閿佸畾淇℃伅
- var lockInfo = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
- .FirstAsync(x => x.Id == pickingRecord.OutStockLockId);
-
- lockInfo.PickedQty -= pickingRecord.PickQuantity;
- lockInfo.Status = (int)OutLockStockStatusEnum.鍑哄簱涓�;
- await _outStockLockInfoService.Db.Updateable(lockInfo).ExecuteCommandAsync();
-
- // 鎭㈠搴撳瓨
- var stockDetail = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
- .FirstAsync(x => x.Barcode == pickingRecord.Barcode);
-
- stockDetail.StockQuantity += pickingRecord.PickQuantity;
- stockDetail.OutboundQuantity -= pickingRecord.PickQuantity;
- stockDetail.Status = (int)StockStatusEmun.鍑哄簱閿佸畾;
- await _stockInfoDetailService.Db.Updateable(stockDetail).ExecuteCommandAsync();
-
- return new RevertPickingResult
- {
- LockInfo = lockInfo,
- StockDetail = stockDetail
- };
- }
-
- private async Task<SplitResultDto> ExecuteSplitLogic(Dt_OutStockLockInfo lockInfo, Dt_StockInfoDetail stockDetail,
+ /// <summary>
+ /// 鎵ц鑷姩鎷嗗寘閫昏緫
+ /// 纭繚鑷姩鎷嗗寘涓嶄細褰卞搷鍥炲簱閫昏緫
+ /// </summary>
+ private async Task<List<SplitResult>> ExecuteAutoSplitLogic(Dt_OutStockLockInfo lockInfo, Dt_StockInfoDetail stockDetail,
decimal splitQuantity, string palletCode)
{
+ _logger.LogInformation($"寮�濮嬫墽琛岃嚜鍔ㄦ媶鍖呴�昏緫 - 鍘熸潯鐮�: {stockDetail.Barcode}, 鎷嗗寘鏁伴噺: {splitQuantity}");
+
+ // 楠岃瘉鎷嗗寘鏁伴噺鍚堢悊鎬�
+ if (splitQuantity <= 0)
+ {
+ throw new InvalidOperationException($"鎷嗗寘鏁伴噺蹇呴』澶т簬0锛屽綋鍓嶅��: {splitQuantity}");
+ }
+
+ if (stockDetail.StockQuantity < lockInfo.AssignQuantity + splitQuantity)
+ {
+ throw new InvalidOperationException($"搴撳瓨鏁伴噺涓嶈冻浠ヨ繘琛岃嚜鍔ㄦ媶鍖�");
+ }
+
// 鐢熸垚鏂版潯鐮�
string newBarcode = await GenerateNewBarcode();
- // 鍒涘缓鏂板簱瀛樻槑缁�
+ // 璁板綍鎷嗗寘鍓嶇殑鍒嗛厤鏁伴噺
+ decimal originalAssignQty = lockInfo.AssignQuantity;
+ decimal remainQty = originalAssignQty; // 鍘熼攣瀹氫俊鎭垎閰嶆暟閲忎繚鎸佷笉鍙�
+
+ // 鍒涘缓鏂板簱瀛樻槑缁嗭紙澶氫綑閮ㄥ垎锛�
var newStockDetail = new Dt_StockInfoDetail
{
StockId = stockDetail.StockId,
@@ -1139,30 +4470,25 @@
Status = (int)StockStatusEmun.鍑哄簱閿佸畾,
SupplyCode = stockDetail.SupplyCode,
Unit = stockDetail.Unit,
- BarcodeQty=stockDetail.BarcodeQty,
- BarcodeUnit=stockDetail.BarcodeUnit,
- BusinessType=stockDetail.BusinessType,
- InboundOrderRowNo=stockDetail.InboundOrderRowNo,
-
-
+ BarcodeQty = stockDetail.BarcodeQty,
+ BarcodeUnit = stockDetail.BarcodeUnit,
+ BusinessType = stockDetail.BusinessType,
+ InboundOrderRowNo = stockDetail.InboundOrderRowNo,
};
+
await _stockInfoDetailService.Db.Insertable(newStockDetail).ExecuteCommandAsync();
+ _logger.LogInformation($"鍒涘缓鏂板簱瀛樻槑缁� - 鏉＄爜: {newBarcode}, 搴撳瓨鏁伴噺: {splitQuantity}");
- // 鏇存柊鍘熷簱瀛樻槑缁�
- stockDetail.StockQuantity -= splitQuantity;
- await _stockInfoDetailService.Db.Updateable(stockDetail).ExecuteCommandAsync();
-
-
+ // 鍒涘缓鏂伴攣瀹氫俊鎭紙澶氫綑閮ㄥ垎锛�- 鏍囪涓烘湭鍒嗛厤
var newLockInfo = new Dt_OutStockLockInfo
{
OrderNo = lockInfo.OrderNo,
- OrderDetailId = lockInfo.OrderDetailId,
- BatchNo = lockInfo.BatchNo,
+ OrderDetailId = 0, // 閲嶈锛氫笉缁戝畾鍒板叿浣撹鍗曟槑缁�
+ OutboundBatchNo = lockInfo.OutboundBatchNo,
MaterielCode = lockInfo.MaterielCode,
MaterielName = lockInfo.MaterielName,
StockId = lockInfo.StockId,
OrderQuantity = splitQuantity,
- //OriginalQuantity = quantity,
AssignQuantity = splitQuantity,
PickedQty = 0,
LocationCode = lockInfo.LocationCode,
@@ -1173,7 +4499,6 @@
SupplyCode = lockInfo.SupplyCode,
OrderType = lockInfo.OrderType,
CurrentBarcode = newBarcode,
- // OriginalLockQuantity = quantity,
IsSplitted = 1,
ParentLockId = lockInfo.Id,
Operator = App.User.UserName,
@@ -1182,54 +4507,239 @@
WarehouseCode = lockInfo.WarehouseCode,
BarcodeQty = lockInfo.BarcodeQty,
BarcodeUnit = lockInfo.BarcodeUnit,
-
+ IsUnallocated = 1 // 鏍囪涓烘湭鍒嗛厤
};
await _outStockLockInfoService.Db.Insertable(newLockInfo).ExecuteCommandAsync();
+ _logger.LogInformation($"鍒涘缓鏂伴攣瀹氫俊鎭� - 鏉＄爜: {newBarcode}, 鍒嗛厤鏁伴噺: {splitQuantity}, 鏍囪涓烘湭鍒嗛厤");
- // 鏇存柊鍘熼攣瀹氫俊鎭�
- lockInfo.AssignQuantity -= splitQuantity;
- lockInfo.OrderQuantity -= splitQuantity;
- await _outStockLockInfoService.Db.Updateable(lockInfo).ExecuteCommandAsync();
+ // 閲嶈锛氳嚜鍔ㄦ媶鍖呴渶瑕佸鍔犺鍗曟槑缁嗙殑鍒嗛厤鏁伴噺鍜岄攣瀹氭暟閲�
+ var orderDetail = await _outboundOrderDetailService.Db.Queryable<Dt_OutboundOrderDetail>()
+ .FirstAsync(x => x.Id == lockInfo.OrderDetailId);
+
+ if (orderDetail != null)
+ {
+ decimal originalAllocated = orderDetail.AllocatedQuantity;
+ decimal originalLock = orderDetail.LockQuantity;
+
+ orderDetail.AllocatedQuantity += splitQuantity;
+ orderDetail.LockQuantity += splitQuantity;
+
+ await UpdateBatchAllocateStatus(orderDetail);
+ await _outboundOrderDetailService.Db.Updateable(orderDetail).ExecuteCommandAsync();
+
+ _logger.LogInformation($"鑷姩鎷嗗寘澧炲姞璁㈠崟鏄庣粏鍒嗛厤 - 鍒嗛厤鏁伴噺: {originalAllocated} -> {orderDetail.AllocatedQuantity}, " +
+ $"閿佸畾鏁伴噺: {originalLock} -> {orderDetail.LockQuantity}");
+ }
// 璁板綍鎷嗗寘鍘嗗彶
- await RecordSplitHistory(lockInfo, stockDetail, splitQuantity, newBarcode);
+ await RecordSplitHistory(lockInfo, stockDetail, splitQuantity, newBarcode, true, stockDetail.StockQuantity);
- return new SplitResultDto { NewBarcode = newBarcode };
+ // 鍒涘缓鎷嗗寘缁撴灉鍒楄〃
+ var splitResults = CreateSplitResults(lockInfo, splitQuantity, remainQty, newBarcode, stockDetail.Barcode);
+
+ _logger.LogInformation($"鑷姩鎷嗗寘閫昏緫鎵ц瀹屾垚");
+
+ return splitResults;
}
- private async Task ExecuteCancelSplitLogic(Dt_SplitPackageRecord splitRecord, Dt_OutStockLockInfo newLockInfo, Dt_StockInfoDetail newStockDetail)
+ /// <summary>
+ /// 楠岃瘉鑷姩鎷嗗寘鍚庢暟鎹竴鑷存��
+ /// </summary>
+ private async Task ValidateDataConsistencyAfterAutoSplit(long orderDetailId, decimal originalAllocatedQty, decimal originalLockQty, decimal splitQuantity)
{
- // 鎭㈠鍘熷簱瀛�
- var originalStock = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
- .FirstAsync(x => x.Barcode == splitRecord.OriginalBarcode && x.StockId == splitRecord.StockId);
+ // 閲嶆柊鑾峰彇璁㈠崟鏄庣粏鏁版嵁
+ var orderDetail = await _outboundOrderDetailService.Db.Queryable<Dt_OutboundOrderDetail>()
+ .FirstAsync(x => x.Id == orderDetailId);
- originalStock.StockQuantity += splitRecord.SplitQty;
- await _stockInfoDetailService.Db.Updateable(originalStock).ExecuteCommandAsync();
+ if (orderDetail == null)
+ return;
- // 鎭㈠鍘熼攣瀹氫俊鎭�
- var originalLockInfo = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
- .FirstAsync(x => x.Id == splitRecord.OutStockLockInfoId);
+ // 璁＄畻鎵�鏈夐攣瀹氫俊鎭殑鎬诲垎閰嶆暟閲�
+ var allLocks = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
+ .Where(x => x.OrderDetailId == orderDetailId)
+ .ToListAsync();
- originalLockInfo.AssignQuantity += splitRecord.SplitQty;
- originalLockInfo.OrderQuantity += splitRecord.SplitQty;
- await _outStockLockInfoService.Db.Updateable(originalLockInfo).ExecuteCommandAsync();
+ decimal totalLockAssignQty = allLocks.Sum(x => x.AssignQuantity);
- // 鍒犻櫎鏂板簱瀛樻槑缁�
- await _stockInfoDetailService.Db.Deleteable<Dt_StockInfoDetail>()
- .Where(x => x.Barcode == newLockInfo.CurrentBarcode)
- .ExecuteCommandAsync();
+ _logger.LogInformation($"鑷姩鎷嗗寘鍚庢暟鎹竴鑷存�ч獙璇� - 璁㈠崟鏄庣粏鍒嗛厤鏁伴噺: {orderDetail.AllocatedQuantity}, 閿佸畾淇℃伅鎬诲垎閰嶆暟閲�: {totalLockAssignQty}");
- // 鍒犻櫎鏂伴攣瀹氫俊鎭�
- await _outStockLockInfoService.Db.Deleteable<Dt_OutStockLockInfo>()
- .Where(x => x.Id == newLockInfo.Id)
- .ExecuteCommandAsync();
+ // 楠岃瘉鑷姩鎷嗗寘鍚庣殑鏁版嵁涓�鑷存��
+ decimal expectedAllocatedQty = originalAllocatedQty + splitQuantity;
+ decimal expectedLockQty = originalLockQty + splitQuantity;
- // 鏍囪鎷嗗寘璁板綍涓哄凡鎾ら攢
- splitRecord.IsReverted = true;
- splitRecord.RevertTime = DateTime.Now;
- splitRecord.RevertOperator = App.User.UserName;
- await _splitPackageService.Db.Updateable(splitRecord).ExecuteCommandAsync();
+ if (Math.Abs(orderDetail.AllocatedQuantity - expectedAllocatedQty) > 0.01m)
+ {
+ _logger.LogWarning($"鑷姩鎷嗗寘鍚庡垎閰嶆暟閲忓紓甯� - 鏈熸湜: {expectedAllocatedQty}, 瀹為檯: {orderDetail.AllocatedQuantity}");
+ }
+
+ if (Math.Abs(orderDetail.LockQuantity - expectedLockQty) > 0.01m)
+ {
+ _logger.LogWarning($"鑷姩鎷嗗寘鍚庨攣瀹氭暟閲忓紓甯� - 鏈熸湜: {expectedLockQty}, 瀹為檯: {orderDetail.LockQuantity}");
+ }
+
+ if (Math.Abs(orderDetail.AllocatedQuantity - totalLockAssignQty) > 0.01m)
+ {
+ _logger.LogWarning($"鑷姩鎷嗗寘鍚庢暟鎹笉涓�鑷� - 璁㈠崟鏄庣粏鍒嗛厤鏁伴噺: {orderDetail.AllocatedQuantity}, 閿佸畾淇℃伅鎬诲垎閰嶆暟閲�: {totalLockAssignQty}");
+ }
+ }
+ #endregion
+
+ #region 鏍稿績閫昏緫鏂规硶
+
+ private async Task<PickingResult> ExecutePickingLogic(
+ Dt_OutStockLockInfo lockInfo, Dt_OutboundOrderDetail orderDetail,
+ Dt_StockInfoDetail stockDetail, decimal actualPickedQty)
+ {
+ _logger.LogInformation($"寮�濮嬫墽琛屽垎鎷ｉ�昏緫 - 鏉＄爜: {stockDetail.Barcode}, 鍒嗛厤鏁伴噺: {lockInfo.AssignQuantity}, 瀹為檯鎷ｉ��: {actualPickedQty}");
+
+ // 鍐嶆楠岃瘉璁㈠崟鏄庣粏鐨勫垎閰嶆暟閲忥紙闃叉骞跺彂鎿嶄綔锛�
+ if (orderDetail.AllocatedQuantity < actualPickedQty)
+ {
+ throw new InvalidOperationException($"璁㈠崟鏄庣粏鍒嗛厤鏁伴噺涓嶈冻锛岄渶瑕佹嫞閫� {actualPickedQty}锛屽彲鐢ㄥ垎閰嶆暟閲� {orderDetail.AllocatedQuantity}");
+ }
+
+ if (orderDetail.LockQuantity < actualPickedQty)
+ {
+ throw new InvalidOperationException($"璁㈠崟鏄庣粏閿佸畾鏁伴噺涓嶈冻锛岄渶瑕佹嫞閫� {actualPickedQty}锛屽彲鐢ㄩ攣瀹氭暟閲� {orderDetail.LockQuantity}");
+ }
+
+ // 鏇存柊閿佸畾淇℃伅
+ lockInfo.PickedQty += actualPickedQty;
+ _logger.LogInformation($"鏇存柊閿佸畾淇℃伅 - 宸叉嫞閫夋暟閲忎粠 {lockInfo.PickedQty - actualPickedQty} 澧炲姞鍒� {lockInfo.PickedQty}");
+
+ // 鍑嗙‘鍒ゆ柇鎷ｉ�夊畬鎴愮姸鎬�
+ if (Math.Abs(lockInfo.PickedQty - lockInfo.AssignQuantity) < 0.001m)
+ {
+ lockInfo.Status = (int)OutLockStockStatusEnum.鎷ｉ�夊畬鎴�;
+ _logger.LogInformation($"閿佸畾淇℃伅鐘舵�佹洿鏂颁负鎷ｉ�夊畬鎴�");
+ }
+ else if (lockInfo.PickedQty > 0)
+ {
+ lockInfo.Status = (int)OutLockStockStatusEnum.鍑哄簱涓�;
+ _logger.LogInformation($"閿佸畾淇℃伅鐘舵�佷繚鎸佷负鍑哄簱涓紙閮ㄥ垎鎷ｉ�夛級");
+ }
+
+ lockInfo.Operator = App.User.UserName;
+ await _outStockLockInfoService.Db.Updateable(lockInfo).ExecuteCommandAsync();
+
+ // 鏇存柊搴撳瓨淇℃伅
+ decimal originalStockQty = stockDetail.StockQuantity;
+ decimal originalOutboundQty = stockDetail.OutboundQuantity;
+
+ stockDetail.StockQuantity -= actualPickedQty;
+ stockDetail.OutboundQuantity += actualPickedQty;
+
+ _logger.LogInformation($"鏇存柊搴撳瓨淇℃伅 - 搴撳瓨鏁伴噺浠� {originalStockQty} 鍑忓皯鍒� {stockDetail.StockQuantity}");
+ _logger.LogInformation($"鏇存柊搴撳瓨淇℃伅 - 鍑哄簱鏁伴噺浠� {originalOutboundQty} 澧炲姞鍒� {stockDetail.OutboundQuantity}");
+
+ // 鍑嗙‘鍒ゆ柇搴撳瓨鐘舵��
+ if (stockDetail.StockQuantity <= 0)
+ {
+ stockDetail.Status = (int)StockStatusEmun.鍑哄簱瀹屾垚;
+ _logger.LogInformation($"搴撳瓨鐘舵�佹洿鏂颁负鍑哄簱瀹屾垚");
+ }
+ else
+ {
+ stockDetail.Status = (int)StockStatusEmun.鍑哄簱閿佸畾;
+ _logger.LogInformation($"搴撳瓨鐘舵�佷繚鎸佷负鍑哄簱閿佸畾");
+ }
+
+ await _stockInfoDetailService.Db.Updateable(stockDetail).ExecuteCommandAsync();
+
+ _logger.LogInformation($"鍒嗘嫞閫昏緫鎵ц瀹屾垚 - 鏉＄爜: {stockDetail.Barcode}");
+
+ return new PickingResult
+ {
+ FinalLockInfo = lockInfo,
+ ActualPickedQty = actualPickedQty
+ };
+ }
+
+ private async Task<RevertPickingResult> RevertPickingData(Dt_PickingRecord pickingRecord)
+ {
+ _logger.LogInformation($"寮�濮嬫仮澶嶆嫞閫夋暟鎹� - 鎷ｉ�夎褰旾D: {pickingRecord.Id}, 鏉＄爜: {pickingRecord.Barcode}, 鎷ｉ�夋暟閲�: {pickingRecord.PickQuantity}");
+
+ // 1. 鎭㈠閿佸畾淇℃伅
+ var lockInfo = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
+ .FirstAsync(x => x.Id == pickingRecord.OutStockLockId);
+
+ if (lockInfo == null)
+ {
+ throw new InvalidOperationException($"鏈壘鍒板搴旂殑閿佸畾淇℃伅锛孖D: {pickingRecord.OutStockLockId}");
+ }
+
+ decimal originalPickedQty = lockInfo.PickedQty;
+ decimal originalAssignQty = lockInfo.AssignQuantity; // 璁板綍鍘熷鍒嗛厤鏁伴噺
+
+ // 鍙仮澶嶅凡鎷ｉ�夋暟閲忥紝涓嶄慨鏀瑰垎閰嶆暟閲�
+ lockInfo.PickedQty -= pickingRecord.PickQuantity;
+
+ // 纭繚宸叉嫞閫夋暟閲忎笉浼氫负璐熸暟
+ if (lockInfo.PickedQty < 0)
+ {
+ _logger.LogWarning($"宸叉嫞閫夋暟閲忓嚭鐜拌礋鏁帮紝閲嶇疆涓�0銆傚師鍊�: {lockInfo.PickedQty + pickingRecord.PickQuantity}, 鎭㈠鏁伴噺: {pickingRecord.PickQuantity}");
+ lockInfo.PickedQty = 0;
+ }
+
+ _logger.LogInformation($"鎭㈠閿佸畾淇℃伅 - 宸叉嫞閫夋暟閲忎粠 {originalPickedQty} 鍑忓皯鍒� {lockInfo.PickedQty}");
+ _logger.LogInformation($"閿佸畾淇℃伅鍒嗛厤鏁伴噺淇濇寔涓嶅彉: {originalAssignQty}");
+
+ // 鎭㈠閿佸畾鐘舵��
+ if (lockInfo.PickedQty <= 0)
+ {
+ lockInfo.Status = (int)OutLockStockStatusEnum.鍑哄簱涓�;
+ _logger.LogInformation($"閿佸畾淇℃伅鐘舵�佹仮澶嶄负鍑哄簱涓�");
+ }
+ else if (lockInfo.PickedQty < lockInfo.AssignQuantity)
+ {
+ lockInfo.Status = (int)OutLockStockStatusEnum.鍑哄簱涓�; // 閮ㄥ垎鎷ｉ�夌姸鎬�
+ _logger.LogInformation($"閿佸畾淇℃伅鐘舵�佹仮澶嶄负鍑哄簱涓紙閮ㄥ垎鎷ｉ�夛級");
+ }
+
+ await _outStockLockInfoService.Db.Updateable(lockInfo).ExecuteCommandAsync();
+
+ // 2. 鎭㈠搴撳瓨淇℃伅
+ var stockDetail = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
+ .FirstAsync(x => x.Barcode == pickingRecord.Barcode);
+
+ if (stockDetail == null)
+ {
+ throw new InvalidOperationException($"鏈壘鍒板搴旂殑搴撳瓨淇℃伅锛屾潯鐮�: {pickingRecord.Barcode}");
+ }
+
+ decimal originalStockQty = stockDetail.StockQuantity;
+ decimal originalOutboundQty = stockDetail.OutboundQuantity;
+
+ stockDetail.StockQuantity += pickingRecord.PickQuantity;
+ stockDetail.OutboundQuantity -= pickingRecord.PickQuantity;
+
+ // 纭繚鍑哄簱鏁伴噺涓嶄細涓鸿礋鏁�
+ if (stockDetail.OutboundQuantity < 0)
+ {
+ _logger.LogWarning($"鍑哄簱鏁伴噺鍑虹幇璐熸暟锛岄噸缃负0銆傚師鍊�: {stockDetail.OutboundQuantity + pickingRecord.PickQuantity}, 鎭㈠鏁伴噺: {pickingRecord.PickQuantity}");
+ stockDetail.OutboundQuantity = 0;
+ }
+
+ _logger.LogInformation($"鎭㈠搴撳瓨淇℃伅 - 搴撳瓨鏁伴噺浠� {originalStockQty} 澧炲姞鍒� {stockDetail.StockQuantity}");
+ _logger.LogInformation($"鎭㈠搴撳瓨淇℃伅 - 鍑哄簱鏁伴噺浠� {originalOutboundQty} 鍑忓皯鍒� {stockDetail.OutboundQuantity}");
+
+ // 鎭㈠搴撳瓨鐘舵��
+ if (stockDetail.StockQuantity > 0)
+ {
+ stockDetail.Status = (int)StockStatusEmun.鍑哄簱閿佸畾;
+ _logger.LogInformation($"搴撳瓨鐘舵�佹仮澶嶄负鍑哄簱閿佸畾");
+ }
+
+ await _stockInfoDetailService.Db.Updateable(stockDetail).ExecuteCommandAsync();
+
+ _logger.LogInformation($"鎭㈠鎷ｉ�夋暟鎹畬鎴� - 鏉＄爜: {pickingRecord.Barcode}");
+
+ return new RevertPickingResult
+ {
+ LockInfo = lockInfo,
+ StockDetail = stockDetail
+ };
}
#endregion
@@ -1238,84 +4748,200 @@
private async Task UpdateBatchAndOrderData(Dt_OutboundBatch batch, Dt_OutboundOrderDetail orderDetail, decimal pickedQty, string orderNo)
{
- // 鏇存柊鎵规瀹屾垚鏁伴噺
+ _logger.LogInformation($"寮�濮嬫洿鏂版壒娆″拰璁㈠崟鏁版嵁 - 鎷ｉ�夋暟閲�: {pickedQty}");
+ var latestOrderDetail = await _outboundOrderDetailService.Db.Queryable<Dt_OutboundOrderDetail>().FirstAsync(x => x.Id == orderDetail.Id);
+
+ if (latestOrderDetail == null)
+ throw new InvalidOperationException("鏈壘鍒拌鍗曟槑缁�");
+
+ orderDetail = latestOrderDetail;
+ // 楠岃瘉鍒嗛厤鏁伴噺涓嶄細鍙樻垚璐熸暟
+ if (orderDetail.AllocatedQuantity < pickedQty)
+ {
+ decimal actualPickedQty = orderDetail.AllocatedQuantity;
+ _logger.LogWarning($"鍒嗛厤鏁伴噺涓嶈冻锛岃皟鏁存嫞閫夋暟閲� - 鍘熼渶瑕�: {pickedQty}, 瀹為檯鍙敤: {actualPickedQty}");
+ pickedQty = actualPickedQty;
+ }
+
+ if (orderDetail.LockQuantity < pickedQty)
+ {
+ decimal actualPickedQty = orderDetail.LockQuantity;
+ _logger.LogWarning($"閿佸畾鏁伴噺涓嶈冻锛岃皟鏁存嫞閫夋暟閲� - 鍘熼渶瑕�: {pickedQty}, 瀹為檯鍙敤: {actualPickedQty}");
+ pickedQty = actualPickedQty;
+ }
+
+ // 1. 鏇存柊鎵规瀹屾垚鏁伴噺
+ decimal originalBatchCompletedQty = batch.CompletedQuantity;
batch.CompletedQuantity += pickedQty;
+
+ _logger.LogInformation($"鏇存柊鎵规瀹屾垚鏁伴噺 - 浠� {originalBatchCompletedQty} 澧炲姞鍒� {batch.CompletedQuantity}");
+
if (batch.CompletedQuantity >= batch.BatchQuantity)
{
batch.BatchStatus = (int)BatchStatusEnum.宸插畬鎴�;
+ _logger.LogInformation($"鎵规鐘舵�佹洿鏂颁负宸插畬鎴�");
}
await _outboundBatchRepository.Db.Updateable(batch).ExecuteCommandAsync();
// 鏇存柊璁㈠崟鏄庣粏
+ decimal originalOverOutQty = orderDetail.OverOutQuantity;
+ decimal originalAllocatedQty = orderDetail.AllocatedQuantity;
+ decimal originalLockQty = orderDetail.LockQuantity;
+
orderDetail.OverOutQuantity += pickedQty;
orderDetail.AllocatedQuantity -= pickedQty;
+ // LockQuantity 鍚屾鍑忓皯
+ orderDetail.LockQuantity = orderDetail.AllocatedQuantity;
+ if (orderDetail.AllocatedQuantity < 0) orderDetail.AllocatedQuantity = 0;
+ if (orderDetail.LockQuantity < 0) orderDetail.LockQuantity = 0;
+ _logger.LogInformation($"鏇存柊璁㈠崟鏄庣粏 - 宸插嚭搴撴暟閲忎粠 {originalOverOutQty} 澧炲姞鍒� {orderDetail.OverOutQuantity}");
+ _logger.LogInformation($"鏇存柊璁㈠崟鏄庣粏 - 宸插垎閰嶆暟閲忎粠 {originalAllocatedQty} 鍑忓皯鍒� {orderDetail.AllocatedQuantity}");
+ _logger.LogInformation($"鏇存柊璁㈠崟鏄庣粏 - 閿佸畾鏁伴噺浠� {originalLockQty} 鍑忓皯鍒� {orderDetail.LockQuantity}");
+
await _outboundOrderDetailService.Db.Updateable(orderDetail).ExecuteCommandAsync();
// 妫�鏌ヨ鍗曠姸鎬�
await CheckAndUpdateOrderStatus(orderNo);
+
+ _logger.LogInformation($"鎵规鍜岃鍗曟暟鎹洿鏂板畬鎴�");
}
- private async Task RevertBatchAndOrderData(Dt_PickingRecord pickingRecord)
+ private async Task RevertBatchAndOrderData(Dt_PickingRecord pickingRecord, RevertPickingResult revertResult)
{
- // 鎭㈠鎵规瀹屾垚鏁伴噺
+ _logger.LogInformation($"寮�濮嬫仮澶嶆壒娆″拰璁㈠崟鏁版嵁");
+
+ // 鎭㈠鎵规瀹屾垚鏁伴噺
var batch = await _outboundBatchRepository.Db.Queryable<Dt_OutboundBatch>()
- .FirstAsync(x => x.BatchNo == pickingRecord.BatchNo);
+ .FirstAsync(x => x.BatchNo == revertResult.LockInfo.OutboundBatchNo);
- batch.CompletedQuantity -= pickingRecord.PickQuantity;
- batch.BatchStatus = (int)BatchStatusEnum.鎵ц涓�;
- await _outboundBatchRepository.Db.Updateable(batch).ExecuteCommandAsync();
+ if (batch != null)
+ {
+ decimal originalCompletedQty = batch.CompletedQuantity;
+ batch.CompletedQuantity -= pickingRecord.PickQuantity;
+ if (batch.CompletedQuantity < 0)
+ {
+ batch.CompletedQuantity = 0;
+ _logger.LogWarning($"鎵规瀹屾垚鏁伴噺鍑虹幇璐熸暟锛岄噸缃负0");
+ }
+ _logger.LogInformation($"鎭㈠鎵规瀹屾垚鏁伴噺 - 浠� {originalCompletedQty} 鍑忓皯鍒� {batch.CompletedQuantity}");
- // 鎭㈠璁㈠崟鏄庣粏
+ // 閲嶆柊璁＄畻鎵规鐘舵��
+ if (batch.CompletedQuantity <= 0)
+ {
+ batch.BatchStatus = (int)BatchStatusEnum.鍒嗛厤涓�;
+ _logger.LogInformation($"鎵规鐘舵�佹仮澶嶄负鍒嗛厤涓�");
+ }
+ else if (batch.CompletedQuantity < batch.BatchQuantity)
+ {
+ batch.BatchStatus = (int)BatchStatusEnum.鎵ц涓�;
+ _logger.LogInformation($"鎵规鐘舵�佹仮澶嶄负鎵ц涓�");
+ }
+
+ await _outboundBatchRepository.Db.Updateable(batch).ExecuteCommandAsync();
+ }
+
+ // 鎭㈠璁㈠崟鏄庣粏
var orderDetail = await _outboundOrderDetailService.Db.Queryable<Dt_OutboundOrderDetail>()
.FirstAsync(x => x.Id == pickingRecord.OrderDetailId);
- orderDetail.OverOutQuantity -= pickingRecord.PickQuantity;
- orderDetail.AllocatedQuantity += pickingRecord.PickQuantity;
- await _outboundOrderDetailService.Db.Updateable(orderDetail).ExecuteCommandAsync();
+ if (orderDetail != null)
+ {
+ decimal originalOverOutQty = orderDetail.OverOutQuantity;
+ decimal originalAllocatedQty = orderDetail.AllocatedQuantity;
+ decimal originalLockQty = orderDetail.LockQuantity;
- // 閲嶆柊妫�鏌ヨ鍗曠姸鎬�
+ // 鍙仮澶嶇浉鍏虫暟閲忥紝鍒嗛厤鏁伴噺淇濇寔涓嶅彉
+ orderDetail.OverOutQuantity -= pickingRecord.PickQuantity;
+ orderDetail.AllocatedQuantity += pickingRecord.PickQuantity;
+ orderDetail.LockQuantity += pickingRecord.PickQuantity;
+ if (orderDetail.OverOutQuantity < 0) orderDetail.OverOutQuantity = 0;
+ if (orderDetail.AllocatedQuantity < 0) orderDetail.AllocatedQuantity = 0;
+ if (orderDetail.LockQuantity < 0) orderDetail.LockQuantity = 0;
+
+ _logger.LogInformation($"鎭㈠璁㈠崟鏄庣粏 - 宸插嚭搴撴暟閲忎粠 {originalOverOutQty} 鍑忓皯鍒� {orderDetail.OverOutQuantity}");
+ _logger.LogInformation($"璁㈠崟鏄庣粏鍒嗛厤鏁伴噺淇濇寔涓嶅彉: {originalAllocatedQty}");
+ _logger.LogInformation($"璁㈠崟鏄庣粏閿佸畾鏁伴噺淇濇寔涓嶅彉: {originalLockQty}");
+
+ await UpdateBatchAllocateStatus(orderDetail);
+ await _outboundOrderDetailService.Db.Updateable(orderDetail).ExecuteCommandAsync();
+ }
+
+ // 3. 閲嶆柊妫�鏌ヨ鍗曠姸鎬�
await CheckAndUpdateOrderStatus(pickingRecord.OrderNo);
+
+ _logger.LogInformation($"鎭㈠鎵规鍜岃鍗曟暟鎹畬鎴�");
}
+ private async Task UpdateBatchAllocateStatus(Dt_OutboundOrderDetail orderDetail)
+ {
+ if (orderDetail.AllocatedQuantity >= orderDetail.NeedOutQuantity)
+ {
+ orderDetail.BatchAllocateStatus = OrderDetailStatusEnum.AssignOver.ObjToInt();
+ }
+ else if (orderDetail.AllocatedQuantity > 0)
+ {
+ orderDetail.BatchAllocateStatus = OrderDetailStatusEnum.AssignOverPartial.ObjToInt();
+ }
+ else
+ {
+ orderDetail.BatchAllocateStatus = OrderDetailStatusEnum.New.ObjToInt();
+ }
+ }
private async Task ReleaseLockAndStock(Dt_OutStockLockInfo lockInfo)
{
- // 鎭㈠搴撳瓨鐘舵��
+ // 鎭㈠搴撳瓨鐘舵�� - 鍥炲簱鍚庡簱瀛樺彉涓哄彲鐢ㄧ姸鎬�
var stockDetail = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
.FirstAsync(x => x.Barcode == lockInfo.CurrentBarcode && x.StockId == lockInfo.StockId);
if (stockDetail != null)
{
+ // 鍥炲簱鍚庡簱瀛樼姸鎬佹仮澶嶄负鍏ュ簱瀹屾垚锛堝彲鐢ㄧ姸鎬侊級
stockDetail.Status = (int)StockStatusEmun.鍏ュ簱瀹屾垚;
await _stockInfoDetailService.Db.Updateable(stockDetail).ExecuteCommandAsync();
}
- // 鏇存柊閿佸畾璁板綍鐘舵�佷负鍥炲簱
+ // 鏇存柊閿佸畾璁板綍鐘舵�佷负宸插洖搴�
lockInfo.Status = (int)OutLockStockStatusEnum.宸插洖搴�;
+ lockInfo.Operator = App.User.UserName;
await _outStockLockInfoService.Db.Updateable(lockInfo).ExecuteCommandAsync();
}
- private async Task UpdateBatchStatusForReturn(string batchNo, List<Dt_OutStockLockInfo> returnedLocks)
+ /// <summary>
+ /// 鏇存柊鎵规鐘舵�侊紙鍥炲簱锛�
+ /// </summary>
+ private async Task UpdateBatchStatusForReturn(string outboundBatchNo, List<Dt_OutStockLockInfo> returnedLocks)
{
var batch = await _outboundBatchRepository.Db.Queryable<Dt_OutboundBatch>()
- .FirstAsync(x => x.BatchNo == batchNo);
+ .FirstAsync(x => x.BatchNo == outboundBatchNo);
- // 璁＄畻鍥炲簱鏁伴噺
- var returnedQty = returnedLocks.Sum(x => x.AssignQuantity - x.PickedQty);
- batch.CompletedQuantity -= returnedQty;
-
- if (batch.CompletedQuantity <= 0)
+ if (batch != null)
{
- batch.BatchStatus = (int)BatchStatusEnum.宸插洖搴�;
- }
- else
- {
- batch.BatchStatus = (int)BatchStatusEnum.鎵ц涓�;
- }
+ // 璁＄畻鍥炲簱鏁伴噺锛堟湭鎷ｉ�夌殑閮ㄥ垎锛�
+ var returnedQty = returnedLocks.Sum(x => x.AssignQuantity - x.PickedQty);
+ batch.CompletedQuantity -= returnedQty;
- batch.Operator = App.User.UserName;
- await _outboundBatchRepository.Db.Updateable(batch).ExecuteCommandAsync();
+ // 鏇存柊鎵规鐘舵��
+ if (batch.CompletedQuantity <= 0)
+ {
+ batch.BatchStatus = (int)BatchStatusEnum.宸插洖搴�;
+ }
+ else if (batch.CompletedQuantity < batch.BatchQuantity)
+ {
+ batch.BatchStatus = (int)BatchStatusEnum.鎵ц涓�;
+ }
+ else
+ {
+ batch.BatchStatus = (int)BatchStatusEnum.宸插畬鎴�;
+ }
+
+ batch.Operator = App.User.UserName;
+ await _outboundBatchRepository.Db.Updateable(batch).ExecuteCommandAsync();
+ }
}
+ /// <summary>
+ /// 鏇存柊璁㈠崟鏄庣粏锛堝洖搴撳悗锛�
+ /// </summary>
private async Task UpdateOrderDetailAfterReturn(List<Dt_OutStockLockInfo> returnedLocks)
{
var orderDetailGroups = returnedLocks.GroupBy(x => x.OrderDetailId);
@@ -1325,14 +4951,126 @@
var orderDetailId = group.Key;
var returnedQty = group.Sum(x => x.AssignQuantity - x.PickedQty);
- await _outboundOrderDetailService.Db.Updateable<Dt_OutboundOrderDetail>()
- .SetColumns(x => x.AllocatedQuantity == x.AllocatedQuantity - returnedQty)
- .Where(x => x.Id == orderDetailId)
- .ExecuteCommandAsync();
+ var orderDetail = await _outboundOrderDetailService.Db.Queryable<Dt_OutboundOrderDetail>()
+ .FirstAsync(x => x.Id == orderDetailId);
+
+ if (orderDetail != null)
+ {
+ orderDetail.AllocatedQuantity -= returnedQty;
+ // LockQuantity 鍚屾鍑忓皯锛屼繚鎸佷笌宸插垎閰嶆暟閲忎竴鑷�
+ orderDetail.LockQuantity = orderDetail.AllocatedQuantity;
+
+ await UpdateBatchAllocateStatus(orderDetail);
+
+ await _outboundOrderDetailService.Db.Updateable(orderDetail).ExecuteCommandAsync();
+ }
+ }
+ }
+ #endregion
+
+ private async Task CreateReturnTaskAndHandleESS(string orderNo, string palletCode, Dt_Task originalTask, TaskTypeEnum taskTypeEnum, int palletType)
+ {
+ var firstLocation = await _locationInfoService.Db.Queryable<Dt_LocationInfo>()
+ .FirstAsync(x => x.LocationCode == originalTask.SourceAddress);
+
+ // 鍒嗛厤鏂拌揣浣�
+ var newLocation = _locationInfoService.AssignLocation(firstLocation.LocationType);
+
+ Dt_Task returnTask = new()
+ {
+ CurrentAddress = stations[originalTask.TargetAddress],
+ Grade = 0,
+ PalletCode = palletCode,
+ NextAddress = "",
+ // OrderNo = originalTask.OrderNo,
+ OrderNo = orderNo,
+ Roadway = newLocation.RoadwayNo,
+ SourceAddress = stations[originalTask.TargetAddress],
+ TargetAddress = newLocation.LocationCode,
+ TaskStatus = TaskStatusEnum.New.ObjToInt(),
+ TaskType = taskTypeEnum.ObjToInt(),
+ PalletType = palletType,
+ WarehouseId = originalTask.WarehouseId
+
+ };
+ // 淇濆瓨鍥炲簱浠诲姟
+ var insertcount = await _taskRepository.Db.Insertable(returnTask).ExecuteCommandAsync();
+ if (insertcount <= 0)
+ {
+ throw new Exception("鍒涘缓浠诲姟澶辫触锛�");
+ }
+ var targetAddress = originalTask.TargetAddress;
+
+ _logger.LogInformation($"CreateReturnTaskAndHandleESS 鍒嗘壒鍒犻櫎鍘嗗彶浠诲姟: {orderNo} 锛� {originalTask.TaskNum}");
+ // 鍒犻櫎鍘熷鍑哄簱浠诲姟
+ //_taskRepository.DeleteAndMoveIntoHty(originalTask, OperateTypeEnum.鑷姩瀹屾垚);
+ var result = _task_HtyService.DeleteAndMoveIntoHty(originalTask, OperateTypeEnum.浜哄伐鍒犻櫎);
+ await _taskRepository.Db.Deleteable(originalTask).ExecuteCommandAsync();
+
+ if (!result)
+ {
+ await _taskRepository.Db.Deleteable(originalTask).ExecuteCommandAsync();
+ }
+ _logger.LogInformation($"CreateReturnTaskAndHandleESS 鍒嗘壒鍒犻櫎鍘嗗彶浠诲姟: {orderNo} 锛� {originalTask.TaskNum},褰卞搷琛� {result}");
+
+
+ // 缁� ESS 鍙戦�佹祦鍔ㄤ俊鍙峰拰鍒涘缓浠诲姟
+ await SendESSCommands(palletCode, targetAddress, returnTask);
+ }
+ /// <summary>
+ /// 缁橢SS涓嬩换鍔�
+ /// </summary>
+ /// <param name="palletCode"></param>
+ /// <param name="targetAddress"></param>
+ /// <param name="returnTask"></param>
+ /// <returns></returns>
+ /// <exception cref="Exception"></exception>
+ private async Task SendESSCommands(string palletCode, string targetAddress, Dt_Task returnTask)
+ {
+ try
+ {
+ // 1. 鍙戦�佹祦鍔ㄤ俊鍙�
+ var moveResult = await _eSSApiService.MoveContainerAsync(new WIDESEA_DTO.Basic.MoveContainerRequest
+ {
+ slotCode = movestations[targetAddress],
+ containerCode = palletCode
+ });
+
+ //if (moveResult)
+ //{
+ // 2. 鍒涘缓鍥炲簱浠诲姟
+ var essTask = new TaskModel()
+ {
+ taskType = "putaway",
+ taskGroupCode = "",
+ groupPriority = 0,
+ tasks = new List<TasksType>{ new() {
+ taskCode = returnTask.TaskNum.ToString(),
+ taskPriority = 0,
+ taskDescribe = new TaskDescribeType
+ {
+ containerCode = palletCode,
+ containerType = "CT_KUBOT_STANDARD",
+ fromLocationCode = stations.GetValueOrDefault(targetAddress) ?? "",
+ toStationCode = "",
+ toLocationCode = returnTask.TargetAddress,
+ deadline = 0,
+ storageTag = ""
+ }
+ } }
+ };
+
+ var resultTask = await _eSSApiService.CreateTaskAsync(essTask);
+ _logger.LogInformation($"ReturnRemaining 鍒涘缓浠诲姟鎴愬姛: {resultTask}");
+ //}
+ }
+ catch (Exception ex)
+ {
+ _logger.LogError($"ReturnRemaining ESS鍛戒护鍙戦�佸け璐�: {ex.Message}");
+ throw new Exception($"ESS绯荤粺閫氫俊澶辫触: {ex.Message}");
}
}
- #endregion
#region 杈呭姪鏂规硶
@@ -1342,7 +5080,7 @@
return "WSLOT" + DateTime.Now.ToString("yyyyMMdd") + seq.ToString().PadLeft(5, '0');
}
- private async Task RecordSplitHistory(Dt_OutStockLockInfo lockInfo, Dt_StockInfoDetail stockDetail, decimal splitQty, string newBarcode)
+ private async Task RecordSplitHistory(Dt_OutStockLockInfo lockInfo, Dt_StockInfoDetail stockDetail, decimal splitQty, string newBarcode, bool isAutoSplit, decimal? originalStockQuantity = null)
{
var splitHistory = new Dt_SplitPackageRecord
{
@@ -1354,7 +5092,12 @@
NewBarcode = newBarcode,
SplitQty = splitQty,
SplitTime = DateTime.Now,
- Status = (int)SplitPackageStatusEnum.宸叉媶鍖�
+ Status = (int)SplitPackageStatusEnum.宸叉媶鍖�,
+ IsAutoSplit = isAutoSplit,
+ // SplitType = isAutoSplit ? "鑷姩鎷嗗寘" : "鎵嬪姩鎷嗗寘"
+ OriginalStockQuantity = originalStockQuantity ?? stockDetail.StockQuantity,
+ //RemainingStockQuantity = stockDetail.StockQuantity - splitQty
+ TaskNum = lockInfo.TaskNum
};
await _splitPackageService.Db.Insertable(splitHistory).ExecuteCommandAsync();
@@ -1374,6 +5117,13 @@
PickTime = DateTime.Now,
Operator = App.User.UserName,
OutStockLockId = result.FinalLockInfo.Id,
+
+ BarcodeUnit = result.FinalLockInfo.BarcodeUnit,
+ BarcodeQty = result.FinalLockInfo.BarcodeQty,
+ BatchNo = result.FinalLockInfo.BatchNo,
+ lineNo = result.FinalLockInfo.lineNo,
+ SupplyCode = result.FinalLockInfo.SupplyCode,
+ WarehouseCode = result.FinalLockInfo.WarehouseCode,
// IsCancelled = false
};
@@ -1397,10 +5147,56 @@
.Where(x => x.OrderNo == orderNo)
.ExecuteCommandAsync();
}
-
+ private string GetPalletStatusText(PalletStatusEnum status)
+ {
+ return status switch
+ {
+ PalletStatusEnum.鏈紑濮� => "鏈紑濮�",
+ PalletStatusEnum.鎷ｉ�変腑 => "鎷ｉ�変腑",
+ PalletStatusEnum.宸插畬鎴� => "宸插畬鎴�",
+ PalletStatusEnum.鏃犱换鍔� => "鏃犱换鍔�",
+ _ => "鏈煡"
+ };
+ }
#endregion
+
#region DTO绫�
+ /// <summary>
+ /// 鏉＄爜鐘舵�佷俊鎭疍TO
+ /// </summary>
+ public class BarcodeStatusInfoDto
+ {
+ public string Barcode { get; set; }
+ public string OrderNo { get; set; }
+ public bool IsOriginalBarcode { get; set; }
+ public int SplitChainCount { get; set; }
+ public bool HasBeenPicked { get; set; }
+ public decimal TotalPickedQuantity { get; set; }
+ public int PickRecordCount { get; set; }
+ public int LockInfoStatus { get; set; }
+ public decimal LockInfoPickedQty { get; set; }
+ public decimal LockInfoAssignQty { get; set; }
+ public decimal StockQuantity { get; set; }
+ public int StockStatus { get; set; }
+ public bool CanCancelSplit { get; set; }
+ public bool NeedCancelPickFirst { get; set; }
+ public List<string> OperationSuggestions { get; set; } = new List<string>();
+ }
+ public class PickedBarcodeInfo
+ {
+ public string Barcode { get; set; }
+ public decimal PickedQty { get; set; }
+ public int PickRecordCount { get; set; }
+ }
+ /// <summary>
+ /// 鑷姩鎷嗗寘缁撴灉
+ /// </summary>
+ public class AutoSplitResult
+ {
+ public string NewBarcode { get; set; }
+ public decimal SplitQuantity { get; set; }
+ }
public class PickingResult
{
@@ -1430,12 +5226,5 @@
}
#endregion
- }
-
-
- // 鏀寔绫�
- public class SplitResultDto
- {
- public string NewBarcode { get; set; }
}
}
--
Gitblit v1.9.3