From 8639f19c82f6e263654db44286256bb8d028d2c2 Mon Sep 17 00:00:00 2001
From: 647556386 <647556386@qq.com>
Date: 星期日, 30 十一月 2025 10:10:40 +0800
Subject: [PATCH] 1
---
项目代码/WMS无仓储版/WIDESEA_WMSServer/WIDESEA_OutboundService/OutboundBatchPickingService.cs | 1441 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++
1 files changed, 1,441 insertions(+), 0 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"
new file mode 100644
index 0000000..bbd2251
--- /dev/null
+++ "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"
@@ -0,0 +1,1441 @@
+锘縰sing Microsoft.Extensions.Logging;
+using SqlSugar;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using WIDESEA_BasicService;
+using WIDESEA_Common.CommonEnum;
+using WIDESEA_Common.OrderEnum;
+using WIDESEA_Common.StockEnum;
+using WIDESEA_Core;
+using WIDESEA_Core.BaseRepository;
+using WIDESEA_Core.BaseServices;
+using WIDESEA_DTO.Outbound;
+using WIDESEA_IAllocateService;
+using WIDESEA_IBasicService;
+using WIDESEA_IOutboundService;
+using WIDESEA_IStockService;
+using WIDESEA_Model.Models;
+using WIDESEA_Model.Models.Basic;
+using WIDESEA_Model.Models.Outbound;
+using static WIDESEA_OutboundService.OutboundBatchPickingService;
+
+namespace WIDESEA_OutboundService
+{
+ public class OutboundBatchPickingService : ServiceBase<Dt_PickingRecord, IRepository<Dt_PickingRecord>>, IOutboundBatchPickingService
+ {
+
+
+ private readonly IUnitOfWorkManage _unitOfWorkManage;
+ public IRepository<Dt_PickingRecord> Repository => BaseDal;
+
+ private readonly IStockInfoService _stockInfoService;
+ private readonly IStockService _stockService;
+ private readonly IOutStockLockInfoService _outStockLockInfoService;
+ private readonly IStockInfoDetailService _stockInfoDetailService;
+ private readonly ILocationInfoService _locationInfoService;
+ private readonly IOutboundOrderDetailService _outboundOrderDetailService;
+ private readonly IOutboundOrderService _outboundOrderService;
+ private readonly ISplitPackageService _splitPackageService;
+ private readonly IRepository<Dt_Task> _taskRepository;
+ private readonly IESSApiService _eSSApiService;
+ private readonly IInvokeMESService _invokeMESService;
+ private readonly IDailySequenceService _dailySequenceService;
+ private readonly IAllocateService _allocateService;
+ private readonly IRepository<Dt_OutboundBatch> _outboundBatchRepository;
+ private readonly ILogger<OutboundPickingService> _logger;
+
+ private Dictionary<string, string> stations = new Dictionary<string, string>
+ {
+ {"2-1","2-9" },
+ {"3-1","3-9" },
+
+ };
+
+ private Dictionary<string, string> movestations = new Dictionary<string, string>
+ {
+ {"2-1","2-5" },
+ {"3-1","3-5" },
+
+ };
+
+ 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)
+ {
+ _unitOfWorkManage = unitOfWorkManage;
+ _stockInfoService = stockInfoService;
+ _stockService = stockService;
+ _outStockLockInfoService = outStockLockInfoService;
+ _stockInfoDetailService = stockInfoDetailService;
+ _locationInfoService = locationInfoService;
+ _outboundOrderDetailService = outboundOrderDetailService;
+ _splitPackageService = splitPackageService;
+ _outboundOrderService = outboundOrderService;
+ _taskRepository = taskRepository;
+ _eSSApiService = eSSApiService;
+ _logger = logger;
+ _invokeMESService = invokeMESService;
+ _dailySequenceService = dailySequenceService;
+ _allocateService = allocateService;
+ _outboundBatchRepository = outboundBatchRepository;
+ }
+
+ // <summary>
+ /// 鑾峰彇鎵樼洏鐨勯攣瀹氫俊鎭�
+ /// </summary>
+ public async Task<List<PalletLockInfoDto>> GetPalletLockInfos(string orderNo, string palletCode)
+ {
+ var lockInfos = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
+ .Where(x => x.OrderNo == orderNo && x.PalletCode == palletCode)
+ .Select(x => new
+ {
+ x.Id,
+ x.OrderNo,
+ x.BatchNo,
+ x.MaterielCode,
+ x.CurrentBarcode,
+ x.AssignQuantity,
+ x.PickedQty,
+ x.Status,
+ x.LocationCode,
+ x.PalletCode
+ }).ToListAsync();
+
+ var lockInfoDtos = lockInfos.Select(x => new PalletLockInfoDto
+ {
+ Id = x.Id,
+ OrderNo = x.OrderNo,
+ BatchNo = x.BatchNo,
+ MaterielCode = x.MaterielCode,
+ CurrentBarcode = x.CurrentBarcode,
+ AssignQuantity = x.AssignQuantity,
+ PickedQty = x.PickedQty,
+ Status = x.Status,
+ LocationCode = x.LocationCode,
+ PalletCode = x.PalletCode,
+ CanSplit = (x.Status == (int)OutLockStockStatusEnum.鍑哄簱涓� && x.AssignQuantity - x.PickedQty > 0),
+ CanPick = (x.Status == (int)OutLockStockStatusEnum.鍑哄簱涓� && x.PickedQty < x.AssignQuantity)
+ }).ToList();
+
+ return lockInfoDtos;
+ }
+ #region 鏌ヨ鏂规硶
+
+ /// <summary>
+ /// 鑾峰彇鎵樼洏鐨勫凡鎷ｉ�夊垪琛�
+ /// </summary>
+ public async Task<List<PalletPickedInfoDto>> GetPalletPickedList(string orderNo, string palletCode)
+ {
+ var pickedList = await Db.Queryable<Dt_PickingRecord>()
+ .Where(x => x.OrderNo == orderNo &&
+ x.PalletCode == palletCode &&
+ !x.IsCancelled)
+ .Select(x => new PalletPickedInfoDto
+ {
+ Id = x.Id,
+ OrderNo = x.OrderNo,
+ OrderDetailId = x.OrderDetailId,
+ PalletCode = x.PalletCode,
+ Barcode = x.Barcode,
+ MaterielCode = x.MaterielCode,
+ PickedQty = x.PickQuantity,
+ PickTime = x.PickTime,
+ Operator = x.Operator,
+ LocationCode = x.LocationCode
+ })
+ .ToListAsync();
+
+ return pickedList;
+ }
+
+ /// <summary>
+ /// 鑾峰彇鎵樼洏鐘舵��
+ /// </summary>
+ public async Task<PalletStatusDto> GetPalletStatus(string orderNo, string palletCode)
+ {
+ // 鑾峰彇鎵樼洏鐨勯攣瀹氫俊鎭�
+ var lockInfos = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
+ .Where(x => x.OrderNo == orderNo && x.PalletCode == palletCode)
+ .ToListAsync();
+
+ if (!lockInfos.Any())
+ {
+ return new PalletStatusDto
+ {
+ OrderNo = orderNo,
+ PalletCode = palletCode,
+ Status = (int)PalletStatusEnum.鏃犱换鍔�,
+ StatusText = "鏃犱换鍔�",
+ TotalItems = 0,
+ CompletedItems = 0,
+ PendingItems = 0
+ };
+ }
+
+ var totalItems = lockInfos.Count;
+ var completedItems = lockInfos.Count(x => x.Status == (int)OutLockStockStatusEnum.鎷ｉ�夊畬鎴�);
+ var pendingItems = lockInfos.Count(x => x.Status == (int)OutLockStockStatusEnum.鍑哄簱涓�);
+
+ var status = PalletStatusEnum.鎷ｉ�変腑;
+ if (pendingItems == 0 && completedItems > 0)
+ {
+ status = PalletStatusEnum.宸插畬鎴�;
+ }
+ else if (pendingItems > 0 && completedItems == 0)
+ {
+ status = PalletStatusEnum.鏈紑濮�;
+ }
+ else if (pendingItems > 0 && completedItems > 0)
+ {
+ status = PalletStatusEnum.鎷ｉ�変腑;
+ }
+
+ return new PalletStatusDto
+ {
+ OrderNo = orderNo,
+ PalletCode = palletCode,
+ Status = (int)status,
+ StatusText = GetPalletStatusText(status),
+ TotalItems = totalItems,
+ CompletedItems = completedItems,
+ PendingItems = pendingItems
+ };
+ }
+
+ /// <summary>
+ /// 鑾峰彇鎷嗗寘淇℃伅
+ /// </summary>
+ public async Task<SplitPackageInfoDto> GetSplitPackageInfo(string orderNo, string palletCode, string barcode)
+ {
+ // 鏌ユ壘閿佸畾淇℃伅
+ var lockInfo = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
+ .Where(x => x.OrderNo == orderNo &&
+ x.PalletCode == palletCode &&
+ x.CurrentBarcode == barcode
+ //&& x.Status == (int)OutLockStockStatusEnum.鍑哄簱涓�
+ )
+ .FirstAsync();
+
+ if (lockInfo == null)
+ throw new Exception("鏈壘鍒版湁鏁堢殑閿佸畾淇℃伅");
+
+ // 璁＄畻鍓╀綑鍙媶鏁伴噺
+ var remainQuantity = lockInfo.AssignQuantity - lockInfo.PickedQty;
+
+ return new SplitPackageInfoDto
+ {
+ OrderNo = orderNo,
+ PalletCode = palletCode,
+ Barcode = barcode,
+ MaterielCode = lockInfo.MaterielCode,
+ RemainQuantity = remainQuantity,
+ AssignQuantity = lockInfo.AssignQuantity,
+ PickedQty = lockInfo.PickedQty
+ };
+ }
+
+ #endregion
+
+ #region 鍙栬蛋绌虹閫昏緫
+
+ /// <summary>
+ /// 鍙栬蛋绌虹 - 娓呯悊宸插畬鎴愭嫞閫夌殑鎵樼洏鏁版嵁
+ /// </summary>
+ public async Task<WebResponseContent> RemoveEmptyPallet(string orderNo, string palletCode)
+ {
+ try
+ {
+ _unitOfWorkManage.BeginTran();
+
+ // 楠岃瘉鎵樼洏鏄惁鍙互鍙栬蛋锛堝繀椤诲叏閮ㄥ畬鎴愭嫞閫夛級
+ var validationResult = await ValidateEmptyPalletRemoval(orderNo, palletCode);
+ if (!validationResult.IsValid)
+ return WebResponseContent.Instance.Error(validationResult.ErrorMessage);
+
+ var completedLocks = validationResult.Data;
+
+ // 娓呯悊閿佸畾璁板綍锛堟爣璁颁负宸插畬鎴愶級
+ await CleanupCompletedLocks(completedLocks);
+
+ // 鏇存柊鐩稿叧璁㈠崟鐘舵��
+ await UpdateOrderStatusAfterPalletRemoval(orderNo);
+
+ // 璁板綍鎿嶄綔鍘嗗彶
+ // await RecordEmptyPalletRemoval(orderNo, palletCode, completedLocks);
+
+ _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}");
+ }
+ }
+
+ /// <summary>
+ /// 楠岃瘉绌虹鍙栬蛋鏉′欢
+ /// </summary>
+ private async Task<ValidationResult<List<Dt_OutStockLockInfo>>> ValidateEmptyPalletRemoval(string orderNo, string palletCode)
+ {
+ // 鑾峰彇鎵樼洏鐨勬墍鏈夐攣瀹氳褰�
+ var lockInfos = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
+ .Where(x => x.OrderNo == orderNo && x.PalletCode == palletCode)
+ .ToListAsync();
+
+ if (!lockInfos.Any())
+ return ValidationResult<List<Dt_OutStockLockInfo>>.Error("璇ユ墭鐩樻病鏈夐攣瀹氳褰�");
+
+ // 妫�鏌ユ槸鍚︽湁鏈畬鎴愮殑閿佸畾璁板綍
+ var unfinishedLocks = lockInfos.Where(x =>
+ x.Status == (int)OutLockStockStatusEnum.鍑哄簱涓� ||
+ x.Status == (int)OutLockStockStatusEnum.鍥炲簱涓�).ToList();
+
+ if (unfinishedLocks.Any())
+ {
+ var unfinishedCount = unfinishedLocks.Count;
+ var unfinishedQty = unfinishedLocks.Sum(x => x.AssignQuantity - x.PickedQty);
+ return ValidationResult<List<Dt_OutStockLockInfo>>.Error(
+ $"鎵樼洏杩樻湁{unfinishedCount}鏉℃湭瀹屾垚璁板綍锛屽墿浣欐暟閲弡unfinishedQty}锛屼笉鑳藉彇璧扮┖绠�");
+ }
+
+ // 鑾峰彇宸插畬鎴愮殑閿佸畾璁板綍
+ var completedLocks = lockInfos.Where(x =>
+ x.Status == (int)OutLockStockStatusEnum.鎷ｉ�夊畬鎴�).ToList();
+
+ if (!completedLocks.Any())
+ return ValidationResult<List<Dt_OutStockLockInfo>>.Error("璇ユ墭鐩樻病鏈夊凡瀹屾垚鎷ｉ�夌殑璁板綍");
+
+ return ValidationResult<List<Dt_OutStockLockInfo>>.Success(completedLocks);
+ }
+
+ /// <summary>
+ /// 娓呯悊宸插畬鎴愮殑閿佸畾璁板綍
+ /// </summary>
+ private async Task CleanupCompletedLocks(List<Dt_OutStockLockInfo> completedLocks)
+ {
+ 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)
+ {
+ // 濡傛灉搴撳瓨宸茬粡鍑哄簱瀹屾垚锛屾爣璁颁负宸叉竻鐞�
+ if (stockDetail.Status == (int)StockStatusEmun.鍑哄簱瀹屾垚)
+ {
+ stockDetail.Status = (int)StockStatusEmun.宸叉竻鐞�;
+ await _stockInfoDetailService.Db.Updateable(stockDetail).ExecuteCommandAsync();
+ }
+ }
+ }
+
+ /// <summary>
+ /// 鏇存柊璁㈠崟鐘舵��
+ /// </summary>
+ private async Task UpdateOrderStatusAfterPalletRemoval(string orderNo)
+ {
+ // 妫�鏌ヨ鍗曟槸鍚︽墍鏈夋墭鐩橀兘宸插畬鎴�
+ var allLocks = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
+ .Where(x => x.OrderNo == orderNo)
+ .ToListAsync();
+
+ var unfinishedPallets = allLocks
+ .GroupBy(x => x.PalletCode)
+ .Where(g => g.Any(x => x.Status == (int)OutLockStockStatusEnum.鍑哄簱涓� ||
+ x.Status == (int)OutLockStockStatusEnum.鍥炲簱涓�))
+ .ToList();
+
+ // 濡傛灉娌℃湁鏈畬鎴愮殑鎵樼洏锛屾洿鏂拌鍗曠姸鎬佷负鍑哄簱瀹屾垚
+ if (!unfinishedPallets.Any())
+ {
+ await _outboundOrderService.Db.Updateable<Dt_OutboundOrder>()
+ .SetColumns(x => new Dt_OutboundOrder
+ {
+ OrderStatus = (int)OutOrderStatusEnum.鍑哄簱瀹屾垚,
+ })
+ .Where(x => x.OrderNo == orderNo)
+ .ExecuteCommandAsync();
+ }
+ }
+
+ /// <summary>
+ /// 璁板綍绌虹鍙栬蛋鍘嗗彶
+ /// </summary>
+ private async Task RecordEmptyPalletRemoval(string orderNo, string palletCode, List<Dt_OutStockLockInfo> completedLocks)
+ {
+ var removalRecord = new Dt_EmptyPalletRemoval
+ {
+ OrderNo = orderNo,
+ PalletCode = palletCode,
+ RemovalTime = DateTime.Now,
+ Operator = App.User.UserName,
+ CompletedItemsCount = completedLocks.Count,
+ TotalPickedQuantity = completedLocks.Sum(x => x.PickedQty)
+ };
+
+ await Db.Insertable(removalRecord).ExecuteCommandAsync();
+ }
+
+ #endregion
+
+ #region 杈呭姪鏂规硶
+
+ private string GetPalletStatusText(PalletStatusEnum status)
+ {
+ return status switch
+ {
+ PalletStatusEnum.鏈紑濮� => "鏈紑濮�",
+ PalletStatusEnum.鎷ｉ�変腑 => "鎷ｉ�変腑",
+ PalletStatusEnum.宸插畬鎴� => "宸插畬鎴�",
+ PalletStatusEnum.鏃犱换鍔� => "鏃犱换鍔�",
+ _ => "鏈煡"
+ };
+ }
+
+ #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 鎵嬪姩鎷嗗寘
+
+ /// <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 鍙栨秷鎷嗗寘
+
+ #region 鍙栨秷鎷嗗寘 - 淇鐗堟湰
+
+ /// <summary>
+ /// 鍙栨秷鎷嗗寘 - 鏀寔澶氭鎷嗗寘鐨勬儏鍐�
+ /// </summary>
+ public async Task<WebResponseContent> CancelSplitPackage(string orderNo, string palletCode, string newBarcode)
+ {
+ try
+ {
+ _unitOfWorkManage.BeginTran();
+
+ // 1. 鏌ユ壘鎷嗗寘璁板綍骞堕獙璇�
+ var validationResult = await ValidateCancelSplitRequest(orderNo, palletCode, newBarcode);
+ if (!validationResult.IsValid)
+ return WebResponseContent.Instance.Error(validationResult.ErrorMessage);
+
+ var (splitRecord, newLockInfo, newStockDetail) = validationResult.Data;
+
+ // 2. 鏌ユ壘鍘熷閿佸畾淇℃伅
+ var originalLockInfo = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
+ .FirstAsync(x => x.Id == splitRecord.OutStockLockInfoId);
+
+ // 3. 妫�鏌ヨ鏉＄爜鏄惁琚啀娆℃媶鍖�
+ var childSplitRecords = await _splitPackageService.Db.Queryable<Dt_SplitPackageRecord>()
+ .Where(x => x.OriginalBarcode == newBarcode && !x.IsReverted)
+ .ToListAsync();
+
+ if (childSplitRecords.Any())
+ {
+ return WebResponseContent.Instance.Error("璇ユ潯鐮佸凡琚啀娆℃媶鍖咃紝璇峰厛鍙栨秷鍚庣画鐨勬媶鍖呮搷浣�");
+ }
+
+ // 4. 鎵ц鍙栨秷鎷嗗寘閫昏緫
+ await ExecuteCancelSplitLogic(splitRecord, originalLockInfo, newLockInfo, newStockDetail);
+
+ _unitOfWorkManage.CommitTran();
+
+ return WebResponseContent.Instance.OK("鍙栨秷鎷嗗寘鎴愬姛");
+ }
+ catch (Exception ex)
+ {
+ _unitOfWorkManage.RollbackTran();
+ _logger.LogError($"鍙栨秷鎷嗗寘澶辫触 - OrderNo: {orderNo}, PalletCode: {palletCode}, Barcode: {newBarcode}, Error: {ex.Message}");
+ return WebResponseContent.Instance.Error($"鍙栨秷鎷嗗寘澶辫触锛歿ex.Message}");
+ }
+ }
+
+ /// <summary>
+ /// 鎵ц鍙栨秷鎷嗗寘閫昏緫 - 淇鐗堟湰
+ /// </summary>
+ private async Task ExecuteCancelSplitLogic(Dt_SplitPackageRecord splitRecord,
+ Dt_OutStockLockInfo originalLockInfo, Dt_OutStockLockInfo newLockInfo,
+ Dt_StockInfoDetail newStockDetail)
+ {
+ // 1. 鎭㈠鍘熼攣瀹氫俊鎭�
+ // 娉ㄦ剰锛氳繖閲岄渶瑕佺疮鍔狅紝鑰屼笉鏄畝鍗曠殑璧嬪�硷紝鍥犱负鍙兘鏈夊娆℃媶鍖�
+ originalLockInfo.AssignQuantity += splitRecord.SplitQty;
+ originalLockInfo.OrderQuantity += splitRecord.SplitQty;
+
+ // 濡傛灉鍘熼攣瀹氫俊鎭殑鐘舵�佹槸鎷ｉ�夊畬鎴愶紝闇�瑕侀噸鏂拌缃负鍑哄簱涓�
+ if (originalLockInfo.Status == (int)OutLockStockStatusEnum.鎷ｉ�夊畬鎴�)
+ {
+ originalLockInfo.Status = (int)OutLockStockStatusEnum.鍑哄簱涓�;
+ }
+
+ await _outStockLockInfoService.Db.Updateable(originalLockInfo).ExecuteCommandAsync();
+
+ // 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.鍑哄簱瀹屾垚)
+ {
+ originalStock.Status = (int)StockStatusEmun.鍑哄簱閿佸畾;
+ }
+
+ 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);
+ }
+
+ /// <summary>
+ /// 楠岃瘉鍙栨秷鎷嗗寘璇锋眰 - 澧炲己鐗堟湰
+ /// </summary>
+ 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 childSplitRecords = await _splitPackageService.Db.Queryable<Dt_SplitPackageRecord>()
+ .Where(x => x.OriginalBarcode == newBarcode && !x.IsReverted)
+ .ToListAsync();
+
+ if (childSplitRecords.Any())
+ {
+ var childBarcodes = string.Join(", ", childSplitRecords.Select(x => x.NewBarcode));
+ return ValidationResult<(Dt_SplitPackageRecord, Dt_OutStockLockInfo, Dt_StockInfoDetail)>.Error(
+ $"璇ユ潯鐮佸凡琚啀娆℃媶鍖咃紝鐢熸垚鐨勬柊鏉＄爜锛歿childBarcodes}锛岃鍏堝彇娑堝悗缁媶鍖�");
+ }
+
+ 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 鎵归噺鍙栨秷鎷嗗寘閾�
+
+ /// <summary>
+ /// 鎵归噺鍙栨秷鎷嗗寘閾� - 鍙栨秷鏌愪釜鏉＄爜鍙婂叾鎵�鏈夊悗缁媶鍖�
+ /// </summary>
+ public async Task<WebResponseContent> CancelSplitPackageChain(string orderNo, string palletCode, string startBarcode)
+ {
+ try
+ {
+ _unitOfWorkManage.BeginTran();
+
+ // 1. 鏌ユ壘鎵�鏈夌浉鍏崇殑鎷嗗寘璁板綍锛堝舰鎴愭媶鍖呴摼锛�
+ var splitChain = await GetSplitPackageChain(orderNo, startBarcode);
+
+ if (!splitChain.Any())
+ return WebResponseContent.Instance.Error("鏈壘鍒版媶鍖呰褰�");
+
+ // 2. 鎸夋媶鍖呴『搴忓�掑簭鍙栨秷锛堜粠鏈�鏂扮殑寮�濮嬪彇娑堬級
+ var reversedChain = splitChain.OrderByDescending(x => x.SplitTime).ToList();
+
+ foreach (var splitRecord in reversedChain)
+ {
+ await CancelSingleSplitPackage(splitRecord, palletCode);
+ }
+
+ _unitOfWorkManage.CommitTran();
+
+ return WebResponseContent.Instance.OK($"鎴愬姛鍙栨秷鎷嗗寘閾撅紝鍏眥reversedChain.Count}娆℃媶鍖呮搷浣�");
+ }
+ catch (Exception ex)
+ {
+ _unitOfWorkManage.RollbackTran();
+ _logger.LogError($"鍙栨秷鎷嗗寘閾惧け璐� - OrderNo: {orderNo}, StartBarcode: {startBarcode}, Error: {ex.Message}");
+ return WebResponseContent.Instance.Error($"鍙栨秷鎷嗗寘閾惧け璐ワ細{ex.Message}");
+ }
+ }
+
+ /// <summary>
+ /// 鑾峰彇鎷嗗寘閾� - 鏌ユ壘鏌愪釜鏉＄爜鐨勬墍鏈夋媶鍖呰褰曪紙鍖呮嫭鍚庣画鎷嗗寘锛�
+ /// </summary>
+ public async Task<List<Dt_SplitPackageRecord>> GetSplitPackageChain(string orderNo, string startBarcode)
+ {
+ var allSplitRecords = new List<Dt_SplitPackageRecord>();
+ var visitedBarcodes = new HashSet<string>(); // 闃叉寰幆寮曠敤
+
+ // 浣跨敤闃熷垪杩涜骞垮害浼樺厛鎼滅储
+ var queue = new Queue<string>();
+ queue.Enqueue(startBarcode);
+ visitedBarcodes.Add(startBarcode);
+
+ while (queue.Count > 0)
+ {
+ var currentBarcode = queue.Dequeue();
+
+ // 鏌ユ壘浠ュ綋鍓嶆潯鐮佷负鍘熸潯鐮佺殑鎵�鏈夋媶鍖呰褰�
+ var splitRecords = await _splitPackageService.Db.Queryable<Dt_SplitPackageRecord>()
+ .Where(x => x.OriginalBarcode == currentBarcode &&
+ x.OrderNo == orderNo &&
+ !x.IsReverted)
+ .ToListAsync();
+
+ foreach (var record in splitRecords)
+ {
+ // 閬垮厤閲嶅澶勭悊
+ if (!visitedBarcodes.Contains(record.NewBarcode))
+ {
+ allSplitRecords.Add(record);
+ queue.Enqueue(record.NewBarcode);
+ visitedBarcodes.Add(record.NewBarcode);
+ }
+ }
+ }
+
+ return allSplitRecords;
+ }
+
+ /// <summary>
+ /// 鍙栨秷鍗曚釜鎷嗗寘璁板綍
+ /// </summary>
+ private async Task CancelSingleSplitPackage(Dt_SplitPackageRecord splitRecord, string palletCode)
+ {
+ // 鏌ユ壘鐩稿叧鏁版嵁
+ var newLockInfo = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
+ .Where(x => x.CurrentBarcode == splitRecord.NewBarcode &&
+ x.PalletCode == palletCode)
+ .FirstAsync();
+
+ var newStockDetail = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
+ .FirstAsync(x => x.Barcode == splitRecord.NewBarcode);
+
+ var originalLockInfo = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
+ .FirstAsync(x => x.Id == splitRecord.OutStockLockInfoId);
+
+ // 鎵ц鍙栨秷閫昏緫
+ await ExecuteCancelSplitLogic(splitRecord, originalLockInfo, newLockInfo, newStockDetail);
+ }
+ #endregion
+
+ #region 鎷嗗寘淇℃伅鏌ヨ澧炲己
+
+ /// <summary>
+ /// 鑾峰彇鎷嗗寘閾句俊鎭�
+ /// </summary>
+ public async Task<WebResponseContent> GetSplitPackageChainInfo(string orderNo, string barcode)
+ {
+ try
+ {
+ var splitChain = await GetSplitPackageChain(orderNo, barcode);
+
+ var chainInfo = new SplitPackageChainInfoDto
+ {
+ OriginalBarcode = barcode,
+ TotalSplitTimes = splitChain.Count,
+ SplitChain = splitChain.Select(x => new SplitChainItemDto
+ {
+ SplitTime = x.SplitTime,
+ OriginalBarcode = x.OriginalBarcode,
+ NewBarcode = x.NewBarcode,
+ SplitQuantity = x.SplitQty,
+ Operator = x.Operator,
+ IsReverted = x.IsReverted
+ }).ToList()
+ };
+
+ return WebResponseContent.Instance.OK("鑾峰彇鎴愬姛", chainInfo);
+ }
+ catch (Exception ex)
+ {
+ _logger.LogError($"鑾峰彇鎷嗗寘閾句俊鎭け璐� - OrderNo: {orderNo}, Barcode: {barcode}, Error: {ex.Message}");
+ return WebResponseContent.Instance.Error("鑾峰彇鎷嗗寘閾句俊鎭け璐�");
+ }
+ }
+
+
+ /// <summary>
+ /// 鏌ユ壘鏍规潯鐮�
+ /// </summary>
+ public async Task<string> FindRootBarcode(string orderNo, string startBarcode)
+ {
+ var currentBarcode = startBarcode;
+ var visited = new HashSet<string>();
+
+ while (!string.IsNullOrEmpty(currentBarcode) && !visited.Contains(currentBarcode))
+ {
+ visited.Add(currentBarcode);
+
+ // 鏌ユ壘褰撳墠鏉＄爜鏄惁鏄敱鍏朵粬鏉＄爜鎷嗗寘鑰屾潵
+ var parentRecord = await _splitPackageService.Db.Queryable<Dt_SplitPackageRecord>()
+ .Where(x => x.NewBarcode == currentBarcode &&
+ x.OrderNo == orderNo &&
+ !x.IsReverted)
+ .FirstAsync();
+
+ if (parentRecord == null)
+ {
+ // 娌℃湁鐖剁骇鎷嗗寘璁板綍锛岃鏄庤繖鏄牴鏉＄爜
+ return currentBarcode;
+ }
+
+ currentBarcode = parentRecord.OriginalBarcode;
+ }
+
+ // 濡傛灉鍑虹幇寰幆寮曠敤锛岃繑鍥炶捣濮嬫潯鐮�
+ return startBarcode;
+ }
+ #endregion
+
+ #region 鏇存柊鎵规鐘舵�佹鏌�
+
+ /// <summary>
+ /// 妫�鏌ュ苟鏇存柊鎵规鐘舵��
+ /// </summary>
+ private async Task CheckAndUpdateBatchStatus(string batchNo)
+ {
+ var batch = await _outboundBatchRepository.Db.Queryable<Dt_OutboundBatch>()
+ .FirstAsync(x => x.BatchNo == batchNo);
+
+ if (batch != null)
+ {
+ // 閲嶆柊璁＄畻鎵规瀹屾垚鏁伴噺
+ var batchLocks = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
+ .Where(x => x.BatchNo == batchNo)
+ .ToListAsync();
+
+ var completedQuantity = batchLocks.Where(x => x.Status == (int)OutLockStockStatusEnum.鎷ｉ�夊畬鎴�)
+ .Sum(x => x.PickedQty);
+
+ batch.CompletedQuantity = completedQuantity;
+
+ // 鏇存柊鎵规鐘舵��
+ if (batch.CompletedQuantity >= batch.BatchQuantity)
+ {
+ batch.BatchStatus = (int)BatchStatusEnum.宸插畬鎴�;
+ }
+ else if (batch.CompletedQuantity > 0)
+ {
+ batch.BatchStatus = (int)BatchStatusEnum.鎵ц涓�;
+ }
+ else
+ {
+ batch.BatchStatus = (int)BatchStatusEnum.鍒嗛厤涓�;
+ }
+
+ await _outboundBatchRepository.Db.Updateable(batch).ExecuteCommandAsync();
+ }
+ }
+
+ #endregion
+
+ #region DTO绫�
+
+
+
+ public class SplitPackageChainInfoDto
+ {
+ 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; }
+ }
+
+ public class SplitChainItemDto
+ {
+ 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; }
+ }
+
+ #endregion
+
+ #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.PalletCode == palletCode &&
+ x.CurrentBarcode == barcode &&
+ x.Status == (int)OutLockStockStatusEnum.鍑哄簱涓�)
+ .FirstAsync();
+
+ if (lockInfo == null)
+ return ValidationResult<(Dt_OutStockLockInfo, Dt_OutboundOrderDetail, Dt_StockInfoDetail, Dt_OutboundBatch)>.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);
+
+ // 楠岃瘉搴撳瓨鏁伴噺
+ 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.OutboundBatchNo);
+
+ 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));
+ }
+
+ #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)
+ {
+ lockInfo.Status = (int)OutLockStockStatusEnum.鎷ｉ�夊畬鎴�;
+ }
+ await _outStockLockInfoService.Db.Updateable(lockInfo).ExecuteCommandAsync();
+
+ // 鏇存柊搴撳瓨
+ stockDetail.StockQuantity -= actualPickedQty;
+ stockDetail.OutboundQuantity += actualPickedQty;
+
+ if (stockDetail.StockQuantity <= 0)
+ {
+ stockDetail.Status = (int)StockStatusEmun.鍑哄簱瀹屾垚;
+ }
+ await _stockInfoDetailService.Db.Updateable(stockDetail).ExecuteCommandAsync();
+
+ return new PickingResult
+ {
+ FinalLockInfo = lockInfo,
+ ActualPickedQty = actualPickedQty
+ };
+ }
+
+ 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,
+ decimal splitQuantity, string palletCode)
+ {
+ // 鐢熸垚鏂版潯鐮�
+ string newBarcode = await GenerateNewBarcode();
+
+ // 鍒涘缓鏂板簱瀛樻槑缁�
+ 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();
+
+ // 鏇存柊鍘熷簱瀛樻槑缁�
+ stockDetail.StockQuantity -= splitQuantity;
+ await _stockInfoDetailService.Db.Updateable(stockDetail).ExecuteCommandAsync();
+
+
+ var newLockInfo = new Dt_OutStockLockInfo
+ {
+ OrderNo = lockInfo.OrderNo,
+ OrderDetailId = lockInfo.OrderDetailId,
+ BatchNo = lockInfo.BatchNo,
+ MaterielCode = lockInfo.MaterielCode,
+ MaterielName = lockInfo.MaterielName,
+ StockId = lockInfo.StockId,
+ OrderQuantity = splitQuantity,
+ //OriginalQuantity = quantity,
+ 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,
+ // OriginalLockQuantity = quantity,
+ 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();
+
+ // 鏇存柊鍘熼攣瀹氫俊鎭�
+ lockInfo.AssignQuantity -= splitQuantity;
+ lockInfo.OrderQuantity -= splitQuantity;
+ await _outStockLockInfoService.Db.Updateable(lockInfo).ExecuteCommandAsync();
+
+ // 璁板綍鎷嗗寘鍘嗗彶
+ await RecordSplitHistory(lockInfo, stockDetail, splitQuantity, newBarcode);
+
+ return new SplitResultDto { NewBarcode = newBarcode };
+ }
+
+ private async Task ExecuteCancelSplitLogic(Dt_SplitPackageRecord splitRecord, Dt_OutStockLockInfo newLockInfo, Dt_StockInfoDetail newStockDetail)
+ {
+ // 鎭㈠鍘熷簱瀛�
+ var originalStock = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
+ .FirstAsync(x => x.Barcode == splitRecord.OriginalBarcode && x.StockId == splitRecord.StockId);
+
+ 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;
+ originalLockInfo.OrderQuantity += splitRecord.SplitQty;
+ await _outStockLockInfoService.Db.Updateable(originalLockInfo).ExecuteCommandAsync();
+
+ // 鍒犻櫎鏂板簱瀛樻槑缁�
+ await _stockInfoDetailService.Db.Deleteable<Dt_StockInfoDetail>()
+ .Where(x => x.Barcode == newLockInfo.CurrentBarcode)
+ .ExecuteCommandAsync();
+
+ // 鍒犻櫎鏂伴攣瀹氫俊鎭�
+ await _outStockLockInfoService.Db.Deleteable<Dt_OutStockLockInfo>()
+ .Where(x => x.Id == newLockInfo.Id)
+ .ExecuteCommandAsync();
+
+ // 鏍囪鎷嗗寘璁板綍涓哄凡鎾ら攢
+ splitRecord.IsReverted = true;
+ splitRecord.RevertTime = DateTime.Now;
+ splitRecord.RevertOperator = App.User.UserName;
+ await _splitPackageService.Db.Updateable(splitRecord).ExecuteCommandAsync();
+ }
+
+ #endregion
+
+ #region 鏁版嵁鏇存柊鏂规硶
+
+ private async Task UpdateBatchAndOrderData(Dt_OutboundBatch batch, Dt_OutboundOrderDetail orderDetail, decimal pickedQty, string orderNo)
+ {
+ // 鏇存柊鎵规瀹屾垚鏁伴噺
+ batch.CompletedQuantity += pickedQty;
+ if (batch.CompletedQuantity >= batch.BatchQuantity)
+ {
+ batch.BatchStatus = (int)BatchStatusEnum.宸插畬鎴�;
+ }
+ 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)
+ {
+ // 鎭㈠搴撳瓨鐘舵��
+ 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.宸插洖搴�;
+ await _outStockLockInfoService.Db.Updateable(lockInfo).ExecuteCommandAsync();
+ }
+
+ private async Task UpdateBatchStatusForReturn(string batchNo, List<Dt_OutStockLockInfo> returnedLocks)
+ {
+ 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)
+ {
+ var orderDetailGroups = returnedLocks.GroupBy(x => x.OrderDetailId);
+
+ foreach (var group in orderDetailGroups)
+ {
+ 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();
+ }
+ }
+
+ #endregion
+
+ #region 杈呭姪鏂规硶
+
+ private async Task<string> GenerateNewBarcode()
+ {
+ var seq = await _dailySequenceService.GetNextSequenceAsync();
+ 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)
+ {
+ var splitHistory = new Dt_SplitPackageRecord
+ {
+ OrderNo = lockInfo.OrderNo,
+ OutStockLockInfoId = lockInfo.Id,
+ StockId = stockDetail.StockId,
+ Operator = App.User.UserName,
+ OriginalBarcode = stockDetail.Barcode,
+ NewBarcode = newBarcode,
+ SplitQty = splitQty,
+ SplitTime = DateTime.Now,
+ Status = (int)SplitPackageStatusEnum.宸叉媶鍖�
+ };
+
+ await _splitPackageService.Db.Insertable(splitHistory).ExecuteCommandAsync();
+ }
+
+ private async Task RecordPickingHistory(PickingResult result, string orderNo, string palletCode)
+ {
+ var pickingRecord = new Dt_PickingRecord
+ {
+ OrderNo = orderNo,
+ // BatchNo = result.FinalLockInfo.BatchNo,
+ OrderDetailId = result.FinalLockInfo.OrderDetailId,
+ PalletCode = palletCode,
+ Barcode = result.FinalLockInfo.CurrentBarcode,
+ MaterielCode = result.FinalLockInfo.MaterielCode,
+ PickQuantity = result.ActualPickedQty,
+ PickTime = DateTime.Now,
+ Operator = App.User.UserName,
+ OutStockLockId = result.FinalLockInfo.Id,
+ // IsCancelled = false
+ };
+
+ await Db.Insertable(pickingRecord).ExecuteCommandAsync();
+ }
+
+ private async Task CheckAndUpdateOrderStatus(string orderNo)
+ {
+ var orderDetails = await _outboundOrderDetailService.Db.Queryable<Dt_OutboundOrderDetail>()
+ .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);
+
+ 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
+ {
+ public string NewBarcode { get; set; }
+ }
+}
--
Gitblit v1.9.3