From 6641d42d35d7b9739c64fe578d69e43a39e26c16 Mon Sep 17 00:00:00 2001
From: pan <antony1029@163.com>
Date: 星期六, 29 十一月 2025 09:46:49 +0800
Subject: [PATCH] 提交
---
项目代码/WMS无仓储版/WIDESEA_WMSServer/WIDESEA_OutboundService/OutboundBatchPickingService.cs | 679 ++++++++++++++++++++++++++++++++++++--------------------
1 files changed, 434 insertions(+), 245 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 445c6e5..2b85d56 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"
@@ -21,10 +21,10 @@
namespace WIDESEA_OutboundService
{
- public class OutboundBatchPickingService : ServiceBase<Dt_PickingRecord, IRepository<Dt_PickingRecord>>
+ public class OutboundBatchPickingService : ServiceBase<Dt_PickingRecord, IRepository<Dt_PickingRecord>>, IOutboundBatchPickingService
{
-
+
private readonly IUnitOfWorkManage _unitOfWorkManage;
public IRepository<Dt_PickingRecord> Repository => BaseDal;
@@ -86,72 +86,327 @@
/// <summary>
/// 鍒嗘壒鍒嗘嫞纭
/// </summary>
- public async Task<WebResponseContent> ConfirmBatchPicking(string orderNo, string batchNo, string palletCode, string barcode, decimal actualPickedQty)
+ public async Task<WebResponseContent> ConfirmBatchPicking(string orderNo, string palletCode, string barcode)
{
try
{
_unitOfWorkManage.BeginTran();
// 1. 楠岃瘉鍒嗘嫞璇锋眰
- var validationResult = await ValidateBatchPickingRequest(orderNo, batchNo, palletCode, barcode, actualPickedQty);
+ var validationResult = await ValidatePickingRequest(orderNo, palletCode, barcode);
if (!validationResult.IsValid)
return WebResponseContent.Instance.Error(validationResult.ErrorMessage);
- var (lockInfo, orderDetail, stockDetail) = validationResult.Data;
+ var (lockInfo, orderDetail, stockDetail, batch) = validationResult.Data;
+
+ // 浣跨敤閿佸畾淇℃伅鐨勫垎閰嶆暟閲忎綔涓哄疄闄呭垎鎷ｆ暟閲�
+ var actualPickedQty = lockInfo.AssignQuantity;
// 2. 鎵ц鍒嗘嫞閫昏緫
- var pickingResult = await ExecuteBatchPickingLogic(lockInfo, orderDetail, stockDetail, actualPickedQty);
+ var pickingResult = await ExecutePickingLogic(lockInfo, orderDetail, stockDetail, actualPickedQty);
- // 3. 鏇存柊鎵规瀹屾垚鏁伴噺
- await UpdateBatchCompletedQuantity(batchNo, actualPickedQty);
+ // 3. 鏇存柊鎵规鍜岃鍗曟暟鎹�
+ await UpdateBatchAndOrderData(batch, orderDetail, actualPickedQty, orderNo);
- // 4. 鏇存柊璁㈠崟鐩稿叧鏁版嵁
- await UpdateOrderRelatedData(orderDetail.Id, actualPickedQty, orderNo);
-
- // 5. 璁板綍鎷ｉ�夊巻鍙�
- await RecordPickingHistory(pickingResult, orderNo, palletCode, batchNo);
+ // 4. 璁板綍鎷ｉ�夊巻鍙�
+ await RecordPickingHistory(pickingResult, orderNo, palletCode);
_unitOfWorkManage.CommitTran();
- return WebResponseContent.Instance.OK("鍒嗘壒鍒嗘嫞鎴愬姛");
+ return WebResponseContent.Instance.OK("鍒嗘嫞鎴愬姛", new
+ {
+ PickedQuantity = actualPickedQty,
+ Barcode = barcode,
+ MaterialCode = lockInfo.MaterielCode
+ });
}
catch (Exception ex)
{
_unitOfWorkManage.RollbackTran();
- _logger.LogError($"鍒嗘壒鍒嗘嫞澶辫触 - OrderNo: {orderNo}, BatchNo: {batchNo}, 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("鏈壘鍒板垎鎷ｈ褰�");
+
+ // 鎭㈠閿佸畾淇℃伅鍜屽簱瀛�
+ 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}");
}
}
- private async Task<ValidationResult<(Dt_OutStockLockInfo, Dt_OutboundOrderDetail, Dt_StockInfoDetail)>> ValidateBatchPickingRequest(
- string orderNo, string batchNo, string palletCode, string barcode, decimal actualPickedQty)
+ #endregion
+
+ #region 鎵嬪姩鎷嗗寘
+
+ /// <summary>
+ /// 鎵嬪姩鎷嗗寘
+ /// </summary>
+ public async Task<WebResponseContent> ManualSplitPackage(string orderNo, string palletCode, string originalBarcode, decimal splitQuantity)
{
- // 鏌ユ壘鎵规閿佸畾淇℃伅
+ try
+ {
+ _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);
+
+ _unitOfWorkManage.CommitTran();
+
+ return WebResponseContent.Instance.OK("鎵嬪姩鎷嗗寘鎴愬姛", new
+ {
+ NewBarcode = splitResult.NewBarcode,
+ OriginalBarcode = originalBarcode,
+ SplitQuantity = splitQuantity
+ });
+ }
+ catch (Exception ex)
+ {
+ _unitOfWorkManage.RollbackTran();
+ _logger.LogError($"鎵嬪姩鎷嗗寘澶辫触 - OrderNo: {orderNo}, Barcode: {originalBarcode}, Error: {ex.Message}");
+ return WebResponseContent.Instance.Error($"鎵嬪姩鎷嗗寘澶辫触锛歿ex.Message}");
+ }
+ }
+
+ #endregion
+
+ #region 鍙栨秷鎷嗗寘
+
+ /// <summary>
+ /// 鍙栨秷鎷嗗寘
+ /// </summary>
+ public async Task<WebResponseContent> CancelSplitPackage(string orderNo, string palletCode, string newBarcode)
+ {
+ try
+ {
+ _unitOfWorkManage.BeginTran();
+
+ // 鏌ユ壘鎷嗗寘璁板綍骞堕獙璇�
+ var validationResult = await ValidateCancelSplitRequest(orderNo, palletCode, newBarcode);
+ if (!validationResult.IsValid)
+ return WebResponseContent.Instance.Error(validationResult.ErrorMessage);
+
+ var (splitRecord, newLockInfo, newStockDetail) = validationResult.Data;
+
+ // 鎵ц鍙栨秷鎷嗗寘閫昏緫
+ await ExecuteCancelSplitLogic(splitRecord, newLockInfo, newStockDetail);
+
+ _unitOfWorkManage.CommitTran();
+
+ return WebResponseContent.Instance.OK("鍙栨秷鎷嗗寘鎴愬姛");
+ }
+ catch (Exception ex)
+ {
+ _unitOfWorkManage.RollbackTran();
+ _logger.LogError($"鍙栨秷鎷嗗寘澶辫触 - OrderNo: {orderNo}, Barcode: {newBarcode}, Error: {ex.Message}");
+ return WebResponseContent.Instance.Error($"鍙栨秷鎷嗗寘澶辫触锛歿ex.Message}");
+ }
+ }
+
+ #endregion
+
+ #region 鍒嗘壒鍥炲簱
+
+ /// <summary>
+ /// 鍒嗘壒鍥炲簱 - 閲婃斁鏈嫞閫夌殑搴撳瓨
+ /// </summary>
+ public async Task<WebResponseContent> BatchReturnStock(string orderNo, string palletCode)
+ {
+ try
+ {
+ _unitOfWorkManage.BeginTran();
+
+ // 鏌ユ壘鎵樼洏涓婃湭瀹屾垚鐨勯攣瀹氳褰�
+ var unfinishedLocks = 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)
+ {
+ var batchNo = batchGroup.Key;
+ var batchLocks = batchGroup.ToList();
+
+ // 閲婃斁搴撳瓨鍜岄攣瀹氳褰�
+ foreach (var lockInfo in batchLocks)
+ {
+ await ReleaseLockAndStock(lockInfo);
+ }
+
+ // 鏇存柊鎵规鐘舵��
+ await UpdateBatchStatusForReturn(batchNo, batchLocks);
+
+ // 鏇存柊璁㈠崟鏄庣粏鐨勫凡鍒嗛厤鏁伴噺
+ await UpdateOrderDetailAfterReturn(batchLocks);
+ }
+
+ _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 楠岃瘉鏂规硶
+ private async Task<ValidationResult<(Dt_OutStockLockInfo, Dt_OutboundOrderDetail, Dt_StockInfoDetail, Dt_OutboundBatch)>> ValidatePickingRequest(
+ string orderNo, string palletCode, string barcode)
+ {
+ // 鏌ユ壘閿佸畾淇℃伅
var lockInfo = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
.Where(x => x.OrderNo == orderNo &&
- x.BatchNo == batchNo &&
x.PalletCode == palletCode &&
x.CurrentBarcode == barcode &&
x.Status == (int)OutLockStockStatusEnum.鍑哄簱涓�)
.FirstAsync();
if (lockInfo == null)
- return ValidationResult<(Dt_OutStockLockInfo, Dt_OutboundOrderDetail, Dt_StockInfoDetail)>.Error("鏈壘鍒版湁鏁堢殑鎵规閿佸畾淇℃伅");
+ return ValidationResult<(Dt_OutStockLockInfo, Dt_OutboundOrderDetail, Dt_StockInfoDetail, Dt_OutboundBatch)>.Error("鏈壘鍒版湁鏁堢殑閿佸畾淇℃伅");
- if (actualPickedQty <= 0 || actualPickedQty > lockInfo.AssignQuantity - lockInfo.PickedQty)
- return ValidationResult<(Dt_OutStockLockInfo, Dt_OutboundOrderDetail, Dt_StockInfoDetail)>.Error("鍒嗘嫞鏁伴噺鏃犳晥");
+ // 妫�鏌ユ槸鍚﹀凡缁忓垎鎷ｅ畬鎴�
+ if (lockInfo.PickedQty >= lockInfo.AssignQuantity)
+ return ValidationResult<(Dt_OutStockLockInfo, Dt_OutboundOrderDetail, Dt_StockInfoDetail, Dt_OutboundBatch)>.Error("璇ユ潯鐮佸凡鍒嗘嫞瀹屾垚");
- // 鑾峰彇璁㈠崟鏄庣粏鍜屽簱瀛樻槑缁�
+ // 鑾峰彇鍏宠仈鏁版嵁
var orderDetail = await _outboundOrderDetailService.Db.Queryable<Dt_OutboundOrderDetail>()
.FirstAsync(x => x.Id == lockInfo.OrderDetailId);
var stockDetail = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
.FirstAsync(x => x.Barcode == barcode && x.StockId == lockInfo.StockId);
- return ValidationResult<(Dt_OutStockLockInfo, Dt_OutboundOrderDetail, Dt_StockInfoDetail)>.Success((lockInfo, orderDetail, stockDetail));
+ // 楠岃瘉搴撳瓨鏁伴噺
+ if (stockDetail.StockQuantity < lockInfo.AssignQuantity)
+ return ValidationResult<(Dt_OutStockLockInfo, Dt_OutboundOrderDetail, Dt_StockInfoDetail, Dt_OutboundBatch)>.Error(
+ $"搴撳瓨鏁伴噺涓嶈冻锛岄渶瑕侊細{lockInfo.AssignQuantity}锛屽疄闄咃細{stockDetail.StockQuantity}");
+
+ var batch = await _outboundBatchRepository.Db.Queryable<Dt_OutboundBatch>()
+ .FirstAsync(x => x.BatchNo == lockInfo.BatchNo);
+
+ 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)
+ {
+ 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));
}
- private async Task<PickingResult> ExecuteBatchPickingLogic(
+ private async Task<ValidationResult<(Dt_SplitPackageRecord, Dt_OutStockLockInfo, Dt_StockInfoDetail)>> ValidateCancelSplitRequest(
+ string orderNo, string palletCode, string newBarcode)
+ {
+ var splitRecord = await _splitPackageService.Db.Queryable<Dt_SplitPackageRecord>()
+ .Where(x => x.NewBarcode == newBarcode &&
+ x.OrderNo == orderNo &&
+ !x.IsReverted)
+ .FirstAsync();
+
+ if (splitRecord == null)
+ return ValidationResult<(Dt_SplitPackageRecord, Dt_OutStockLockInfo, Dt_StockInfoDetail)>.Error("鏈壘鍒版媶鍖呰褰�");
+
+ var newLockInfo = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
+ .Where(x => x.CurrentBarcode == newBarcode &&
+ x.PalletCode == palletCode &&
+ x.OrderNo == orderNo)
+ .FirstAsync();
+
+ 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();
+
+ if (pickingRecord != null)
+ return ValidationResult<(Dt_SplitPackageRecord, Dt_OutStockLockInfo, Dt_StockInfoDetail)>.Error("璇ユ潯鐮佸凡琚垎鎷ｏ紝鏃犳硶鍙栨秷鎷嗗寘");
+
+ var newStockDetail = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
+ .FirstAsync(x => x.Barcode == newBarcode);
+
+ return ValidationResult<(Dt_SplitPackageRecord, Dt_OutStockLockInfo, Dt_StockInfoDetail)>.Success((splitRecord, newLockInfo, newStockDetail));
+ }
+
+ #endregion
+
+ #region 鏍稿績閫昏緫鏂规硶
+
+ private async Task<PickingResult> ExecutePickingLogic(
Dt_OutStockLockInfo lockInfo, Dt_OutboundOrderDetail orderDetail,
Dt_StockInfoDetail stockDetail, decimal actualPickedQty)
{
@@ -180,86 +435,34 @@
};
}
- private async Task UpdateBatchCompletedQuantity(string batchNo, decimal pickedQty)
+ private async Task<RevertPickingResult> RevertPickingData(Dt_PickingRecord pickingRecord)
{
- await _outboundBatchRepository.Db.Updateable<Dt_OutboundBatch>()
- .SetColumns(x => x.CompletedQuantity == x.CompletedQuantity + pickedQty)
- .Where(x => x.BatchNo == batchNo)
- .ExecuteCommandAsync();
-
- // 妫�鏌ユ壒娆℃槸鍚﹀畬鎴�
- var batch = await _outboundBatchRepository.Db.Queryable<Dt_OutboundBatch>()
- .FirstAsync(x => x.BatchNo == batchNo);
-
- if (batch.CompletedQuantity >= batch.BatchQuantity)
- {
- batch.BatchStatus = (int)BatchStatusEnum.宸插畬鎴�;
- await _outboundBatchRepository.Db.Updateable(batch).ExecuteCommandAsync();
- }
- }
-
- #endregion
-
- #region 鎵嬪姩鎷嗗寘
-
- /// <summary>
- /// 鎵嬪姩鎷嗗寘
- /// </summary>
- public async Task<WebResponseContent> ManualSplitPackage(string orderNo, string batchNo, string originalBarcode, decimal splitQuantity)
- {
- try
- {
- _unitOfWorkManage.BeginTran();
-
- // 1. 楠岃瘉鎷嗗寘璇锋眰
- var validationResult = await ValidateManualSplitRequest(orderNo, batchNo, originalBarcode, splitQuantity);
- if (!validationResult.IsValid)
- return WebResponseContent.Instance.Error(validationResult.ErrorMessage);
-
- var (lockInfo, stockDetail) = validationResult.Data;
-
- // 2. 鎵ц鎷嗗寘閫昏緫
- var splitResult = await ExecuteManualSplit(lockInfo, stockDetail, splitQuantity, batchNo);
-
- _unitOfWorkManage.CommitTran();
-
- return WebResponseContent.Instance.OK("鎵嬪姩鎷嗗寘鎴愬姛", new { NewBarcode = splitResult.NewBarcode });
- }
- catch (Exception ex)
- {
- _unitOfWorkManage.RollbackTran();
- _logger.LogError($"鎵嬪姩鎷嗗寘澶辫触 - OrderNo: {orderNo}, BatchNo: {batchNo}, Barcode: {originalBarcode}, Error: {ex.Message}");
- return WebResponseContent.Instance.Error($"鎵嬪姩鎷嗗寘澶辫触锛歿ex.Message}");
- }
- }
-
- private async Task<ValidationResult<(Dt_OutStockLockInfo, Dt_StockInfoDetail)>> ValidateManualSplitRequest(
- string orderNo, string batchNo, string originalBarcode, decimal splitQuantity)
- {
+ // 鎭㈠閿佸畾淇℃伅
var lockInfo = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
- .Where(x => x.OrderNo == orderNo &&
- x.BatchNo == batchNo &&
- x.CurrentBarcode == originalBarcode &&
- x.Status == (int)OutLockStockStatusEnum.鍑哄簱涓�)
- .FirstAsync();
+ .FirstAsync(x => x.Id == pickingRecord.OutStockLockId);
- if (lockInfo == null)
- return ValidationResult<(Dt_OutStockLockInfo, Dt_StockInfoDetail)>.Error("鏈壘鍒版湁鏁堢殑閿佸畾淇℃伅");
+ 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 == originalBarcode && x.StockId == lockInfo.StockId);
+ .FirstAsync(x => x.Barcode == pickingRecord.Barcode);
- if (stockDetail.StockQuantity < splitQuantity)
- return ValidationResult<(Dt_OutStockLockInfo, Dt_StockInfoDetail)>.Error("鎷嗗寘鏁伴噺涓嶈兘澶т簬搴撳瓨鏁伴噺");
+ stockDetail.StockQuantity += pickingRecord.PickQuantity;
+ stockDetail.OutboundQuantity -= pickingRecord.PickQuantity;
+ stockDetail.Status = (int)StockStatusEmun.鍑哄簱閿佸畾;
+ await _stockInfoDetailService.Db.Updateable(stockDetail).ExecuteCommandAsync();
- if (lockInfo.AssignQuantity - lockInfo.PickedQty < splitQuantity)
- return ValidationResult<(Dt_OutStockLockInfo, Dt_StockInfoDetail)>.Error("鎷嗗寘鏁伴噺涓嶈兘澶т簬鏈嫞閫夋暟閲�");
-
- return ValidationResult<(Dt_OutStockLockInfo, Dt_StockInfoDetail)>.Success((lockInfo, stockDetail));
+ return new RevertPickingResult
+ {
+ LockInfo = lockInfo,
+ StockDetail = stockDetail
+ };
}
- private async Task<SplitResultDto> ExecuteManualSplit(Dt_OutStockLockInfo lockInfo, Dt_StockInfoDetail stockDetail,
- decimal splitQuantity, string batchNo)
+ private async Task<SplitResultDto> ExecuteSplitLogic(Dt_OutStockLockInfo lockInfo, Dt_StockInfoDetail stockDetail,
+ decimal splitQuantity, string palletCode)
{
// 鐢熸垚鏂版潯鐮�
string newBarcode = await GenerateNewBarcode();
@@ -289,22 +492,23 @@
{
OrderNo = lockInfo.OrderNo,
OrderDetailId = lockInfo.OrderDetailId,
- BatchNo = batchNo,
+ OutboundBatchNo = lockInfo.OutboundBatchNo,
MaterielCode = lockInfo.MaterielCode,
StockId = lockInfo.StockId,
OrderQuantity = splitQuantity,
AssignQuantity = splitQuantity,
PickedQty = 0,
LocationCode = lockInfo.LocationCode,
- PalletCode = lockInfo.PalletCode,
+ PalletCode = palletCode,
Status = (int)OutLockStockStatusEnum.鍑哄簱涓�,
CurrentBarcode = newBarcode,
- Operator = App.User.UserName,
+ Operator = App.User.UserName,
};
await _outStockLockInfoService.Db.Insertable(newLockInfo).ExecuteCommandAsync();
// 鏇存柊鍘熼攣瀹氫俊鎭�
lockInfo.AssignQuantity -= splitQuantity;
+ lockInfo.OrderQuantity -= splitQuantity;
await _outStockLockInfoService.Db.Updateable(lockInfo).ExecuteCommandAsync();
// 璁板綍鎷嗗寘鍘嗗彶
@@ -313,121 +517,83 @@
return new SplitResultDto { NewBarcode = newBarcode };
}
- #endregion
-
- #region 鍙栨秷鎷嗗寘
-
- /// <summary>
- /// 鍙栨秷鎷嗗寘
- /// </summary>
- public async Task<WebResponseContent> CancelSplitPackage(string orderNo, string batchNo, string newBarcode)
+ private async Task ExecuteCancelSplitLogic(Dt_SplitPackageRecord splitRecord, Dt_OutStockLockInfo newLockInfo, Dt_StockInfoDetail newStockDetail)
{
- try
- {
- _unitOfWorkManage.BeginTran();
+ // 鎭㈠鍘熷簱瀛�
+ var originalStock = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
+ .FirstAsync(x => x.Barcode == splitRecord.OriginalBarcode && x.StockId == splitRecord.StockId);
- // 鏌ユ壘鎷嗗寘璁板綍鍜屾柊閿佸畾淇℃伅
- var splitRecord = await _splitPackageService.Db.Queryable<Dt_SplitPackageRecord>()
- .Where(x => x.NewBarcode == newBarcode && x.OrderNo == orderNo && !x.IsReverted)
- .FirstAsync();
+ originalStock.StockQuantity += splitRecord.SplitQty;
+ await _stockInfoDetailService.Db.Updateable(originalStock).ExecuteCommandAsync();
- if (splitRecord == null)
- return WebResponseContent.Instance.Error("鏈壘鍒版媶鍖呰褰�");
+ // 鎭㈠鍘熼攣瀹氫俊鎭�
+ var originalLockInfo = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
+ .FirstAsync(x => x.Id == splitRecord.OutStockLockInfoId);
- var newLockInfo = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
- .Where(x => x.CurrentBarcode == newBarcode && x.BatchNo == batchNo)
- .FirstAsync();
+ originalLockInfo.AssignQuantity += splitRecord.SplitQty;
+ originalLockInfo.OrderQuantity += splitRecord.SplitQty;
+ await _outStockLockInfoService.Db.Updateable(originalLockInfo).ExecuteCommandAsync();
- if (newLockInfo == null)
- return WebResponseContent.Instance.Error("鏈壘鍒版柊閿佸畾淇℃伅");
+ // 鍒犻櫎鏂板簱瀛樻槑缁�
+ await _stockInfoDetailService.Db.Deleteable<Dt_StockInfoDetail>()
+ .Where(x => x.Barcode == newLockInfo.CurrentBarcode)
+ .ExecuteCommandAsync();
- // 鎭㈠鍘熷簱瀛�
- var originalStock = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
- .FirstAsync(x => x.Barcode == splitRecord.OriginalBarcode && x.StockId == splitRecord.StockId);
+ // 鍒犻櫎鏂伴攣瀹氫俊鎭�
+ await _outStockLockInfoService.Db.Deleteable<Dt_OutStockLockInfo>()
+ .Where(x => x.Id == newLockInfo.Id)
+ .ExecuteCommandAsync();
- originalStock.StockQuantity += splitRecord.SplitQty;
- await _stockInfoDetailService.Db.Updateable(originalStock).ExecuteCommandAsync();
-
- // 鎭㈠鍘熼攣瀹氫俊鎭�
- var originalLockInfo = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
- .FirstAsync(x => x.Id == splitRecord.OutStockLockInfoId);
-
- originalLockInfo.AssignQuantity += splitRecord.SplitQty;
- await _outStockLockInfoService.Db.Updateable(originalLockInfo).ExecuteCommandAsync();
-
- // 鍒犻櫎鏂板簱瀛樻槑缁�
- await _stockInfoDetailService.Db.Deleteable<Dt_StockInfoDetail>()
- .Where(x => x.Barcode == newBarcode)
- .ExecuteCommandAsync();
-
- // 鍒犻櫎鏂伴攣瀹氫俊鎭�
- await _outStockLockInfoService.Db.Deleteable<Dt_OutStockLockInfo>()
- .Where(x => x.Id == newLockInfo.Id)
- .ExecuteCommandAsync();
-
- // 鏍囪鎷嗗寘璁板綍涓哄凡鎾ら攢
- splitRecord.IsReverted = true;
- splitRecord.RevertTime = DateTime.Now;
- splitRecord.Operator = App.User.UserName;
- await _splitPackageService.Db.Updateable(splitRecord).ExecuteCommandAsync();
-
- _unitOfWorkManage.CommitTran();
-
- return WebResponseContent.Instance.OK("鍙栨秷鎷嗗寘鎴愬姛");
- }
- catch (Exception ex)
- {
- _unitOfWorkManage.RollbackTran();
- _logger.LogError($"鍙栨秷鎷嗗寘澶辫触 - OrderNo: {orderNo}, BatchNo: {batchNo}, Barcode: {newBarcode}, Error: {ex.Message}");
- return WebResponseContent.Instance.Error($"鍙栨秷鎷嗗寘澶辫触锛歿ex.Message}");
- }
+ // 鏍囪鎷嗗寘璁板綍涓哄凡鎾ら攢
+ splitRecord.IsReverted = true;
+ splitRecord.RevertTime = DateTime.Now;
+ splitRecord.RevertOperator = App.User.UserName;
+ await _splitPackageService.Db.Updateable(splitRecord).ExecuteCommandAsync();
}
#endregion
- #region 鍒嗘壒鍥炲簱
+ #region 鏁版嵁鏇存柊鏂规硶
- /// <summary>
- /// 鍒嗘壒鍥炲簱 - 閲婃斁鏈嫞閫夌殑搴撳瓨
- /// </summary>
- public async Task<WebResponseContent> BatchReturnStock(string orderNo, string batchNo)
+ private async Task UpdateBatchAndOrderData(Dt_OutboundBatch batch, Dt_OutboundOrderDetail orderDetail, decimal pickedQty, string orderNo)
{
- try
+ // 鏇存柊鎵规瀹屾垚鏁伴噺
+ batch.CompletedQuantity += pickedQty;
+ if (batch.CompletedQuantity >= batch.BatchQuantity)
{
- _unitOfWorkManage.BeginTran();
-
- // 1. 鏌ユ壘鎵规鏈畬鎴愮殑閿佸畾璁板綍
- var unfinishedLocks = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
- .Where(x => x.OrderNo == orderNo &&
- x.BatchNo == batchNo &&
- x.Status == (int)OutLockStockStatusEnum.鍑哄簱涓�)
- .ToListAsync();
-
- if (!unfinishedLocks.Any())
- return WebResponseContent.Instance.Error("璇ユ壒娆℃病鏈夋湭瀹屾垚鐨勯攣瀹氳褰�");
-
- // 2. 閲婃斁搴撳瓨鍜岄攣瀹氳褰�
- foreach (var lockInfo in unfinishedLocks)
- {
- await ReleaseLockAndStock(lockInfo);
- }
-
- // 3. 鏇存柊鎵规鐘舵��
- await UpdateBatchStatusForReturn(batchNo);
-
- // 4. 鏇存柊璁㈠崟鏄庣粏鐨勫凡鍒嗛厤鏁伴噺
- await UpdateOrderDetailAfterReturn(unfinishedLocks);
-
- _unitOfWorkManage.CommitTran();
-
- return WebResponseContent.Instance.OK("鍒嗘壒鍥炲簱鎴愬姛");
+ batch.BatchStatus = (int)BatchStatusEnum.宸插畬鎴�;
}
- catch (Exception ex)
- {
- _unitOfWorkManage.RollbackTran();
- _logger.LogError($"鍒嗘壒鍥炲簱澶辫触 - OrderNo: {orderNo}, BatchNo: {batchNo}, Error: {ex.Message}");
- return WebResponseContent.Instance.Error($"鍒嗘壒鍥炲簱澶辫触锛歿ex.Message}");
- }
+ await _outboundBatchRepository.Db.Updateable(batch).ExecuteCommandAsync();
+
+ // 鏇存柊璁㈠崟鏄庣粏
+ orderDetail.OverOutQuantity += pickedQty;
+ orderDetail.AllocatedQuantity -= pickedQty;
+ await _outboundOrderDetailService.Db.Updateable(orderDetail).ExecuteCommandAsync();
+
+ // 妫�鏌ヨ鍗曠姸鎬�
+ await CheckAndUpdateOrderStatus(orderNo);
+ }
+
+ private async Task RevertBatchAndOrderData(Dt_PickingRecord pickingRecord)
+ {
+ // 鎭㈠鎵规瀹屾垚鏁伴噺
+ var batch = await _outboundBatchRepository.Db.Queryable<Dt_OutboundBatch>()
+ .FirstAsync(x => x.BatchNo == pickingRecord.BatchNo);
+
+ batch.CompletedQuantity -= pickingRecord.PickQuantity;
+ batch.BatchStatus = (int)BatchStatusEnum.鎵ц涓�;
+ 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();
+
+ // 閲嶆柊妫�鏌ヨ鍗曠姸鎬�
+ await CheckAndUpdateOrderStatus(pickingRecord.OrderNo);
}
private async Task ReleaseLockAndStock(Dt_OutStockLockInfo lockInfo)
@@ -443,20 +609,30 @@
}
// 鏇存柊閿佸畾璁板綍鐘舵�佷负鍥炲簱
- lockInfo.Status = (int)OutLockStockStatusEnum.鍥炲簱涓�;
+ lockInfo.Status = (int)OutLockStockStatusEnum.宸插洖搴�;
await _outStockLockInfoService.Db.Updateable(lockInfo).ExecuteCommandAsync();
}
- private async Task UpdateBatchStatusForReturn(string batchNo)
+ private async Task UpdateBatchStatusForReturn(string batchNo, List<Dt_OutStockLockInfo> returnedLocks)
{
- await _outboundBatchRepository.Db.Updateable<Dt_OutboundBatch>()
- .SetColumns(x => new Dt_OutboundBatch
- {
- BatchStatus = (int)BatchStatusEnum.宸插洖搴�,
- Operator = App.User.UserName
- })
- .Where(x => x.BatchNo == batchNo)
- .ExecuteCommandAsync();
+ var batch = await _outboundBatchRepository.Db.Queryable<Dt_OutboundBatch>()
+ .FirstAsync(x => x.BatchNo == batchNo);
+
+ // 璁＄畻鍥炲簱鏁伴噺
+ var returnedQty = returnedLocks.Sum(x => x.AssignQuantity - x.PickedQty);
+ batch.CompletedQuantity -= returnedQty;
+
+ if (batch.CompletedQuantity <= 0)
+ {
+ batch.BatchStatus = (int)BatchStatusEnum.宸插洖搴�;
+ }
+ else
+ {
+ batch.BatchStatus = (int)BatchStatusEnum.鎵ц涓�;
+ }
+
+ batch.Operator = App.User.UserName;
+ await _outboundBatchRepository.Db.Updateable(batch).ExecuteCommandAsync();
}
private async Task UpdateOrderDetailAfterReturn(List<Dt_OutStockLockInfo> returnedLocks)
@@ -482,10 +658,10 @@
private async Task<string> GenerateNewBarcode()
{
var seq = await _dailySequenceService.GetNextSequenceAsync();
- return "WSLOT" + DateTime.Now.ToString("yyyyMMdd") + seq.ToString()?.PadLeft(5, '0');
+ 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)
{
var splitHistory = new Dt_SplitPackageRecord
{
@@ -503,12 +679,12 @@
await _splitPackageService.Db.Insertable(splitHistory).ExecuteCommandAsync();
}
- private async Task RecordPickingHistory(PickingResult result, string orderNo, string palletCode, string batchNo)
+ private async Task RecordPickingHistory(PickingResult result, string orderNo, string palletCode)
{
var pickingRecord = new Dt_PickingRecord
{
OrderNo = orderNo,
- // BatchNo = batchNo,
+ // BatchNo = result.FinalLockInfo.BatchNo,
OrderDetailId = result.FinalLockInfo.OrderDetailId,
PalletCode = palletCode,
Barcode = result.FinalLockInfo.CurrentBarcode,
@@ -516,53 +692,66 @@
PickQuantity = result.ActualPickedQty,
PickTime = DateTime.Now,
Operator = App.User.UserName,
- OutStockLockId = result.FinalLockInfo.Id
+ OutStockLockId = result.FinalLockInfo.Id,
+ // IsCancelled = false
};
await Db.Insertable(pickingRecord).ExecuteCommandAsync();
}
- private async Task UpdateOrderRelatedData(int orderDetailId, decimal pickedQty, string orderNo)
- {
- // 鏇存柊璁㈠崟鏄庣粏鐨勫凡鍑哄簱鏁伴噺
- await _outboundOrderDetailService.Db.Updateable<Dt_OutboundOrderDetail>()
- .SetColumns(x => new Dt_OutboundOrderDetail
- {
- OverOutQuantity = x.OverOutQuantity + pickedQty,
- AllocatedQuantity = x.AllocatedQuantity - pickedQty
- })
- .Where(x => x.Id == orderDetailId)
- .ExecuteCommandAsync();
-
- // 妫�鏌ヨ鍗曠姸鎬�
- await CheckAndUpdateOrderStatus(orderNo);
- }
-
private async Task CheckAndUpdateOrderStatus(string orderNo)
{
var orderDetails = await _outboundOrderDetailService.Db.Queryable<Dt_OutboundOrderDetail>()
- .LeftJoin<Dt_OutboundOrder>((o, item) => o.OrderId == item.Id)
- .Where((o, item) => item.OrderNo == orderNo)
- .Select((o, item) => o)
- .ToListAsync();
-
-
+ .LeftJoin<Dt_OutboundOrder>((detail, order) => detail.OrderId == order.Id)
+ .Where((detail, order) => order.OrderNo == orderNo)
+ .Select((detail, order) => detail)
+ .ToListAsync();
bool allCompleted = orderDetails.All(x => x.OverOutQuantity >= x.NeedOutQuantity);
- if (allCompleted)
- {
- await _outboundOrderService.Db.Updateable<Dt_OutboundOrder>()
- .SetColumns(x => new Dt_OutboundOrder { OrderStatus = (int)OutOrderStatusEnum.鍑哄簱瀹屾垚 })
- .Where(x => x.OrderNo == orderNo)
- .ExecuteCommandAsync();
- }
+ var orderStatus = allCompleted ? (int)OutOrderStatusEnum.鍑哄簱瀹屾垚 : (int)OutOrderStatusEnum.鍑哄簱涓�;
+
+ await _outboundOrderService.Db.Updateable<Dt_OutboundOrder>()
+ .SetColumns(x => x.OrderStatus == orderStatus)
+ .Where(x => x.OrderNo == orderNo)
+ .ExecuteCommandAsync();
+ }
+
+ #endregion
+
+ #region DTO绫�
+
+ public class PickingResult
+ {
+ public Dt_OutStockLockInfo FinalLockInfo { get; set; }
+ public decimal ActualPickedQty { get; set; }
+ }
+
+ public class RevertPickingResult
+ {
+ public Dt_OutStockLockInfo LockInfo { get; set; }
+ public Dt_StockInfoDetail StockDetail { get; set; }
+ }
+
+ public class SplitResultDto
+ {
+ public string NewBarcode { get; set; }
+ }
+
+ public class ValidationResult<T>
+ {
+ public bool IsValid { get; set; }
+ public string ErrorMessage { get; set; }
+ public T Data { get; set; }
+
+ public static ValidationResult<T> Success(T data) => new ValidationResult<T> { IsValid = true, Data = data };
+ public static ValidationResult<T> Error(string message) => new ValidationResult<T> { IsValid = false, ErrorMessage = message };
}
#endregion
}
-
+
// 鏀寔绫�
public class SplitResultDto
{
--
Gitblit v1.9.3