ZhongRui/ALDbanyunxiangmu.git

			@@ -8,7 +8,9 @@
			using System.Collections.Generic;
			using System.Linq;
			using System.Text;
			using System.Text.Json;
			using System.Threading.Tasks;
			using WIDESEA_Common.CommonEnum;
			using WIDESEA_Common.LocationEnum;
			using WIDESEA_Common.OrderEnum;
			using WIDESEA_Common.StockEnum;
			@@ -16,10 +18,13 @@
			using WIDESEA_Core;
			using WIDESEA_Core.BaseRepository;
			using WIDESEA_Core.BaseServices;
			using WIDESEA_Core.Enums;
			using WIDESEA_Core.Helper;
			using WIDESEA_DTO.Allocate;
			using WIDESEA_DTO.Basic;
			using WIDESEA_DTO.Inbound;
			using WIDESEA_DTO.Outbound;
			using WIDESEA_IAllocateService;
			using WIDESEA_IBasicService;
			using WIDESEA_IOutboundService;
			using WIDESEA_IStockService;
			@@ -47,6 +52,7 @@
			private readonly IESSApiService _eSSApiService;
			private readonly IInvokeMESService _invokeMESService;
			private readonly IDailySequenceService _dailySequenceService;
			private readonly IAllocateService _allocateService;

			private readonly ILogger<OutboundPickingService> _logger;

			@@ -67,7 +73,7 @@
			public OutboundPickingService(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) : base(BaseDal)
			IRepository<Dt_Task> taskRepository, IESSApiService eSSApiService, ILogger<OutboundPickingService> logger, IInvokeMESService invokeMESService, IDailySequenceService dailySequenceService, IAllocateService allocateService) : base(BaseDal)
			{
			_unitOfWorkManage = unitOfWorkManage;
			_stockInfoService = stockInfoService;
			@@ -83,8 +89,11 @@
			_logger = logger;
			_invokeMESService = invokeMESService;
			_dailySequenceService = dailySequenceService;
			_allocateService = allocateService;
			}


			#region æ¥è¯¢æ¹æ³
			// è·åæªæ£éåè¡¨
			public async Task<List<Dt_OutStockLockInfo>> GetUnpickedList(string orderNo, string palletCode)
			{
			@@ -147,35 +156,48 @@
			return summary;
			}

			#region æ ¸å¿ä¸å¡æµç¨
			#endregion

			#region æ ¸å¿ä¸å¡æµç¨
			/// <summary>
			/// æ£é
			/// </summary>
			/// <param name="orderNo"></param>
			/// <param name="palletCode"></param>
			/// <param name="barcode"></param>
			/// <returns></returns>
			public async Task<WebResponseContent> ConfirmPicking(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) = validationResult.Data;

			// 2. è®¡ç®å®éæ£éæ°é
			// è®¡ç®å®éæ£éæ°é
			var quantityResult = await CalculateActualPickingQuantity(lockInfo, orderDetail, stockDetail);
			if (!quantityResult.IsValid)
			return WebResponseContent.Instance.Error(quantityResult.ErrorMessage);

			var (actualQty, adjustedReason) = quantityResult.Data;

			// 3. æ§è¡åæ£é»è¾
			var overPickingValidation = await ValidateOverPicking(orderDetail.Id, actualQty);
			if (!overPickingValidation.IsValid)
			{
			return WebResponseContent.Instance.Error(overPickingValidation.ErrorMessage);
			}

			// æ§è¡åæ£é»è¾ï¼åªå¤çåºååéå®ï¼ä¸å¤çè®¢åï¼
			var pickingResult = await ExecutePickingLogic(lockInfo, orderDetail, stockDetail, orderNo, palletCode, barcode, actualQty);

			// 4. æ´æ°ç¸å³æ°æ®
			// ç»ä¸æ´æ°è®¢åæ°æ®ï¼ææåæ¯é½å¨è¿éæ´æ°ï¼
			await UpdateOrderRelatedData(orderDetail.Id, pickingResult.ActualPickedQty, orderNo);

			// 5. è®°å½æä½åå²
			// è®°å½æä½åå²
			await RecordPickingHistory(pickingResult, orderNo, palletCode);

			_unitOfWorkManage.CommitTran();
			@@ -190,10 +212,21 @@
			}
			}

			/// <summary>
			/// åæ¶æ£é
			/// </summary>
			/// <param name="orderNo"></param>
			/// <param name="palletCode"></param>
			/// <param name="barcode"></param>
			/// <returns></returns>
			public async Task<WebResponseContent> CancelPicking(string orderNo, string palletCode, string barcode)
			{
			try
			{
			if (await IsPalletReturned(palletCode))
			{
			return WebResponseContent.Instance.Error($"æç{palletCode}å·²ç»ååºï¼ä¸è½åæ¶åæ£");
			}
			_unitOfWorkManage.BeginTran();

			// 1. åç½®éªè¯
			@@ -208,7 +241,7 @@

			_unitOfWorkManage.CommitTran();

			return WebResponseContent.Instance.OK($"åæ¶åæ£æåï¼æ¢å¤æ°éï¼{pickingRecord.PickQuantity}");
			return WebResponseContent.Instance.OK($"åæ¶åæ£æå");
			}
			catch (Exception ex)
			{
			@@ -217,20 +250,25 @@
			return WebResponseContent.Instance.Error($"åæ¶åæ£å¤±è´¥ï¼{ex.Message}");
			}
			}

			/// <summary>
			/// ååº
			/// </summary>
			/// <param name="orderNo"></param>
			/// <param name="palletCode"></param>
			/// <param name="reason"></param>
			/// <returns></returns>
			public async Task<WebResponseContent> ReturnRemaining(string orderNo, string palletCode, string reason)
			{
			try
			{
			_unitOfWorkManage.BeginTran();

			// 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);
			// è·ååºååä»»å¡ä¿¡æ¯
			var stockInfo = await _stockInfoService.Db.Queryable<Dt_StockInfo>().FirstAsync(x => x.PalletCode == palletCode);

			if (stockInfo == null)
			return WebResponseContent.Instance.Error($"æªæ¾å°æç {palletCode} å¯¹åºçåºåä¿¡æ¯");
			@@ -239,23 +277,35 @@
			if (task == null)
			return WebResponseContent.Instance.Error("æªæ¾å°å¯¹åºçä»»å¡ä¿¡æ¯");

			// 3. åæéè¦ååºçè´§ç©
			var returnAnalysis = await AnalyzeReturnItems(orderNo, palletCode, stockInfo.Id);
			if (!returnAnalysis.HasItemsToReturn)
			return await HandleNoReturnItems(orderNo, palletCode);
			//åæéè¦ååºçè´§ç©
			//var returnAnalysis = await AnalyzeReturnItems(orderNo, palletCode, stockInfo.Id);
			//if (!returnAnalysis.HasItemsToReturn)
			// return await HandleNoReturnItems(orderNo, palletCode, task);

			// 4. æ§è¡ååºæä½
			await ExecuteReturnOperations(orderNo, palletCode, stockInfo, task, returnAnalysis);
			var statusAnalysis = await AnalyzePalletStatus(orderNo, palletCode, stockInfo.Id);
			if (!statusAnalysis.HasItemsToReturn)
			return await HandleNoReturnItems(orderNo, palletCode, task, stockInfo.Id);

			// 5. åå»ºååºä»»å¡
			await CreateReturnTaskAndHandleESS(orderNo, palletCode, task, returnAnalysis);
			// 4. æ£æ¥æ¯å¦æè¿è¡ä¸çä»»å¡
			if (statusAnalysis.HasActiveTasks)
			{
			return WebResponseContent.Instance.Error($"æç {palletCode} æè¿è¡ä¸çä»»å¡ï¼ä¸è½æ§è¡ååºæä½");
			}

			//æ§è¡ååºæä½
			await ExecuteReturnOperations(orderNo, palletCode, stockInfo, task, statusAnalysis);

			_unitOfWorkManage.CommitTran();

			// 6. æ´æ°è®¢åç¶æï¼ä¸è§¦åMESåä¼ ï¼

			// åå»ºååºä»»å¡
			await CreateReturnTaskAndHandleESS(orderNo, palletCode, task, TaskTypeEnum.InPick, task.PalletType);

			// æ´æ°è®¢åç¶æï¼ä¸è§¦åMESåä¼ ï¼
			await UpdateOrderStatusForReturn(orderNo);

			return WebResponseContent.Instance.OK($"ååºæä½æåï¼å±ååºæ°éï¼{returnAnalysis.TotalReturnQty}");
			return WebResponseContent.Instance.OK($"ååºæä½æå");
			//return WebResponseContent.Instance.OK($"ååºæä½æåï¼å±ååºæ°éï¼{statusAnalysis.TotalReturnQty}");
			}
			catch (Exception ex)
			{
			@@ -265,6 +315,71 @@
			}
			}

			/// <summary>
			/// ç©ºæçåèµ°æ¥å£ï¼å¸¦è®¢åå·ï¼
			/// éªè¯æçæ¯å¦ççä¸ºç©ºï¼æ¸çæ°æ®ï¼æ´æ°è®¢åç¶æï¼åå»ºåæçä»»å¡
			/// </summary>
			public async Task<WebResponseContent> RemoveEmptyPallet(string orderNo, string palletCode)
			{
			try
			{
			_unitOfWorkManage.BeginTran();

			if (string.IsNullOrEmpty(orderNo) \|\| string.IsNullOrEmpty(palletCode))
			return WebResponseContent.Instance.Error("è®¢åå·åæçç ä¸è½ä¸ºç©º");

			// æ£æ¥è®¢åæ¯å¦åå¨
			var order = await _outboundOrderService.Db.Queryable<Dt_OutboundOrder>()
			.Where(x => x.OrderNo == orderNo)
			.FirstAsync();

			if (order == null)
			return WebResponseContent.Instance.Error($"æªæ¾å°è®¢å {orderNo}");

			//æ£æ¥æçæ¯å¦åå¨ä¸å±äºè¯¥è®¢å
			var stockInfo = await _stockInfoService.Db.Queryable<Dt_StockInfo>()
			.Where(x => x.PalletCode == palletCode)
			.FirstAsync();

			if (stockInfo == null)
			return WebResponseContent.Instance.Error($"æªæ¾å°æç {palletCode} å¯¹åºçåºåä¿¡æ¯");

			var statusAnalysis = await AnalyzePalletStatus(orderNo, palletCode, stockInfo.Id);

			if (!statusAnalysis.CanRemove)
			{
			if (!statusAnalysis.IsEmptyPallet)
			{
			return WebResponseContent.Instance.Error($"æç {palletCode} ä¸è¿æè´§ç©ï¼ä¸è½åèµ°");
			}
			if (statusAnalysis.HasActiveTasks)
			{
			return WebResponseContent.Instance.Error($"æç {palletCode} è¿æè¿è¡ä¸çä»»å¡ï¼ä¸è½åèµ°");
			}
			}
			// æ¸çé¶åºåæ°æ®
			await CleanupZeroStockData(stockInfo.Id);

			// å é¤æåæ¶ç¸å³ä»»å¡
			await HandleTaskCleanup(orderNo, palletCode);

			// æ´æ°è®¢åç¸å³æ°æ®
			await UpdateOrderData(orderNo, palletCode);


			_unitOfWorkManage.CommitTran();

			_logger.LogInformation($"ç©ºæçåèµ°æä½æå - è®¢å: {orderNo}, æç: {palletCode}, æä½äºº: {App.User.UserName}");

			return WebResponseContent.Instance.OK("ç©ºæçåèµ°æä½æå");
			}
			catch (Exception ex)
			{
			_unitOfWorkManage.RollbackTran();
			_logger.LogError($"RemoveEmptyPalletå¤±è´¥ - OrderNo: {orderNo}, PalletCode: {palletCode}, Error: {ex.Message}");
			return WebResponseContent.Instance.Error($"ç©ºæçåèµ°å¤±è´¥: {ex.Message}");
			}
			}
			#endregion

			#region åæ£ç¡®è®¤ç§ææ¹æ³
			@@ -301,7 +416,8 @@

			// 6. è·ååºåæç»
			var stockDetail = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
			.Where(x => x.Barcode == barcode && x.StockId == lockInfo.StockId)
			.Where(x => x.Barcode == barcode && x.StockId == lockInfo.StockId &&
			x.Status != StockStatusEmun.å¥åºç¡®è®¤.ObjToInt())
			.FirstAsync();

			if (stockDetail == null)
			@@ -333,18 +449,13 @@
			it.Status == (int)OutLockStockStatusEnum.åºåºä¸ &&
			it.PalletCode == palletCode &&
			it.CurrentBarcode == barcode &&
			it.AssignQuantity > it.PickedQty)
			.FirstAsync();
			it.AssignQuantity > it.PickedQty).FirstAsync();

			if (lockInfo == null)
			{
			// æ¥æ¾åä¸è®¢åä¸çè®°å½
			lockInfo = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
			.Where(it => it.OrderNo == orderNo &&
			it.CurrentBarcode == barcode &&
			it.Status == (int)OutLockStockStatusEnum.åºåºä¸ &&
			it.AssignQuantity > it.PickedQty)
			.FirstAsync();
			.Where(it => it.OrderNo == orderNo && it.CurrentBarcode == barcode && it.Status == (int)OutLockStockStatusEnum.åºåºä¸ && it.AssignQuantity > it.PickedQty).FirstAsync();

			if (lockInfo == null)
			{
			@@ -352,8 +463,7 @@
			var completedLockInfo = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
			.Where(it => it.CurrentBarcode == barcode &&
			(it.Status == (int)OutLockStockStatusEnum.æ£éå®æ \|\|
			it.PickedQty >= it.AssignQuantity))
			.FirstAsync();
			it.PickedQty >= it.AssignQuantity)).FirstAsync();

			if (completedLockInfo != null)
			throw new Exception($"æ¡ç {barcode}å·²ç»å®æåæ£ï¼ä¸è½éå¤åæ£");
			@@ -372,18 +482,29 @@
			decimal remainingOrderQty = orderDetail.NeedOutQuantity - orderDetail.OverOutQuantity;
			decimal stockQuantity = stockDetail.StockQuantity;

			if (plannedQty <= 0)
			{
			return ValidationResult<(decimal, string)>.Error($"è®¡åæ£éæ°éå¿é¡»å¤§äº0ï¼å½å: {plannedQty}");
			}

			if (remainingOrderQty <= 0)
			{
			return ValidationResult<(decimal, string)>.Error($"è®¢åå©ä½éæ±æ°éå¿é¡»å¤§äº0ï¼å½å: {remainingOrderQty}");
			}

			if (stockQuantity <= 0)
			{
			return ValidationResult<(decimal, string)>.Error($"åºåæ°éå¿é¡»å¤§äº0ï¼å½å: {stockQuantity}");
			}
			// ä¸éæ£æ¥ï¼åæå°å¼
			decimal actualQty = plannedQty;
			string adjustedReason = null;

			// æ£æ¥1ï¼è®¢åæ°ééå¶
			if (plannedQty > remainingOrderQty && remainingOrderQty > 0)
			if (plannedQty > remainingOrderQty)
			{
			actualQty = remainingOrderQty;
			adjustedReason = $"è®¢åæ°ééå¶ï¼ä»{plannedQty}è°æ´ä¸º{actualQty}";
			}

			// æ£æ¥2ï¼åºåæ°ééå¶
			if (actualQty > stockQuantity)
			{
			actualQty = stockQuantity;
			@@ -391,11 +512,18 @@
			? $"{adjustedReason}ï¼åºåæ°ééå¶ï¼è¿ä¸æ¥è°æ´ä¸º{actualQty}"
			: $"åºåæ°ééå¶ï¼ä»{plannedQty}è°æ´ä¸º{actualQty}";
			}

			// æ£æ¥3ï¼å®éå¯æ£éæ°éå¿é¡»å¤§äº0
			if (actualQty <= 0)
			{
			return ValidationResult<(decimal, string)>.Error($"æ æ³åæ£ï¼è®¡åæ°é{plannedQty}ï¼å©ä½è®¢å{remainingOrderQty}ï¼åºå{stockQuantity}");
			return ValidationResult<(decimal, string)>.Error($"æ æ³åæ£ï¼è®¡ç®åçå®éæ°éä¸º{actualQty}");
			}
			decimal projectedOverOut = orderDetail.OverOutQuantity + actualQty;
			if (projectedOverOut > orderDetail.NeedOutQuantity)
			{
			// å¦æä¼è¶æ£ï¼è°æ´ä¸ºåå¥½æ»¡è¶³éæ±çæ°é
			actualQty = orderDetail.NeedOutQuantity - orderDetail.OverOutQuantity;
			adjustedReason = adjustedReason != null
			? $"{adjustedReason}ï¼é²è¶æ£éå¶ï¼æç»è°æ´ä¸º{actualQty}"
			: $"é²è¶æ£éå¶ï¼ä»{plannedQty}è°æ´ä¸º{actualQty}";
			}

			if (adjustedReason != null)
			@@ -406,9 +534,32 @@
			return ValidationResult<(decimal, string)>.Success((actualQty, adjustedReason));
			}

			/// <summary>
			/// ä¸é¨éªè¯æ¯å¦ä¼åçè¶æ£
			/// </summary>
			private async Task<ValidationResult<bool>> ValidateOverPicking(int orderDetailId, decimal pickingQty)
			{
			var orderDetail = await _outboundOrderDetailService.Db.Queryable<Dt_OutboundOrderDetail>()
			.FirstAsync(x => x.Id == orderDetailId);

			if (orderDetail == null)
			return ValidationResult<bool>.Error("æªæ¾å°è®¢åæç»");

			decimal projectedOverOut = orderDetail.OverOutQuantity + pickingQty;

			if (projectedOverOut > orderDetail.NeedOutQuantity)
			{
			return ValidationResult<bool>.Error(
			$"åæ£åå°å¯¼è´è¶æ£ï¼å½åå·²åºåº{orderDetail.OverOutQuantity}ï¼æ¬æ¬¡åæ£{pickingQty}ï¼åè®¡{projectedOverOut}ï¼è¶è¿éæ±{orderDetail.NeedOutQuantity}");
			}

			return ValidationResult<bool>.Success(true);
			}


			private async Task<PickingResult> ExecutePickingLogic(
			Dt_OutStockLockInfo lockInfo, Dt_OutboundOrderDetail orderDetail, Dt_StockInfoDetail stockDetail,
			string orderNo, string palletCode, string barcode, decimal actualQty)
			Dt_OutStockLockInfo lockInfo, Dt_OutboundOrderDetail orderDetail, Dt_StockInfoDetail stockDetail,
			string orderNo, string palletCode, string barcode, decimal actualQty)
			{
			decimal stockQuantity = stockDetail.StockQuantity;
			var result = new PickingResult
			@@ -422,49 +573,58 @@
			if (actualQty < stockQuantity)
			{
			await HandleSplitPacking(lockInfo, stockDetail, actualQty, stockQuantity, result);
			// æååºæ¯è¿åå®éæ£éæ°é
			result.ActualPickedQty = actualQty;
			}
			else if (actualQty == stockQuantity)
			{
			await HandleFullPicking(lockInfo, stockDetail, actualQty, result);
			// æ´åæ£éè¿åå®éæ£éæ°é
			result.ActualPickedQty = actualQty;
			}
			else
			{
			await HandlePartialPicking(lockInfo, stockDetail, actualQty, stockQuantity, result);
			// é¨åæ£éè¿åè°æ´åçæ°é
			result.ActualPickedQty = result.ActualPickedQty; // å·²ç»å¨æ¹æ³åè°æ´
			}

			return result;
			}

			private async Task HandleSplitPacking(Dt_OutStockLockInfo lockInfo, Dt_StockInfoDetail stockDetail,
			decimal actualQty, decimal stockQuantity, PickingResult result)
			decimal actualQty, decimal stockQuantity, PickingResult result)
			{
			decimal remainingStockQty = stockQuantity - actualQty;

			// 1. æ´æ°åæ¡ç åºå
			// æ´æ°åæ¡ç åºå
			stockDetail.StockQuantity = remainingStockQty;
			stockDetail.OutboundQuantity = remainingStockQty;
			await _stockInfoDetailService.Db.Updateable(stockDetail).ExecuteCommandAsync();

			// 2. çææ°æ¡ç
			// çææ°æ¡ç
			string newBarcode = await GenerateNewBarcode();

			// 3. åå»ºæ°éå®ä¿¡æ¯
			// åå»ºæ°éå®ä¿¡æ¯
			var newLockInfo = await CreateSplitLockInfo(lockInfo, actualQty, newBarcode);

			// 4. è®°å½æååå²
			// è®°å½æååå²
			await RecordSplitHistory(lockInfo, stockDetail, actualQty, remainingStockQty, newBarcode);

			// 5. æ´æ°åéå®ä¿¡æ¯
			// æ´æ°åéå®ä¿¡æ¯
			lockInfo.AssignQuantity = remainingStockQty;
			lockInfo.PickedQty = 0;
			lockInfo.Operator = App.User.UserName;
			await _outStockLockInfoService.Db.Updateable(lockInfo).ExecuteCommandAsync();

			// 6. è®¾ç½®ç»æ
			// è®¾ç½®ç»æ
			result.FinalLockInfo = newLockInfo;
			result.FinalBarcode = newBarcode;
			result.SplitResults.AddRange(CreateSplitResults(lockInfo, actualQty, remainingStockQty, newBarcode, stockDetail.Barcode));
			}



			_logger.LogInformation($"æååæ£å®æ - OrderDetailId: {lockInfo.OrderDetailId}, åæ£æ°é: {actualQty}");
			}
			private async Task HandleFullPicking(Dt_OutStockLockInfo lockInfo, Dt_StockInfoDetail stockDetail,
			decimal actualQty, PickingResult result)
			{
			@@ -477,6 +637,7 @@
			// 2. æ´æ°éå®ä¿¡æ¯
			lockInfo.PickedQty += actualQty;
			lockInfo.Status = (int)OutLockStockStatusEnum.æ£éå®æ;
			lockInfo.Operator = App.User.UserName;
			await _outStockLockInfoService.Db.Updateable(lockInfo).ExecuteCommandAsync();
			}

			@@ -495,6 +656,7 @@
			// 2. æ´æ°éå®ä¿¡æ¯
			lockInfo.PickedQty += stockOutQty;
			lockInfo.AssignQuantity = remainingAssignQty;
			lockInfo.Operator = App.User.UserName;
			await _outStockLockInfoService.Db.Updateable(lockInfo).ExecuteCommandAsync();

			// 3. æ´æ°æåè®°å½ç¶æ
			@@ -512,10 +674,24 @@
			decimal newOverOutQuantity = currentOrderDetail.OverOutQuantity + pickedQty;
			decimal newPickedQty = currentOrderDetail.PickedQty + pickedQty;

			// æç»æ£æ¥ï¼ç¡®ä¿ä¸ä¼è¶è¿è®¢åéæ±æ°é
			if (newOverOutQuantity > currentOrderDetail.NeedOutQuantity)
			{
			throw new Exception($"åæ£åå°å¯¼è´å·²åºåºæ°é({newOverOutQuantity})è¶è¿è®¢åéæ±æ°é({currentOrderDetail.NeedOutQuantity})");

			_logger.LogError($"é²è¶æ£æ£æ¥å¤±è´¥ - OrderDetailId: {orderDetailId}, å·²åºåº: {newOverOutQuantity}, éæ±: {currentOrderDetail.NeedOutQuantity}, æ¬æ¬¡åæ£: {pickedQty}");


			decimal adjustedQty = currentOrderDetail.NeedOutQuantity - currentOrderDetail.OverOutQuantity;

			if (adjustedQty > 0)
			{
			_logger.LogWarning($"èªå¨è°æ´åæ£æ°éé²æ¢è¶æ£ï¼ä»{pickedQty}è°æ´ä¸º{adjustedQty}");
			newOverOutQuantity = currentOrderDetail.NeedOutQuantity;
			newPickedQty = currentOrderDetail.PickedQty + adjustedQty;
			}
			else
			{
			throw new Exception($"åæ£åå°å¯¼è´å·²åºåºæ°é({newOverOutQuantity})è¶è¿è®¢åéæ±æ°é({currentOrderDetail.NeedOutQuantity})ï¼ä¸æ æ³èªå¨è°æ´");
			}
			}

			// æ´æ°è®¢åæç»
			@@ -566,7 +742,73 @@
			#endregion

			#region åæ¶åæ£ç§ææ¹æ³
			private async Task<ValidationResult<bool>> ValidateDataConsistencyBeforeCancel(CancelPickingContext context)
			{
			try
			{
			// 1. éªè¯è®¢åæç»æ°æ®
			var currentOrderDetail = await _outboundOrderDetailService.Db.Queryable<Dt_OutboundOrderDetail>()
			.FirstAsync(x => x.Id == context.OrderDetail.Id);

			if (currentOrderDetail.OverOutQuantity < context.PickingRecord.PickQuantity)
			return ValidationResult<bool>.Error($"è®¢åæç»å·²åºåºæ°é({currentOrderDetail.OverOutQuantity})å°äºåæ¶æ°é({context.PickingRecord.PickQuantity})");

			if (currentOrderDetail.PickedQty < context.PickingRecord.PickQuantity)
			return ValidationResult<bool>.Error($"è®¢åæç»å·²æ£éæ°é({currentOrderDetail.PickedQty})å°äºåæ¶æ°é({context.PickingRecord.PickQuantity})");

			// 2. éªè¯éå®ä¿¡æ¯æ°æ®
			var currentLockInfo = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
			.FirstAsync(x => x.Id == context.LockInfo.Id);

			if (currentLockInfo.PickedQty < context.PickingRecord.PickQuantity)
			return ValidationResult<bool>.Error($"éå®ä¿¡æ¯å·²æ£éæ°é({currentLockInfo.PickedQty})å°äºåæ¶æ°é({context.PickingRecord.PickQuantity})");

			// 3. éªè¯åºåæ°æ®
			var currentStockDetail = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
			.FirstAsync(x => x.Barcode == context.PickingRecord.Barcode && x.StockId == context.PickingRecord.StockId);

			if (currentStockDetail == null)
			return ValidationResult<bool>.Error($"æªæ¾å°å¯¹åºçåºåæç»è®°å½");

			if (currentStockDetail.Status == StockStatusEmun.å¥åºç¡®è®¤.ObjToInt() \|\|
			currentStockDetail.Status == StockStatusEmun.å¥åºå®æ.ObjToInt())
			return ValidationResult<bool>.Error($"æ¡ç {context.PickingRecord.Barcode}å·²ç»ååºï¼æ æ³åæ¶åæ£");

			// 4. éªè¯ç¶ææµè½¬çåæ³æ§
			if (!await CanCancelPicking(currentLockInfo, currentStockDetail))
			return ValidationResult<bool>.Error($"å½åç¶æä¸åè®¸åæ¶åæ£");

			return ValidationResult<bool>.Success(true);
			}
			catch (Exception ex)
			{
			_logger.LogError($"åæ¶åæ£æ°æ®ä¸è´æ§éªè¯å¤±è´¥: {ex.Message}");
			return ValidationResult<bool>.Error($"æ°æ®éªè¯å¤±è´¥: {ex.Message}");
			}
			}

			private async Task<bool> CanCancelPicking(Dt_OutStockLockInfo lockInfo, Dt_StockInfoDetail stockDetail)
			{
			// éå®ä¿¡æ¯ç¶ææ£æ¥
			if (lockInfo.Status != (int)OutLockStockStatusEnum.æ£éå®æ)
			return false;

			// åºåç¶ææ£æ¥
			if (stockDetail.Status == StockStatusEmun.åºåºå®æ.ObjToInt())
			return false;

			// å¦ææ¯æåè®°å½ï¼è¿éè¦æ£æ¥ç¶éå®ä¿¡æ¯ç¶æ
			if (lockInfo.IsSplitted == 1 && lockInfo.ParentLockId.HasValue)
			{
			var parentLock = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
			.FirstAsync(x => x.Id == lockInfo.ParentLockId.Value);

			if (parentLock == null \|\| parentLock.Status == (int)OutLockStockStatusEnum.ååºä¸)
			return false;
			}

			return true;
			}
			private async Task<ValidationResult<(Dt_PickingRecord, Dt_OutStockLockInfo, Dt_OutboundOrderDetail)>> ValidateCancelRequest(string orderNo, string palletCode, string barcode)
			{
			// åºç¡åæ°éªè¯
			@@ -584,6 +826,10 @@
			if (pickingRecord == null)
			return ValidationResult<(Dt_PickingRecord, Dt_OutStockLockInfo, Dt_OutboundOrderDetail)>.Error("æªæ¾å°å¯¹åºçæ£éè®°å½");

			if (pickingRecord.PickQuantity <= 0)
			{
			return ValidationResult<(Dt_PickingRecord, Dt_OutStockLockInfo, Dt_OutboundOrderDetail)>.Error($"æ£éè®°å½æ°éæ æ: {pickingRecord.PickQuantity}");
			}
			// æ¥æ¾éå®ä¿¡æ¯
			var lockInfo = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
			.Where(it => it.Id == pickingRecord.OutStockLockId)
			@@ -592,41 +838,101 @@
			if (lockInfo == null)
			return ValidationResult<(Dt_PickingRecord, Dt_OutStockLockInfo, Dt_OutboundOrderDetail)>.Error("æªæ¾å°å¯¹åºçåºåºéå®ä¿¡æ¯");

			if (lockInfo.PickedQty < pickingRecord.PickQuantity)
			{
			return ValidationResult<(Dt_PickingRecord, Dt_OutStockLockInfo, Dt_OutboundOrderDetail)>.Error(
			$"åæ¶æ°é({pickingRecord.PickQuantity})è¶è¿éå®ä¿¡æ¯çå·²æ£éæ°é({lockInfo.PickedQty})");
			}
			// æ£æ¥ç¶ææ¯å¦åè®¸åæ¶
			if (lockInfo.Status != (int)OutLockStockStatusEnum.æ£éå®æ)
			return ValidationResult<(Dt_PickingRecord, Dt_OutStockLockInfo, Dt_OutboundOrderDetail)>.Error("å½åç¶æä¸åè®¸åæ¶åæ£");

			// æ£æ¥è®¢åç¶æ
			var order = await _outboundOrderService.Db.Queryable<Dt_OutboundOrder>()
			.Where(x => x.OrderNo == orderNo)
			.FirstAsync();
			var order = await _outboundOrderService.Db.Queryable<Dt_OutboundOrder>().FirstAsync(x => x.OrderNo == orderNo);

			if (order?.OrderStatus == (int)OutOrderStatusEnum.åºåºå®æ)
			return ValidationResult<(Dt_PickingRecord, Dt_OutStockLockInfo, Dt_OutboundOrderDetail)>.Error("è®¢åå·²åºåºå®æï¼ä¸åè®¸åæ¶åæ£");

			// è·åè®¢åæç»
			var orderDetail = await _outboundOrderDetailService.Db.Queryable<Dt_OutboundOrderDetail>()
			.FirstAsync(x => x.Id == pickingRecord.OrderDetailId);
			var orderDetail = await _outboundOrderDetailService.Db.Queryable<Dt_OutboundOrderDetail>().FirstAsync(x => x.Id == pickingRecord.OrderDetailId);

			if (orderDetail == null)
			return ValidationResult<(Dt_PickingRecord, Dt_OutStockLockInfo, Dt_OutboundOrderDetail)>.Error($"æªæ¾å°è®¢åæç»ï¼ID: {pickingRecord.OrderDetailId}");

			// æ£æ¥è®¢åæç»çå·²æ£éæ°éæ¯å¦è¶³å¤åæ¶
			if (orderDetail.PickedQty < pickingRecord.PickQuantity)
			{
			return ValidationResult<(Dt_PickingRecord, Dt_OutStockLockInfo, Dt_OutboundOrderDetail)>.Error($"åæ¶æ°é({pickingRecord.PickQuantity})è¶è¿è®¢åæç»çå·²æ£éæ°é({orderDetail.PickedQty})");
			}

			// æ£æ¥è®¢åæç»çå·²åºåºæ°éæ¯å¦è¶³å¤åæ¶
			if (orderDetail.OverOutQuantity < pickingRecord.PickQuantity)
			{
			return ValidationResult<(Dt_PickingRecord, Dt_OutStockLockInfo, Dt_OutboundOrderDetail)>.Error($"åæ¶æ°é({pickingRecord.PickQuantity})è¶è¿è®¢åæç»çå·²åºåºæ°é({orderDetail.OverOutQuantity})");
			}

			var stockDetail = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>().FirstAsync(it => it.Barcode == barcode && it.StockId == pickingRecord.StockId);

			if (stockDetail != null)
			{
			// æ£æ¥åºåç¶æ - å¦æç¶ææ¯å¥åºç¡®è®¤æå¥åºå®æï¼è¯´æå·²ç»ååº
			if (stockDetail.Status == StockStatusEmun.å¥åºç¡®è®¤.ObjToInt() \|\|
			stockDetail.Status == StockStatusEmun.å¥åºå®æ.ObjToInt())
			{
			return ValidationResult<(Dt_PickingRecord, Dt_OutStockLockInfo, Dt_OutboundOrderDetail)>.Error($"æ¡ç {barcode}å·²ç»ååºï¼ä¸è½åæ¶åæ£");
			}
			}

			return ValidationResult<(Dt_PickingRecord, Dt_OutStockLockInfo, Dt_OutboundOrderDetail)>.Success((pickingRecord, lockInfo, orderDetail));
			}
			/// <summary>
			/// æ£æ¥æ¡ç æ¯å¦å·²ç»ååº
			/// </summary>
			private async Task<bool> IsBarcodeReturned(string barcode, int stockId)
			{
			var stockDetail = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
			.Where(it => it.Barcode == barcode && it.StockId == stockId)
			.FirstAsync();

			if (stockDetail == null)
			return false;

			// å¦æç¶ææ¯å¥åºç¡®è®¤æå¥åºå®æï¼è¯´æå·²ç»ååº
			return stockDetail.Status == StockStatusEmun.å¥åºç¡®è®¤.ObjToInt() \|\|
			stockDetail.Status == StockStatusEmun.å¥åºå®æ.ObjToInt();
			}

			/// <summary>
			/// æ£æ¥éå®ä¿¡æ¯å¯¹åºçæ¡ç æ¯å¦å·²ç»ååº
			/// </summary>
			private async Task<bool> IsLockInfoReturned(Dt_OutStockLockInfo lockInfo)
			{
			var stockDetail = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
			.Where(it => it.Barcode == lockInfo.CurrentBarcode && it.StockId == lockInfo.StockId)
			.FirstAsync();

			if (stockDetail == null)
			return false;

			return stockDetail.Status == StockStatusEmun.å¥åºç¡®è®¤.ObjToInt() \|\|
			stockDetail.Status == StockStatusEmun.å¥åºå®æ.ObjToInt();
			}
			private async Task ExecuteCancelLogic(Dt_OutStockLockInfo lockInfo, Dt_PickingRecord pickingRecord,
			Dt_OutboundOrderDetail orderDetail, string orderNo)
			Dt_OutboundOrderDetail orderDetail, string orderNo)
			{
			decimal cancelQty = pickingRecord.PickQuantity;

			// 1. æ£æ¥åæ¶åæ°éä¸ä¼ä¸ºè´æ°
			decimal newOverOutQuantity = orderDetail.OverOutQuantity - cancelQty;
			decimal newPickedQty = orderDetail.PickedQty - cancelQty;

			if (newOverOutQuantity < 0 \|\| newPickedQty < 0)
			// 1. æ°æ®ä¸è´æ§éªè¯
			var context = new CancelPickingContext
			{
			throw new Exception($"åæ¶åæ£å°å¯¼è´æ°æ®å¼å¸¸ï¼å·²åºåº{newOverOutQuantity}ï¼å·²æ£é{newPickedQty}");
			}
			LockInfo = lockInfo,
			PickingRecord = pickingRecord,
			OrderDetail = orderDetail,
			OrderNo = orderNo,
			CancelQuantity = cancelQty
			};

			var validationResult = await ValidateDataConsistencyBeforeCancel(context);
			if (!validationResult.IsValid)
			throw new Exception(validationResult.ErrorMessage);

			// 2. å¤çä¸åç±»åçåæ¶
			if (lockInfo.IsSplitted == 1 && lockInfo.ParentLockId.HasValue)
			@@ -638,16 +944,23 @@
			await HandleNormalBarcodeCancel(lockInfo, pickingRecord, cancelQty);
			}

			// 3. æ´æ°è®¢åæç»
			// æ´æ°è®¢åæç»
			await UpdateOrderDetailOnCancel(pickingRecord.OrderDetailId, cancelQty);

			// 4. å é¤æ£éè®°å½
			await Db.Deleteable<Dt_PickingRecord>()
			// å é¤æ£éè®°å½
			var deleteResult = await Db.Deleteable<Dt_PickingRecord>()
			.Where(x => x.Id == pickingRecord.Id)
			.ExecuteCommandAsync();

			// 5. éæ°æ£æ¥è®¢åç¶æ
			if (deleteResult <= 0)
			throw new Exception("å é¤æ£éè®°å½å¤±è´¥");

			_logger.LogInformation($"å é¤æ£éè®°å½ - è®°å½ID: {pickingRecord.Id}, æ¡ç : {pickingRecord.Barcode}");

			// éæ°æ£æ¥è®¢åç¶æ
			await UpdateOrderStatusForReturn(orderNo);


			}

			private async Task HandleSplitBarcodeCancel(Dt_OutStockLockInfo lockInfo, Dt_PickingRecord pickingRecord, decimal cancelQty)
			@@ -660,47 +973,85 @@
			if (parentLockInfo == null)
			throw new Exception("æªæ¾å°ç¶éå®ä¿¡æ¯ï¼æ æ³åæ¶æååæ£");

			// æ£æ¥ç¶æ¡ç åæåæ¡ç çç¶æ
			if (await IsLockInfoReturned(parentLockInfo))
			throw new Exception($"ç¶æ¡ç {parentLockInfo.CurrentBarcode}å·²ç»ååºï¼æ æ³åæ¶æååæ£");

			if (await IsLockInfoReturned(lockInfo))
			throw new Exception($"æåæ¡ç {lockInfo.CurrentBarcode}å·²ç»ååºï¼æ æ³åæ¶æååæ£");

			// æ¢å¤ç¶éå®ä¿¡æ¯çåéæ°é
			parentLockInfo.AssignQuantity += cancelQty;
			parentLockInfo.Status = (int)OutLockStockStatusEnum.åºåºä¸; // æ¢å¤ä¸ºåºåºä¸ç¶æ
			await _outStockLockInfoService.Db.Updateable(parentLockInfo).ExecuteCommandAsync();

			// æ¢å¤åºå
			var stockDetail = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
			// æ¢å¤ç¶æ¡ç åºå
			var parentStockDetail = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
			.Where(x => x.Barcode == parentLockInfo.CurrentBarcode && x.StockId == parentLockInfo.StockId)
			.FirstAsync();

			if (stockDetail != null)
			if (parentStockDetail != null)
			{
			stockDetail.StockQuantity += cancelQty;
			stockDetail.OutboundQuantity = stockDetail.StockQuantity;
			stockDetail.Status = StockStatusEmun.åºåºéå®.ObjToInt();
			await _stockInfoDetailService.Db.Updateable(stockDetail).ExecuteCommandAsync();
			parentStockDetail.StockQuantity += cancelQty;
			parentStockDetail.OutboundQuantity = parentStockDetail.StockQuantity;
			parentStockDetail.Status = StockStatusEmun.åºåºéå®.ObjToInt();
			await _stockInfoDetailService.Db.Updateable(parentStockDetail).ExecuteCommandAsync();

			_logger.LogInformation($"æ¢å¤ç¶æ¡ç åºå - æ¡ç : {parentStockDetail.Barcode}, æ¢å¤æ°é: {cancelQty}, æ°åºå: {parentStockDetail.StockQuantity}");
			}

			// å¤çæåäº§ççæ°æ¡ç åºå
			var splitStockDetail = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
			.Where(x => x.Barcode == lockInfo.CurrentBarcode && x.StockId == lockInfo.StockId)
			.FirstAsync();

			if (splitStockDetail != null)
			{
			// å é¤æåäº§ççæ°æ¡ç åºåè®°å½
			await _stockInfoDetailService.Db.Deleteable(splitStockDetail).ExecuteCommandAsync();
			_logger.LogInformation($"å é¤æåæ°æ¡ç åºå - æ¡ç : {splitStockDetail.Barcode}");
			}

			// æ´æ°æåè®°å½ç¶æ
			await _splitPackageService.Db.Updateable<Dt_SplitPackageRecord>()
			var updateCount = await _splitPackageService.Db.Updateable<Dt_SplitPackageRecord>()
			.SetColumns(x => new Dt_SplitPackageRecord
			{
			Status = (int)SplitPackageStatusEnum.å·²æ¤é,
			IsReverted = true,
			Operator = App.User.UserName,
			RevertTime = DateTime.Now
			})
			.Where(x => x.NewBarcode == lockInfo.CurrentBarcode && !x.IsReverted)
			.ExecuteCommandAsync();

			_logger.LogInformation($"æ´æ°æåè®°å½ç¶æ - æ´æ°è®°å½æ°: {updateCount}");

			// å é¤æåäº§ççéå®ä¿¡æ¯
			await _outStockLockInfoService.Db.Deleteable<Dt_OutStockLockInfo>()
			.Where(x => x.Id == lockInfo.Id)
			.ExecuteCommandAsync();
			}

			_logger.LogInformation($"å é¤æåéå®ä¿¡æ¯ - éå®ID: {lockInfo.Id}, æ¡ç : {lockInfo.CurrentBarcode}");
			}
			private async Task HandleNormalBarcodeCancel(Dt_OutStockLockInfo lockInfo, Dt_PickingRecord pickingRecord, decimal cancelQty)
			{
			if (await IsLockInfoReturned(lockInfo))
			throw new Exception($"æ¡ç {lockInfo.CurrentBarcode}å·²ç»ååºï¼æ æ³åæ¶åæ£");

			// æ¢å¤éå®ä¿¡æ¯
			lockInfo.PickedQty -= cancelQty;
			if (lockInfo.PickedQty < 0) lockInfo.PickedQty = 0;

			lockInfo.Status = (int)OutLockStockStatusEnum.åºåºä¸;
			// åªæå½æ£éæ°éå®å¨åæ¶æ¶ææ¢å¤ç¶æ
			if (lockInfo.PickedQty == 0)
			{
			lockInfo.Status = (int)OutLockStockStatusEnum.åºåºä¸;
			}

			lockInfo.Operator = App.User.UserName;
			await _outStockLockInfoService.Db.Updateable(lockInfo).ExecuteCommandAsync();

			_logger.LogInformation($"æ¢å¤éå®ä¿¡æ¯ - éå®ID: {lockInfo.Id}, æ£åæ£éæ°é: {cancelQty}, æ°å·²æ£éæ°é: {lockInfo.PickedQty}");

			// æ¢å¤åºå
			var stockDetail = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
			@@ -711,36 +1062,57 @@
			{
			stockDetail.StockQuantity += cancelQty;
			stockDetail.OutboundQuantity = stockDetail.StockQuantity;
			stockDetail.Status = StockStatusEmun.åºåºéå®.ObjToInt();

			// æ¢å¤åºåç¶æ
			if (stockDetail.Status == StockStatusEmun.åºåºå®æ.ObjToInt())
			{
			stockDetail.Status = StockStatusEmun.åºåºéå®.ObjToInt();
			}

			await _stockInfoDetailService.Db.Updateable(stockDetail).ExecuteCommandAsync();

			_logger.LogInformation($"æ¢å¤åºå - æ¡ç : {stockDetail.Barcode}, æ¢å¤æ°é: {cancelQty}, " +
			$"æ°åºå: {stockDetail.StockQuantity}, æ°ç¶æ: {stockDetail.Status}");
			}
			else
			{
			_logger.LogWarning($"æªæ¾å°åºåè®°å½ - æ¡ç : {pickingRecord.Barcode}, åºåID: {pickingRecord.StockId}");
			}
			}

			private async Task UpdateOrderDetailOnCancel(int orderDetailId, decimal cancelQty)
			{
			// è·åææ°çè®¢åæç»æ°æ®
			// è·åææ°çè®¢åæç»æ°æ®ï¼å¸¦éï¼
			var currentOrderDetail = await _outboundOrderDetailService.Db.Queryable<Dt_OutboundOrderDetail>()
			.With(SqlWith.RowLock)
			.FirstAsync(x => x.Id == orderDetailId);

			decimal newOverOutQuantity = currentOrderDetail.OverOutQuantity - cancelQty;
			decimal newPickedQty = currentOrderDetail.PickedQty - cancelQty;

			// æ£æ¥åæ¶åæ°éä¸ä¼ä¸ºè´æ°
			if (newOverOutQuantity < 0 \|\| newPickedQty < 0)
			{
			throw new Exception($"åæ¶åæ£å°å¯¼è´å·²åºåºæ°é({newOverOutQuantity})æå·²æ£éæ°é({newPickedQty})ä¸ºè´æ°");
			}
			// ä¸¥æ ¼æ£æ¥åæ¶åæ°éä¸ä¼ä¸ºè´æ°
			if (newOverOutQuantity < 0)
			throw new Exception($"åæ¶åæ£å°å¯¼è´å·²åºåºæ°é({newOverOutQuantity})ä¸ºè´æ°");

			await _outboundOrderDetailService.Db.Updateable<Dt_OutboundOrderDetail>()
			if (newPickedQty < 0)
			throw new Exception($"åæ¶åæ£å°å¯¼è´å·²æ£éæ°é({newPickedQty})ä¸ºè´æ°");

			// æ´æ°è®¢åæç»
			var updateResult = await _outboundOrderDetailService.Db.Updateable<Dt_OutboundOrderDetail>()
			.SetColumns(it => new Dt_OutboundOrderDetail
			{
			PickedQty = newPickedQty,
			OverOutQuantity = newOverOutQuantity,
			OverOutQuantity = newOverOutQuantity
			})
			.Where(it => it.Id == orderDetailId)
			.ExecuteCommandAsync();
			}

			if (updateResult <= 0)
			throw new Exception("æ´æ°è®¢åæç»å¤±è´¥");

			_logger.LogInformation($"æ´æ°è®¢åæç» - OrderDetailId: {orderDetailId}, " +
			$"æ£åå·²åºåº: {cancelQty}, æ°å·²åºåº: {newOverOutQuantity}, " +
			$"æ£åå·²æ£é: {cancelQty}, æ°å·²æ£é: {newPickedQty}");
			}
			#endregion

			#region ååºæä½ç§ææ¹æ³
			@@ -750,7 +1122,22 @@
			return await _stockInfoService.Db.Queryable<Dt_StockInfo>()
			.FirstAsync(x => x.PalletCode == palletCode);
			}
			/// <summary>
			/// æ£æ¥æ´ä¸ªæçæ¯å¦å·²ç»ååº
			/// </summary>
			private async Task<bool> IsPalletReturned(string palletCode)
			{
			var stockInfo = await _stockInfoService.Db.Queryable<Dt_StockInfo>()
			.Where(x => x.PalletCode == palletCode)
			.FirstAsync();

			if (stockInfo == null)
			return false;

			// å¦ææçç¶ææ¯å¥åºç¡®è®¤æå¥åºå®æï¼è¯´æå·²ç»ååº
			return stockInfo.StockStatus == StockStatusEmun.å¥åºç¡®è®¤.ObjToInt() \|\|
			stockInfo.StockStatus == StockStatusEmun.å¥åºå®æ.ObjToInt();
			}
			private async Task<Dt_Task> GetCurrentTask(string orderNo, string palletCode)
			{
			// åå°è¯éè¿è®¢åå·åæçå·æ¥æ¾ä»»å¡
			@@ -769,58 +1156,6 @@
			return task;
			}

			private async Task<ReturnAnalysisResult> AnalyzeReturnItems(string orderNo, string palletCode, int stockId)
			{
			var result = new ReturnAnalysisResult();

			// æåµ1ï¼è·åæªåæ£çåºåºéå®è®°å½
			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);
			}

			// æåµ2ï¼æ£æ¥æçä¸æ¯å¦æå¶ä»åºåè´§ç©
			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);
			}

			// æåµ3ï¼æ£æ¥æåè®°å½
			var splitRecords = await _splitPackageService.Db.Queryable<Dt_SplitPackageRecord>()
			.Where(it => it.OrderNo == orderNo && it.PalletCode == palletCode && !it.IsReverted)
			.ToListAsync();

			if (splitRecords.Any())
			{
			result.HasSplitRecords = true;
			result.SplitRecords = splitRecords;
			result.SplitReturnQty = await CalculateSplitReturnQuantity(splitRecords, stockId);
			}

			result.TotalReturnQty = result.RemainingLocksReturnQty + result.PalletStockReturnQty + result.SplitReturnQty;
			result.HasItemsToReturn = result.TotalReturnQty > 0;

			return result;
			}

			private async Task<decimal> CalculateSplitReturnQuantity(List<Dt_SplitPackageRecord> splitRecords, int stockId)
			{
			decimal totalQty = 0;
			@@ -828,11 +1163,14 @@

			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)
			.Where(it => it.Barcode == splitRecord.OriginalBarcode && it.StockId == stockId &&
			it.Status != StockStatusEmun.åºåºå®æ.ObjToInt())
			.FirstAsync();

			if (originalStock != null && originalStock.StockQuantity > 0)
			@@ -846,7 +1184,7 @@
			if (!processedBarcodes.Contains(splitRecord.NewBarcode))
			{
			var newStock = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
			.Where(it => it.Barcode == splitRecord.NewBarcode && it.StockId == stockId)
			.Where(it => it.Barcode == splitRecord.NewBarcode && it.StockId == stockId && it.Status != StockStatusEmun.åºåºå®æ.ObjToInt())
			.FirstAsync();

			if (newStock != null && newStock.StockQuantity > 0)
			@@ -860,45 +1198,109 @@
			return totalQty;
			}

			private async Task<WebResponseContent> HandleNoReturnItems(string orderNo, string palletCode)
			private async Task<WebResponseContent> HandleNoReturnItems(string orderNo, string palletCode, Dt_Task originalTask, int stockInfoId)
			{
			// æ£æ¥æ¯å¦ææè´§ç©é½å·²æ£éå®æ
			var allPicked = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
			.Where(it => it.OrderNo == orderNo && it.PalletCode == palletCode)
			.AnyAsync(it => it.Status == (int)OutLockStockStatusEnum.æ£éå®æ);
			//var allPicked = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
			// .Where(it => it.OrderNo == orderNo && it.PalletCode == palletCode)
			// .AnyAsync(it => it.Status == (int)OutLockStockStatusEnum.æ£éå®æ);

			if (allPicked)
			//if (allPicked)
			//{
			// // å é¤åå§åºåºä»»å¡ ç»ç©ºç ç©ºçååº
			// //await _taskRepository.Db.Deleteable(originalTask).ExecuteCommandAsync();
			// return WebResponseContent.Instance.OK("ææè´§ç©å·²æ£éå®æï¼æçä¸ºç©º");
			//}
			//else
			//{
			// // å é¤åå§åºåºä»»å¡
			// //await _taskRepository.Db.Deleteable(originalTask).ExecuteCommandAsync();
			// return WebResponseContent.Instance.Error("æ²¡æéè¦ååºçå©ä½è´§ç©");
			//}
			try
			{
			return WebResponseContent.Instance.OK("ææè´§ç©å·²æ£éå®æï¼æçä¸ºç©º");
			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(stockInfoId);


			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());

			}
			else
			catch (Exception ex)
			{
			return WebResponseContent.Instance.Error("æ²¡æéè¦ååºçå©ä½è´§ç©");
			_logger.LogError($" HandleNoReturnItems å¤±è´¥: {ex.Message}");
			return WebResponseContent.Instance.Error($" ååºç©ºæçå¤±è´¥ï¼");
			}
			return WebResponseContent.Instance.OK("ç©ºæçååºä»»å¡åå»ºæå");

			}

			private async Task ExecuteReturnOperations(string orderNo, string palletCode, Dt_StockInfo stockInfo,
			Dt_Task task, ReturnAnalysisResult analysis)
			Dt_Task task, PalletStatusAnalysis analysis)
			{
			// æåµ1ï¼å¤çæªåæ£çåºåºéå®è®°å½
			if (analysis.HasRemainingLocks)
			{
			await HandleRemainingLocksReturn(analysis.RemainingLocks, stockInfo.Id);

			// å³é®ï¼æ´æ°è®¢åæç»çå·²æ£éæ°é
			await UpdateOrderDetailsOnReturn(analysis.RemainingLocks);
			// await UpdateOrderDetailsOnReturn(analysis.RemainingLocks);
			}

			// æåµ2ï¼å¤çæçä¸å¶ä»åºåè´§ç©
			// å¤çæçä¸å¶ä»åºåè´§ç©
			if (analysis.HasPalletStockGoods)
			{
			await HandlePalletStockGoodsReturn(analysis.PalletStockGoods);
			var validStockGoods = analysis.PalletStockGoods
			.Where(x => x.Status != StockStatusEmun.åºåºå®æ.ObjToInt())
			.ToList();

			if (validStockGoods.Any())
			{
			await HandlePalletStockGoodsReturn(analysis.PalletStockGoods);
			}
			else
			{
			_logger.LogInformation("æ²¡æææçåºåè´§ç©éè¦ååº");
			}
			}

			// æåµ3ï¼å¤çæåè®°å½
			// å¤çæåè®°å½
			if (analysis.HasSplitRecords)
			{
			await HandleSplitRecordsReturn(analysis.SplitRecords, orderNo, palletCode);
			var validSplitRecords = analysis.SplitRecords
			.Where(x => x.Status != (int)SplitPackageStatusEnum.å·²æ£é)
			.ToList();

			if (validSplitRecords.Any())
			{
			await HandleSplitRecordsReturn(analysis.SplitRecords, orderNo, palletCode);
			}
			else
			{
			_logger.LogInformation("æ²¡æææçæåè®°å½éè¦å¤ç");
			}
			}

			// æ´æ°åºåä¸»è¡¨ç¶æ
			@@ -922,7 +1324,13 @@
			foreach (var lockInfo in remainingLocks)
			{
			decimal returnQty = lockInfo.AssignQuantity - lockInfo.PickedQty;
			if (returnQty <= 0)
			{
			_logger.LogWarning($"éå®è®°å½{lockInfo.Id}æ éååºï¼åéæ°é: {lockInfo.AssignQuantity}, å·²æ£é: {lockInfo.PickedQty}");
			continue;
			}

			_logger.LogInformation($"å¤çéå®è®°å½ååº - éå®ID: {lockInfo.Id}, æ¡ç : {lockInfo.CurrentBarcode}, ååºæ°é: {returnQty}");
			// æ¥æ¾å¯¹åºçåºåæç»
			var stockDetail = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
			.Where(it => it.Barcode == lockInfo.CurrentBarcode && it.StockId == lockInfo.StockId)
			@@ -932,29 +1340,29 @@
			{
			// æ¢å¤åºåç¶æ
			stockDetail.OutboundQuantity = Math.Max(0, stockDetail.OutboundQuantity - returnQty);
			stockDetail.Status = StockStatusEmun.å¥åºå®æ.ObjToInt();
			stockDetail.Status = StockStatusEmun.å¥åºç¡®è®¤.ObjToInt();
			await _stockInfoDetailService.Db.Updateable(stockDetail).ExecuteCommandAsync();
			}
			else
			{
			// åå»ºæ°çåºåè®°å½
			var newStockDetail = new Dt_StockInfoDetail
			{
			StockId = lockInfo.StockId,
			MaterielCode = lockInfo.MaterielCode,
			MaterielName = lockInfo.MaterielName,
			OrderNo = lockInfo.OrderNo,
			BatchNo = lockInfo.BatchNo,
			StockQuantity = returnQty,
			OutboundQuantity = 0,
			Barcode = lockInfo.CurrentBarcode,
			InboundOrderRowNo = "",
			Status = StockStatusEmun.å¥åºå®æ.ObjToInt(),
			SupplyCode = lockInfo.SupplyCode,
			WarehouseCode = lockInfo.WarehouseCode,
			Unit = lockInfo.Unit,
			};
			await _stockInfoDetailService.Db.Insertable(newStockDetail).ExecuteCommandAsync();
			//var newStockDetail = new Dt_StockInfoDetail
			//{
			// StockId = lockInfo.StockId,
			// MaterielCode = lockInfo.MaterielCode,
			// MaterielName = lockInfo.MaterielName,
			// OrderNo = lockInfo.OrderNo,
			// BatchNo = lockInfo.BatchNo,
			// StockQuantity = returnQty,
			// OutboundQuantity = 0,
			// Barcode = lockInfo.CurrentBarcode,
			// InboundOrderRowNo = "",
			// Status = StockStatusEmun.å¥åºç¡®è®¤.ObjToInt(),
			// SupplyCode = lockInfo.SupplyCode,
			// WarehouseCode = lockInfo.WarehouseCode,
			// Unit = lockInfo.Unit,
			//};
			//await _stockInfoDetailService.Db.Insertable(newStockDetail).ExecuteCommandAsync();
			}
			}
			}
			@@ -993,36 +1401,65 @@

			private async Task HandlePalletStockGoodsReturn(List<Dt_StockInfoDetail> palletStockGoods)
			{
			_logger.LogInformation($"ååºæä½ï¼åç°{palletStockGoods.Count}ä¸ªåºåæç»éè¦ååºï¼çå¾AGVæ¬è¿");
			foreach (var stockGood in palletStockGoods)
			{
			// æ¢å¤åºåç¶æ
			stockGood.OutboundQuantity = 0;
			stockGood.Status = StockStatusEmun.å¥åºå®æ.ObjToInt();
			_logger.LogInformation($"å¾ååºè´§ç© - æ¡ç : {stockGood.Barcode}, æ°é: {stockGood.StockQuantity}, å½åç¶æ: {stockGood.Status}");

			await _stockInfoDetailService.Db.Updateable(stockGood).ExecuteCommandAsync();
			if (stockGood.Status != StockStatusEmun.åºåºå®æ.ObjToInt())
			{
			stockGood.OutboundQuantity = 0;
			stockGood.Status = StockStatusEmun.å¥åºç¡®è®¤.ObjToInt();
			await _stockInfoDetailService.Db.Updateable(stockGood).ExecuteCommandAsync();

			_logger.LogInformation($"åºåè´§ç©ååºå®æ - æ¡ç : {stockGood.Barcode}, æ°ç¶æ: {stockGood.Status}");
			}
			else
			{
			_logger.LogWarning($"è·³è¿å·²åºåºå®æçè´§ç© - æ¡ç : {stockGood.Barcode}");
			}
			}
			}

			private async Task HandleSplitRecordsReturn(List<Dt_SplitPackageRecord> splitRecords, string orderNo, string palletCode)
			{
			var validRecords = splitRecords.Where(x => x.Status != (int)SplitPackageStatusEnum.å·²æ£é).ToList();

			if (!validRecords.Any())
			{
			_logger.LogInformation("æ²¡æéè¦ååºçæåè®°å½");
			return;
			}

			_logger.LogInformation($"æ´æ°{validRecords.Count}æ¡æåè®°å½ç¶æä¸ºå·²ååº");

			// æ´æ°æåè®°å½ç¶æ
			await _splitPackageService.Db.Updateable<Dt_SplitPackageRecord>()
			.SetColumns(x => new Dt_SplitPackageRecord
			{
			Status = (int)SplitPackageStatusEnum.å·²ååº,
			Operator = App.User.UserName
			})
			.Where(x => x.OrderNo == orderNo && x.PalletCode == palletCode && !x.IsReverted)
			.Where(x => validRecords.Select(r => r.Id).Contains(x.Id))
			.ExecuteCommandAsync();
			}

			private async Task UpdateStockInfoStatus(Dt_StockInfo stockInfo)
			{
			_logger.LogInformation($"ååºæä½ï¼æç{stockInfo.PalletCode}çå¾AGVååºæ¬è¿");
			// æ´æ°åºåä¸»è¡¨ç¶æ
			stockInfo.StockStatus = StockStatusEmun.å¥åºå®æ.ObjToInt();
			stockInfo.StockStatus = StockStatusEmun.å¥åºç¡®è®¤.ObjToInt();
			await _stockInfoService.Db.Updateable(stockInfo).ExecuteCommandAsync();
			}

			private async Task CreateReturnTaskAndHandleESS(string orderNo, string palletCode, Dt_Task originalTask, ReturnAnalysisResult analysis)
			/// <summary>
			/// åå»ºååºä»»å¡
			/// </summary>
			/// <param name="orderNo"></param>
			/// <param name="palletCode"></param>
			/// <param name="originalTask"></param>
			/// <param name="analysis"></param>
			/// <returns></returns>
			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);
			@@ -1036,27 +1473,38 @@
			Grade = 0,
			PalletCode = palletCode,
			NextAddress = "",
			OrderNo = originalTask.OrderNo,
			// OrderNo = originalTask.OrderNo,
			OrderNo = orderNo,
			Roadway = newLocation.RoadwayNo,
			SourceAddress = stations[originalTask.TargetAddress],
			TargetAddress = newLocation.LocationCode,
			TaskStatus = TaskStatusEnum.New.ObjToInt(),
			TaskType = TaskTypeEnum.InPick.ObjToInt(),
			PalletType = originalTask.PalletType,
			TaskType = taskTypeEnum.ObjToInt(),
			PalletType = palletType,
			WarehouseId = originalTask.WarehouseId

			};
			// ä¿åååºä»»å¡
			await _taskRepository.Db.Insertable(returnTask).ExecuteCommandAsync();
			var targetAddress = originalTask.TargetAddress;

			var targetAddress = originalTask.TargetAddress;

			// å é¤åå§åºåºä»»å¡
			await _taskRepository.Db.Deleteable(originalTask).ExecuteCommandAsync();
			_taskRepository.DeleteAndMoveIntoHty(originalTask, OperateTypeEnum.èªå¨å®æ);
			// await _taskRepository.Db.Deleteable(originalTask).ExecuteCommandAsync();



			// ç» ESS åéæµå¨ä¿¡å·ååå»ºä»»å¡
			await SendESSCommands(palletCode, targetAddress, returnTask);
			}

			/// <summary>
			/// ç»ESSä¸ä»»å¡
			/// </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
			@@ -1068,18 +1516,15 @@
			containerCode = palletCode
			});

			if (moveResult)
			//if (moveResult)
			//{
			// 2. åå»ºååºä»»å¡
			var essTask = new TaskModel()
			{
			// 2. åå»ºååºä»»å¡
			var essTask = new TaskModel()
			{
			taskType = "putaway",
			taskGroupCode = "",
			groupPriority = 0,
			tasks = new List<TasksType>
			{
			new()
			{
			taskType = "putaway",
			taskGroupCode = "",
			groupPriority = 0,
			tasks = new List<TasksType>{ new() {
			taskCode = returnTask.TaskNum.ToString(),
			taskPriority = 0,
			taskDescribe = new TaskDescribeType
			@@ -1092,13 +1537,12 @@
			deadline = 0,
			storageTag = ""
			}
			}
			}
			};
			} }
			};

			var resultTask = await _eSSApiService.CreateTaskAsync(essTask);
			_logger.LogInformation($"ReturnRemaining åå»ºä»»å¡æå: {resultTask}");
			}
			var resultTask = await _eSSApiService.CreateTaskAsync(essTask);
			_logger.LogInformation($"ReturnRemaining åå»ºä»»å¡æå: {resultTask}");
			//}
			}
			catch (Exception ex)
			{
			@@ -1141,15 +1585,19 @@
			if (outboundOrder.OrderStatus != newStatus)
			{
			await _outboundOrderService.Db.Updateable<Dt_OutboundOrder>()
			.SetColumns(x => x.OrderStatus == newStatus)
			.SetColumns(x => new Dt_OutboundOrder
			{
			OrderStatus = newStatus,
			Operator = App.User.UserName,
			})
			.Where(x => x.OrderNo == orderNo)
			.ExecuteCommandAsync();

			// åªææ£å¸¸åæ£å®ææ¶æåMESåé¦
			if (allCompleted && newStatus == (int)OutOrderStatusEnum.åºåºå®æ)
			{
			await HandleOrderCompletion(outboundOrder, orderNo);
			}
			//if (allCompleted && newStatus == (int)OutOrderStatusEnum.åºåºå®æ)
			//{
			// await HandleOrderCompletion(outboundOrder, orderNo);
			//}
			}
			}
			catch (Exception ex)
			@@ -1157,6 +1605,8 @@
			_logger.LogError($"CheckAndUpdateOrderStatuså¤±è´¥ - OrderNo: {orderNo}, Error: {ex.Message}");
			}
			}



			private async Task UpdateOrderStatusForReturn(string orderNo)
			{
			@@ -1188,7 +1638,11 @@
			if (outboundOrder.OrderStatus != newStatus)
			{
			await _outboundOrderService.Db.Updateable<Dt_OutboundOrder>()
			.SetColumns(x => x.OrderStatus == newStatus)
			.SetColumns(x => new Dt_OutboundOrder
			{
			OrderStatus = newStatus,
			Operator = App.User.UserName,
			})
			.Where(x => x.OrderNo == orderNo)
			.ExecuteCommandAsync();

			@@ -1204,75 +1658,480 @@
			private async Task HandleOrderCompletion(Dt_OutboundOrder outboundOrder, string orderNo)
			{
			// è°æ¨åºåºåéæ£åºåºä¸éè¦åé¦MES
			if (outboundOrder.OrderType == OutOrderTypeEnum.Allocate.ObjToInt() \|\|
			outboundOrder.OrderType == OutOrderTypeEnum.ReCheck.ObjToInt())
			if (outboundOrder.OrderType == OutOrderTypeEnum.Allocate.ObjToInt())
			{
			return;
			}

			try
			{
			var feedmodel = new FeedbackOutboundRequestModel
			var allocate = _allocateService.Repository.QueryData(x => x.UpperOrderNo == outboundOrder.UpperOrderNo).First();
			var feedmodel = new AllocateDto
			{
			reqCode = Guid.NewGuid().ToString(),
			reqTime = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"),
			business_type = outboundOrder.BusinessType,
			factoryArea = outboundOrder.FactoryArea,
			operationType = 1,
			Operator = outboundOrder.Operator,
			orderNo = outboundOrder.UpperOrderNo,
			status = outboundOrder.OrderStatus,
			details = new List<FeedbackOutboundDetailsModel>()
			};
			ReqCode = Guid.NewGuid().ToString(),
			ReqTime = DateTime.Now.ToString(),
			BusinessType = "3",

			FactoryArea = outboundOrder.FactoryArea,
			OperationType = 1,
			Operator = App.User.UserName,
			OrderNo = outboundOrder.UpperOrderNo,
			// documentsNO = outboundOrder.OrderNo,
			// status = outboundOrder.OrderStatus,
			fromWarehouse = allocate?.FromWarehouse ?? "",
			toWarehouse = allocate?.ToWarehouse ?? "",
			Details = new List<AllocateDtoDetail>()

			};
			// åªè·åå·²æ£éå®æçéå®è®°å½
			var lists = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
			.Where(x => x.OrderNo == orderNo && x.Status == (int)OutLockStockStatusEnum.æ£éå®æ)
			.ToListAsync();

			var groupedData = lists.GroupBy(item => new { item.MaterielCode, item.lineNo, item.Unit, item.WarehouseCode })
			.Select(group => new FeedbackOutboundDetailsModel
			.Select(group => new AllocateDtoDetail
			{
			materialCode = group.Key.MaterielCode,
			lineNo = group.Key.lineNo,
			warehouseCode = group.Key.WarehouseCode,
			currentDeliveryQty = group.Sum(x => x.PickedQty),
			unit = group.Key.Unit,
			barcodes = group.Select(row => new WIDESEA_DTO.Outbound.BarcodesModel
			MaterialCode = group.Key.MaterielCode,
			LineNo = group.Key.lineNo,
			WarehouseCode = group.Key.WarehouseCode,
			Qty = group.Sum(x => x.PickedQty),

			Unit = group.Key.Unit,
			Barcodes = group.Select(row => new BarcodeInfo
			{
			barcode = row.CurrentBarcode,
			supplyCode = row.SupplyCode,
			batchNo = row.BatchNo,
			unit = row.Unit,
			qty = row.PickedQty
			Barcode = row.CurrentBarcode,
			SupplyCode = row.SupplyCode,
			BatchNo = row.BatchNo,
			Unit = row.Unit,
			Qty = row.PickedQty
			}).ToList()


			}).ToList();
			feedmodel.Details = groupedData;

			feedmodel.details = groupedData;

			var result = await _invokeMESService.FeedbackOutbound(feedmodel);
			var result = await _invokeMESService.FeedbackAllocate(feedmodel);
			if (result != null && result.code == 200)
			{
			{
			await _outboundOrderDetailService.Db.Updateable<Dt_OutboundOrderDetail>()
			.SetColumns(x => x.ReturnToMESStatus == 1)
			.Where(x => x.OrderId == outboundOrder.Id)
			.ExecuteCommandAsync();
			.SetColumns(x => x.ReturnToMESStatus == 1)
			.Where(x => x.OrderId == outboundOrder.Id).ExecuteCommandAsync();

			await _outboundOrderService.Db.Updateable<Dt_OutboundOrder>()
			.SetColumns(x => x.ReturnToMESStatus == 1)
			.Where(x => x.OrderNo == orderNo)
			.ExecuteCommandAsync();
			.SetColumns(x => new Dt_OutboundOrder
			{
			ReturnToMESStatus = 1,
			Operator = App.User.UserName,
			}).Where(x => x.OrderNo == orderNo).ExecuteCommandAsync();
			}
			}
			catch (Exception ex)
			else if (outboundOrder.OrderType == OutOrderTypeEnum.ReCheck.ObjToInt())
			{
			_logger.LogError($"FeedbackOutboundå¤±è´¥ - OrderNo: {orderNo}, Error: {ex.Message}");

			}
			else
			{
			try
			{
			var feedmodel = new FeedbackOutboundRequestModel
			{
			reqCode = Guid.NewGuid().ToString(),
			reqTime = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"),
			business_type = outboundOrder.BusinessType,
			factoryArea = outboundOrder.FactoryArea,
			operationType = 1,
			Operator = App.User.UserName,
			orderNo = outboundOrder.UpperOrderNo,
			documentsNO = outboundOrder.OrderNo,
			status = outboundOrder.OrderStatus,
			details = new List<FeedbackOutboundDetailsModel>()
			};

			// åªè·åå·²æ£éå®æçéå®è®°å½
			var lists = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
			.Where(x => x.OrderNo == orderNo && x.Status == (int)OutLockStockStatusEnum.æ£éå®æ)
			.ToListAsync();

			var groupedData = lists.GroupBy(item => new { item.MaterielCode, item.lineNo, item.Unit, item.WarehouseCode })
			.Select(group => new FeedbackOutboundDetailsModel
			{
			materialCode = group.Key.MaterielCode,
			lineNo = group.Key.lineNo,
			warehouseCode = group.Key.WarehouseCode,
			qty = group.Sum(x => x.PickedQty),
			currentDeliveryQty = group.Sum(x => x.PickedQty),
			unit = group.Key.Unit,
			barcodes = group.Select(row => new WIDESEA_DTO.Outbound.BarcodesModel
			{
			barcode = row.CurrentBarcode,
			supplyCode = row.SupplyCode,
			batchNo = row.BatchNo,
			unit = row.Unit,
			qty = row.PickedQty
			}).ToList()
			}).ToList();

			feedmodel.details = groupedData;

			var result = await _invokeMESService.FeedbackOutbound(feedmodel);
			if (result != null && result.code == 200)
			{
			await _outboundOrderDetailService.Db.Updateable<Dt_OutboundOrderDetail>()
			.SetColumns(x => x.ReturnToMESStatus == 1)
			.Where(x => x.OrderId == outboundOrder.Id)
			.ExecuteCommandAsync();

			await _outboundOrderService.Db.Updateable<Dt_OutboundOrder>()
			.SetColumns(x => new Dt_OutboundOrder
			{
			ReturnToMESStatus = 1,
			Operator = App.User.UserName,
			})

			.Where(x => x.OrderNo == orderNo)
			.ExecuteCommandAsync();
			}

			_logger.LogError($"FeedbackOutboundæå - OrderNo: {orderNo}, {JsonSerializer.Serialize(result)}");
			}
			catch (Exception ex)
			{
			_logger.LogError($"FeedbackOutboundå¤±è´¥ - OrderNo: {orderNo}, Error: {ex.Message}");
			}
			}
			}

			#endregion

			#region ç©ºæç

			/// <summary>
			/// æ¸çé¶åºåæ°æ®
			/// </summary>
			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 && (x.Status == StockStatusEmun.åºåºå®æ.ObjToInt() \|\| x.Status ==
			StockStatusEmun.å¥åºå®æ.ObjToInt()))
			.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 HandleTaskCleanup(string orderNo, string palletCode)
			{
			try
			{
			// 1. æ¥æ¾ææä¸è¯¥è®¢ååæçç¸å³çä»»å¡
			var tasks = await _taskRepository.Db.Queryable<Dt_Task>().Where(x => x.OrderNo == orderNo && x.PalletCode == palletCode).ToListAsync();

			if (tasks.Any())
			{
			foreach (var task in tasks)
			{
			task.TaskStatus = (int)TaskStatusEnum.Finish;
			}
			// await _taskRepository.Db.Updateable(tasks).ExecuteCommandAsync();

			_taskRepository.DeleteAndMoveIntoHty(tasks, OperateTypeEnum.èªå¨å®æ);
			_logger.LogInformation($"å®æ{tasks.Count}ä¸ªæçä»»å¡ - è®¢å: {orderNo}, æç: {palletCode}");
			}

			}
			catch (Exception ex)
			{
			_logger.LogWarning($"å¤çä»»å¡æ¸çå¤±è´¥ - OrderNo: {orderNo}, PalletCode: {palletCode}, Error: {ex.Message}");
			throw new Exception($"ä»»å¡æ¸çå¤±è´¥: {ex.Message}");
			}
			}
			/// <summary>
			/// æ´æ°è®¢åç¸å³æ°æ®
			/// </summary>
			private async Task UpdateOrderData(string orderNo, string palletCode)
			{
			try
			{
			// æ£æ¥è®¢åæ¯å¦è¿æå¶ä»æçå¨å¤çä¸
			var otherActivePallets = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
			.Where(x => x.OrderNo == orderNo &&
			x.PalletCode != palletCode &&
			(x.Status == (int)OutLockStockStatusEnum.åºåºä¸ \|\| x.Status == (int)OutLockStockStatusEnum.ååºä¸))
			.AnyAsync();

			var otherActiveTasks = await _taskRepository.Db.Queryable<Dt_Task>()
			.Where(x => x.OrderNo == orderNo &&
			x.PalletCode != palletCode
			// && x.TaskStatus.In((int)TaskStatusEnum.å¾æ§è¡, (int)TaskStatusEnum.æ§è¡ä¸)
			)
			.AnyAsync();

			// å¦ææ²¡æå¶ä»æçå¨å¤çï¼æ£æ¥è®¢åæ¯å¦åºè¯¥å®æ
			if (!otherActivePallets && !otherActiveTasks)
			{
			await CheckAndUpdateOrderCompletion(orderNo);
			}
			else
			{
			_logger.LogInformation($"è®¢å {orderNo} è¿æå¶ä»æçå¨å¤çï¼ä¸æ´æ°è®¢åç¶æ");
			}

			// 3. æ´æ°æ£éè®°å½ç¶æï¼å¯éï¼
			await UpdatePickingRecordsStatus(orderNo, palletCode);

			}
			catch (Exception ex)
			{
			_logger.LogWarning($"æ´æ°è®¢åæ°æ®å¤±è´¥ - OrderNo: {orderNo}, PalletCode: {palletCode}, Error: {ex.Message}");
			throw new Exception($"æ´æ°è®¢åæ°æ®å¤±è´¥: {ex.Message}");
			}
			}

			/// <summary>
			/// æ£æ¥å¹¶æ´æ°è®¢åå®æç¶æ
			/// </summary>
			private async Task CheckAndUpdateOrderCompletion(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();

			bool allCompleted = true;
			foreach (var detail in orderDetails)
			{
			if (detail.OverOutQuantity < detail.NeedOutQuantity)
			{
			allCompleted = false;
			break;
			}
			}

			var outboundOrder = await _outboundOrderService.Db.Queryable<Dt_OutboundOrder>()
			.FirstAsync(x => x.OrderNo == orderNo);

			if (outboundOrder != null && allCompleted && outboundOrder.OrderStatus != (int)OutOrderStatusEnum.åºåºå®æ)
			{
			outboundOrder.OrderStatus = (int)OutOrderStatusEnum.åºåºå®æ;
			outboundOrder.Operator = App.User.UserName;
			await _outboundOrderService.Db.Updateable(outboundOrder).ExecuteCommandAsync();

			_logger.LogInformation($"è®¢å {orderNo} å·²æ è®°ä¸ºåºåºå®æ");

			// åMESåé¦è®¢åå®æï¼å¦æéè¦ï¼
			await HandleOrderCompletion(outboundOrder, orderNo);
			}
			}

			/// <summary>
			/// æ´æ°æ£éè®°å½ç¶æ
			/// </summary>
			private async Task UpdatePickingRecordsStatus(string orderNo, string palletCode)
			{
			try
			{
			// å¯ä»¥å°ç¸å³çæ£éè®°å½æ è®°ä¸ºå·²å®æ
			var pickingRecords = await Db.Queryable<Dt_PickingRecord>()
			.Where(x => x.OrderNo == orderNo && x.PalletCode == palletCode)
			.ToListAsync();

			// è¿éå¯ä»¥æ ¹æ®éè¦æ´æ°æ£éè®°å½çç¶æåæ®µ
			// ä¾å¦ï¼pickingRecord.Status = (int)PickingStatusEnum.å·²å®æ;

			_logger.LogInformation($"æ¾å°{pickingRecords.Count}æ¡æ£éè®°å½ - è®¢å: {orderNo}, æç: {palletCode}");

			}
			catch (Exception ex)
			{
			_logger.LogWarning($"æ´æ°æ£éè®°å½ç¶æå¤±è´¥: {ex.Message}");
			}
			}
			#endregion



			#region è¾å©æ¹æ³
			/// <summary>
			/// ç»ä¸åææçç¶æ - è¿åæççå®æ´ç¶æä¿¡æ¯
			/// </summary>
			private async Task<PalletStatusAnalysis> AnalyzePalletStatus(string orderNo, string palletCode, int stockId)
			{
			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;
			}

			/// <summary>
			/// æ£æ¥æçæ¯å¦ä¸ºç©º
			/// </summary>
			private async Task<bool> IsPalletEmpty(string orderNo, string palletCode)
			{
			try
			{
			// è·ååºåä¿¡æ¯
			var stockInfo = await _stockInfoService.Db.Queryable<Dt_StockInfo>()
			.Where(x => x.PalletCode == palletCode)
			.FirstAsync();

			if (stockInfo == null)
			return false;

			// ä½¿ç¨ç»ä¸çç¶æåæ
			var statusAnalysis = await AnalyzePalletStatus(orderNo, palletCode, stockInfo.Id);
			return statusAnalysis.IsEmptyPallet;
			}
			catch (Exception ex)
			{
			_logger.LogWarning($"æ£æ¥æçæ¯å¦ä¸ºç©ºå¤±è´¥ - OrderNo: {orderNo}, PalletCode: {palletCode}, Error: {ex.Message}");
			return false;
			}
			}
			/// <summary>
			/// æ£æ¥å¹¶å¤çç©ºæç
			/// </summary>
			private async Task<bool> CheckAndHandleEmptyPallet(string orderNo, string palletCode)
			{
			try
			{
			// 1. è·ååºåä¿¡æ¯
			var stockInfo = await _stockInfoService.Db.Queryable<Dt_StockInfo>()
			.Where(x => x.PalletCode == palletCode)
			.FirstAsync();

			if (stockInfo == null)
			{
			_logger.LogWarning($"æªæ¾å°æç {palletCode} çåºåä¿¡æ¯");
			return false;
			}

			// 2. ä½¿ç¨ç»ä¸çç¶æåæ
			var statusAnalysis = await AnalyzePalletStatus(orderNo, palletCode, stockInfo.Id);

			// 3. æ£æ¥æ¯å¦ä¸ºç©ºæçä¸æ²¡æè¿è¡ä¸çä»»å¡
			if (!statusAnalysis.IsEmptyPallet \|\| statusAnalysis.HasActiveTasks)
			{
			return false;
			}

			_logger.LogInformation($"æ£æµå°ç©ºæçï¼å¼å§èªå¨å¤ç - è®¢å: {orderNo}, æç: {palletCode}");

			//// æ¸çé¶åºåæ°æ®
			//await CleanupZeroStockData(stockInfo.Id);

			//// æ´æ°åºåä¸»è¡¨ç¶æä¸ºç©ºæç
			//await UpdateStockInfoAsEmpty(stockInfo);

			//// å¤çåºåºéå®è®°å½
			//await HandleOutStockLockRecords(orderNo, palletCode);

			//// å¤çä»»å¡ç¶æ
			//await HandleTaskStatusForEmptyPallet(orderNo, palletCode);

			//// æ´æ°è®¢åæ°æ®
			//await UpdateOrderDataForEmptyPallet(orderNo, palletCode);

			////è®°å½æä½åå²
			//await RecordAutoEmptyPalletOperation(orderNo, palletCode);

			_logger.LogInformation($"ç©ºæçèªå¨å¤çå®æ - è®¢å: {orderNo}, æç: {palletCode}");

			return true;
			}
			catch (Exception ex)
			{
			_logger.LogError($"èªå¨å¤çç©ºæçå¤±è´¥ - OrderNo: {orderNo}, PalletCode: {palletCode}, Error: {ex.Message}");
			return false;
			}
			}

			private async Task<string> GenerateNewBarcode()
			{
			@@ -1304,7 +2163,12 @@
			CurrentBarcode = newBarcode,
			OriginalLockQuantity = quantity,
			IsSplitted = 1,
			ParentLockId = originalLock.Id
			ParentLockId = originalLock.Id,
			Operator = App.User.UserName,
			FactoryArea = originalLock.FactoryArea,
			lineNo = originalLock.lineNo,
			WarehouseCode = originalLock.WarehouseCode,

			};

			var newLockId = await _outStockLockInfoService.Db.Insertable(newLockInfo).ExecuteReturnIdentityAsync();
			@@ -1385,12 +2249,27 @@

			private WebResponseContent CreatePickingResponse(PickingResult result, string adjustedReason)
			{
			//if (result.SplitResults.Any())
			//{
			// var responseData = new { SplitResults = result.SplitResults, AdjustedReason = "" };
			// if (!string.IsNullOrEmpty(adjustedReason))
			// {
			// responseData = new { SplitResults = result.SplitResults, AdjustedReason = adjustedReason };
			// }
			// return WebResponseContent.Instance.OK("æ£éç¡®è®¤æåï¼å·²èªå¨æå", responseData);
			//}

			//if (!string.IsNullOrEmpty(adjustedReason))
			//{
			// return WebResponseContent.Instance.OK($"æ£éç¡®è®¤æåï¼{adjustedReason}ï¼");
			//}

			//return WebResponseContent.Instance.OK("æ£éç¡®è®¤æå");

			if (result.SplitResults.Any())
			{

			return WebResponseContent.Instance.OK("æ£éç¡®è®¤æåï¼å·²èªå¨æå", new { SplitResults = result.SplitResults });
			}

			return WebResponseContent.Instance.OK("æ£éç¡®è®¤æå", new { SplitResults = new List<SplitResult>() });
			}

			@@ -1447,6 +2326,56 @@
			public List<Dt_StockInfoDetail> PalletStockGoods { get; set; } = new List<Dt_StockInfoDetail>();
			public List<Dt_SplitPackageRecord> SplitRecords { get; set; } = new List<Dt_SplitPackageRecord>();
			}
			public class PalletStatusAnalysis
			{
			public string OrderNo { get; set; }
			public string PalletCode { get; set; }
			public int StockId { get; set; }

			// ååºç¸å³å±æ§
			public bool HasItemsToReturn { get; set; }
			public bool HasRemainingLocks { get; set; }
			public bool HasPalletStockGoods { get; set; }
			public bool HasSplitRecords { get; set; }
			public decimal RemainingLocksReturnQty { get; set; }
			public decimal PalletStockReturnQty { get; set; }
			public decimal SplitReturnQty { get; set; }
			public decimal TotalReturnQty { get; set; }
			public List<Dt_OutStockLockInfo> RemainingLocks { get; set; } = new List<Dt_OutStockLockInfo>();
			public List<Dt_StockInfoDetail> PalletStockGoods { get; set; } = new List<Dt_StockInfoDetail>();
			public List<Dt_SplitPackageRecord> SplitRecords { get; set; } = new List<Dt_SplitPackageRecord>();

			// ç©ºæçç¸å³å±æ§
			public bool IsEmptyPallet { get; set; }
			public bool HasActiveTasks { get; set; }

			// ä¾¿å©æ¹æ³
			public bool CanReturn => HasItemsToReturn && !HasActiveTasks;
			public bool CanRemove => IsEmptyPallet && !HasActiveTasks;
			}
			public class PickingContext
			{
			public string OrderNo { get; set; }
			public string PalletCode { get; set; }
			public string Barcode { get; set; }
			public string Operator { get; set; }
			public Dt_OutStockLockInfo LockInfo { get; set; }
			public Dt_OutboundOrderDetail OrderDetail { get; set; }
			public Dt_StockInfoDetail StockDetail { get; set; }
			public decimal ActualQuantity { get; set; }
			public string AdjustedReason { get; set; }
			}
			public class CancelPickingContext
			{
			public string OrderNo { get; set; }
			public string PalletCode { get; set; }
			public string Barcode { get; set; }
			public string Operator { get; set; }

			public decimal CancelQuantity { get; set; }
			public Dt_PickingRecord PickingRecord { get; set; }
			public Dt_OutStockLockInfo LockInfo { get; set; }
			public Dt_OutboundOrderDetail OrderDetail { get; set; }
			}
			#endregion
			}