ZhongRui/ALDbanyunxiangmu.git

			@@ -1,6 +1,5 @@
			ï»¿using Microsoft.Extensions.Logging;
			using SqlSugar;
			using SqlSugar.Extensions;
			using System;
			using System.Collections.Generic;
			using System.Linq;
			@@ -15,12 +14,14 @@
			using WIDESEA_Core.BaseRepository;
			using WIDESEA_Core.BaseServices;
			using WIDESEA_Core.Enums;
			using WIDESEA_Core.Helper;
			using WIDESEA_DTO.Basic;
			using WIDESEA_DTO.Outbound;
			using WIDESEA_IAllocateService;
			using WIDESEA_IBasicService;
			using WIDESEA_IOutboundService;
			using WIDESEA_IStockService;
			using WIDESEA_ITaskInfoService;
			using WIDESEA_Model.Models;
			using WIDESEA_Model.Models.Basic;
			using WIDESEA_Model.Models.Outbound;
			@@ -49,6 +50,7 @@
			private readonly IDailySequenceService _dailySequenceService;
			private readonly IAllocateService _allocateService;
			private readonly IRepository<Dt_OutboundBatch> _outboundBatchRepository;
			private readonly ITask_HtyService _task_HtyService;
			private readonly ILogger<OutboundPickingService> _logger;

			private Dictionary<string, string> stations = new Dictionary<string, string>
			@@ -68,7 +70,7 @@
			public OutboundBatchPickingService(IRepository<Dt_PickingRecord> BaseDal, IUnitOfWorkManage unitOfWorkManage, IStockInfoService stockInfoService, IStockService stockService,
			IOutStockLockInfoService outStockLockInfoService, IStockInfoDetailService stockInfoDetailService, ILocationInfoService locationInfoService,
			IOutboundOrderDetailService outboundOrderDetailService, ISplitPackageService splitPackageService, IOutboundOrderService outboundOrderService,
			IRepository<Dt_Task> taskRepository, IESSApiService eSSApiService, ILogger<OutboundPickingService> logger, IInvokeMESService invokeMESService, IDailySequenceService dailySequenceService, IAllocateService allocateService, IRepository<Dt_OutboundBatch> outboundBatchRepository) : base(BaseDal)
			IRepository<Dt_Task> taskRepository, IESSApiService eSSApiService, ILogger<OutboundPickingService> logger, IInvokeMESService invokeMESService, IDailySequenceService dailySequenceService, IAllocateService allocateService, IRepository<Dt_OutboundBatch> outboundBatchRepository, ITask_HtyService task_HtyService) : base(BaseDal)
			{
			_unitOfWorkManage = unitOfWorkManage;
			_stockInfoService = stockInfoService;
			@@ -86,6 +88,7 @@
			_dailySequenceService = dailySequenceService;
			_allocateService = allocateService;
			_outboundBatchRepository = outboundBatchRepository;
			_task_HtyService = task_HtyService;
			}

			// <summary>
			@@ -246,27 +249,48 @@

			#region åæ¹åæ£


			/// <summary>
			/// åæ¹åæ£ç¡®è®¤
			/// åæ¹åæ£ç¡®è®¤ - ä¿®æ£çï¼åå«æååéªè¯ï¼
			/// </summary>
			public async Task<WebResponseContent> ConfirmBatchPicking(string orderNo, string palletCode, string barcode)
			{
			try
			{
			_logger.LogInformation($"ãåæ£å¼å§ãè®¢å: {orderNo}, æç: {palletCode}, æ¡ç : {barcode}");

			_unitOfWorkManage.BeginTran();

			// éªè¯åæ£è¯·æ±
			// 1. éªè¯åæ£è¯·æ±
			var validationResult = await ValidatePickingRequest(orderNo, palletCode, barcode);
			if (!validationResult.IsValid)
			{
			_unitOfWorkManage.RollbackTran();
			return WebResponseContent.Instance.Error(validationResult.ErrorMessage);
			}

			var (lockInfo, orderDetail, stockDetail, batch) = validationResult.Data;

			// æ£æ¥æ¯å¦éè¦èªå¨æå
			_logger.LogInformation($"éªè¯éè¿ - éå®ID: {lockInfo.Id}, åéæ°é: {lockInfo.AssignQuantity}, å·²æ£é: {lockInfo.PickedQty}");
			_logger.LogInformation($"åºåä¿¡æ¯ - æ¡ç : {stockDetail.Barcode}, åºåæ°é: {stockDetail.StockQuantity}, åºåºæ°é: {stockDetail.OutboundQuantity}");


			decimal originalStockQtyBeforeSplit = stockDetail.StockQuantity;
			decimal originalOutboundQtyBeforeSplit = stockDetail.OutboundQuantity;

			// è®°å½æååçå³é®æ°æ®ï¼ç¨äºåç»éªè¯ï¼
			decimal originalAllocatedQty = orderDetail.AllocatedQuantity;
			decimal originalLockQty = orderDetail.LockQuantity;
			decimal originalStockQty = stockDetail.StockQuantity;
			decimal originalOutboundQty = stockDetail.OutboundQuantity;

			// 2. æ£æ¥æ¯å¦éè¦èªå¨æå
			var autoSplitResult = await CheckAndAutoSplitIfNeeded(lockInfo, stockDetail, palletCode);
			if (autoSplitResult != null)
			{
			// å¦ææ§è¡äºèªå¨æåï¼éæ°è·åææ°çéå®ä¿¡æ¯ååºåä¿¡æ¯
			_logger.LogInformation($"æ§è¡äºèªå¨æåï¼éæ°è·åæ°æ®");

			// éæ°è·åææ°çéå®ä¿¡æ¯ååºåä¿¡æ¯
			var refreshedValidation = await ValidatePickingRequest(orderNo, palletCode, barcode);
			if (!refreshedValidation.IsValid)
			{
			@@ -275,40 +299,56 @@
			}

			(lockInfo, orderDetail, stockDetail, batch) = refreshedValidation.Data;


			// ãéè¦ãè°ç¨èªå¨æååéªè¯
			decimal splitQuantity = autoSplitResult.FirstOrDefault()?.quantityTotal.ObjToDecimal()??0 ;
			bool autoSplitValid = await ValidateAfterAutoSplit(lockInfo, orderDetail, stockDetail, splitQuantity,originalStockQtyBeforeSplit);

			var actualPickedQty = lockInfo.AssignQuantity;
			var pickingResult = await ExecutePickingLogic(lockInfo, orderDetail, stockDetail, actualPickedQty);
			if (!autoSplitValid)
			{
			_unitOfWorkManage.RollbackTran();
			return WebResponseContent.Instance.Error("èªå¨æååæ°æ®éªè¯å¤±è´¥ï¼è¯·æ£æ¥ç³»ç»æ¥å¿");
			}

			// æ´æ°æ¹æ¬¡åè®¢åæ°æ®
			await UpdateBatchAndOrderData(batch, orderDetail, actualPickedQty, orderNo);

			// è®°å½æ£éåå²
			await RecordPickingHistory(pickingResult, orderNo, palletCode);

			_unitOfWorkManage.CommitTran();

			return WebResponseContent.Instance.OK("èªå¨æåå¹¶åæ£æå", autoSplitResult);
			_logger.LogInformation($"èªå¨æåéªè¯éè¿ï¼ç»§ç»æ§è¡åæ£");
			}

			// æ£å¸¸åæ£æµç¨ï¼ä¸éè¦èªå¨æåï¼
			var normalPickedQty = lockInfo.AssignQuantity;
			var normalPickingResult = await ExecutePickingLogic(lockInfo, orderDetail, stockDetail, normalPickedQty);
			// 3. è®¡ç®å®éæ£éæ°é
			decimal actualPickedQty = lockInfo.AssignQuantity - lockInfo.PickedQty;

			// æ´æ°æ¹æ¬¡åè®¢åæ°æ®
			await UpdateBatchAndOrderData(batch, orderDetail, normalPickedQty, orderNo);
			if (actualPickedQty <= 0)
			{
			_unitOfWorkManage.RollbackTran();
			return WebResponseContent.Instance.Error("è¯¥æ¡ç å·²æ£éå®æï¼æ ééå¤æ£é");
			}

			// è®°å½æ£éåå²
			await RecordPickingHistory(normalPickingResult, orderNo, palletCode);
			_logger.LogInformation($"å¼å§æ£é - æ°é: {actualPickedQty}");

			// 4. æ§è¡åæ£é»è¾
			var pickingResult = await ExecutePickingLogic(lockInfo, orderDetail, stockDetail, actualPickedQty);

			// 5. æ´æ°æ¹æ¬¡åè®¢åæ°æ®
			await UpdateBatchAndOrderData(batch, orderDetail, actualPickedQty, orderNo);

			// 6. è®°å½æ£éåå²
			await RecordPickingHistory(pickingResult, orderNo, palletCode);

			// 7. æ£éåéªè¯
			await ValidateAfterPicking(orderNo, palletCode, barcode, actualPickedQty);

			_unitOfWorkManage.CommitTran();

			return WebResponseContent.Instance.OK("åæ£æå", new
			{
			PickedQuantity = normalPickedQty,
			PickedQuantity = actualPickedQty,
			Barcode = barcode,
			MaterialCode = lockInfo.MaterielCode,
			AutoSplitted = false
			AutoSplitted = autoSplitResult != null,
			RemainingStock = stockDetail.StockQuantity,
			CurrentOutbound = stockDetail.OutboundQuantity,
			// å¦ææ¯èªå¨æåï¼è¿åç¸å³ä¿¡æ¯
			UnallocatedCreated = autoSplitResult != null ? "æ¯" : "å¦"
			});
			}
			catch (Exception ex)
			@@ -318,6 +358,260 @@
			return WebResponseContent.Instance.Error($"åæ£å¤±è´¥ï¼{ex.Message}");
			}
			}


			/// <summary>
			/// èªå¨æååéªè¯æ°æ®ä¸è´æ§ - ä¿®æ£ç
			/// éç¹ä¿®æ£ï¼æ£ç¡®çååºåææå¼è®¡ç®
			/// </summary>
			private async Task<bool> ValidateAfterAutoSplit(Dt_OutStockLockInfo lockInfo, Dt_OutboundOrderDetail orderDetail,
			Dt_StockInfoDetail originalStockDetail, decimal splitQuantity, decimal originalStockQtyBeforeSplit)
			{
			try
			{
			_logger.LogInformation($"å¼å§èªå¨æååéªè¯ - åæ¡ç : {originalStockDetail.Barcode}, æåæ°é: {splitQuantity}");
			_logger.LogInformation($"æååååºåæ°é: {originalStockQtyBeforeSplit}, åéæ°é: {lockInfo.AssignQuantity}");

			bool allValid = true;
			List<string> validationErrors = new List<string>();

			// 1. éæ°è·åææ°çæ°æ®ï¼æååçå½åç¶æï¼
			var refreshedOrderDetail = await _outboundOrderDetailService.Db.Queryable<Dt_OutboundOrderDetail>()
			.FirstAsync(x => x.Id == orderDetail.Id);

			var refreshedLockInfo = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
			.FirstAsync(x => x.Id == lockInfo.Id);

			var refreshedStockDetail = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
			.FirstAsync(x => x.Id == originalStockDetail.Id);

			// 2. ãæ ¸å¿ä¿®æ£ãéªè¯ååºåæç»æ°æ®
			// éè¦ï¼æååååºåçææå¼ = åéæ°é (å ä¸ºèªå¨æåæ¶ï¼ååºååºåªä¿çåéæ°é)
			decimal expectedOriginalStockQty = lockInfo.AssignQuantity; // åºè¯¥æ¯120ï¼èä¸æ¯ç¨è®¡ç®

			_logger.LogInformation($"åºåéªè¯åºå:");
			_logger.LogInformation($" æååååºå: {originalStockQtyBeforeSplit}");
			_logger.LogInformation($" åéæ°é: {lockInfo.AssignQuantity}");
			_logger.LogInformation($" æåæ°é: {splitQuantity}");
			_logger.LogInformation($" ææååºå: {expectedOriginalStockQty}");
			_logger.LogInformation($" å®éååºå: {refreshedStockDetail.StockQuantity}");

			// åè®¸å°éè¯¯å·®çéªè¯
			if (Math.Abs(refreshedStockDetail.StockQuantity - expectedOriginalStockQty) > 0.01m)
			{
			// é¢å¤æ£æ¥ï¼å¦æååºåæ°éä¸åçï¼å¯è½æ¯æ°æ®é®é¢
			if (refreshedStockDetail.StockQuantity < 0)
			{
			string error = $"ååºåæ°éå¼å¸¸ï¼è´æ°ï¼ï¼å®é: {refreshedStockDetail.StockQuantity}";
			validationErrors.Add(error);
			allValid = false;
			_logger.LogError(error);
			}
			else if (refreshedStockDetail.StockQuantity > originalStockQtyBeforeSplit)
			{
			string error = $"ååºåæ°éå¼å¸¸ï¼å¤§äºæååï¼ï¼æåå: {originalStockQtyBeforeSplit}, å½å: {refreshedStockDetail.StockQuantity}";
			validationErrors.Add(error);
			allValid = false;
			_logger.LogError(error);
			}
			else
			{
			// å¯è½æ¯åççè¯¯å·®ï¼è®°å½è¦åä½ä¸æ è®°ä¸ºå¤±è´¥
			_logger.LogWarning($"ååºåæ°éä¸ææå¼æå·®å¼ï¼ææ: {expectedOriginalStockQty}, å®é: {refreshedStockDetail.StockQuantity}");
			}
			}

			// éªè¯ååºåçåºåºæ°éæ¯å¦ä¿æä¸å
			if (Math.Abs(refreshedStockDetail.OutboundQuantity - originalStockDetail.OutboundQuantity) > 0.01m)
			{
			string error = $"ååºååºåºæ°éä¸åºååï¼æåå: {originalStockDetail.OutboundQuantity}, æåå: {refreshedStockDetail.OutboundQuantity}";
			validationErrors.Add(error);
			allValid = false;
			_logger.LogError(error);
			}

			// 3. éªè¯æ°åºåæç»ï¼æåäº§ççï¼
			// æ¥æ¾æ°æ¡ç ï¼éè¿æåè®°å½ï¼
			var splitRecords = await _splitPackageService.Db.Queryable<Dt_SplitPackageRecord>()
			.Where(x => x.OutStockLockInfoId == lockInfo.Id &&
			!x.IsReverted &&
			x.IsAutoSplit == true)
			.OrderByDescending(x => x.SplitTime)
			.ToListAsync();

			if (splitRecords.Any())
			{
			var latestSplit = splitRecords.First();
			if (!string.IsNullOrEmpty(latestSplit.NewBarcode))
			{
			var newStockDetail = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
			.FirstAsync(x => x.Barcode == latestSplit.NewBarcode && x.StockId == originalStockDetail.StockId);

			if (newStockDetail != null)
			{
			// æ°åºåçææå¼ = æåæ°é
			decimal expectedNewStockQty = splitQuantity;

			_logger.LogInformation($"æ°åºåéªè¯:");
			_logger.LogInformation($" æ°æ¡ç : {newStockDetail.Barcode}");
			_logger.LogInformation($" æææ°é: {expectedNewStockQty}");
			_logger.LogInformation($" å®éæ°é: {newStockDetail.StockQuantity}");
			_logger.LogInformation($" åºåºæ°é: {newStockDetail.OutboundQuantity} (åºä¸º0)");

			if (Math.Abs(newStockDetail.StockQuantity - expectedNewStockQty) > 0.01m)
			{
			string error = $"æ°åºåæ°éä¸æ£ç¡®ï¼ææ: {expectedNewStockQty}, å®é: {newStockDetail.StockQuantity}";
			validationErrors.Add(error);
			allValid = false;
			_logger.LogError(error);
			}

			// æ°åºååºåºæ°éåºä¸º0
			if (Math.Abs(newStockDetail.OutboundQuantity - 0) > 0.01m)
			{
			string error = $"æ°åºååºåºæ°éä¸ä¸º0ï¼å®é: {newStockDetail.OutboundQuantity}";
			validationErrors.Add(error);
			allValid = false;
			_logger.LogError(error);
			}
			}
			}
			}

			// 4. éªè¯æªåééå®è®°å½
			var unallocatedLocks = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
			.Where(x => x.ParentLockId == lockInfo.Id &&
			x.IsUnallocated == 1 &&
			x.OrderDetailId == 0)
			.ToListAsync();

			if (!unallocatedLocks.Any())
			{
			string error = $"æªæ¾å°èªå¨æååå»ºçæªåééå®è®°å½";
			validationErrors.Add(error);
			allValid = false;
			_logger.LogError(error);
			}

			// 5. éªè¯è®¢åæç»æ°æ®æªæ¹å
			if (Math.Abs(refreshedOrderDetail.AllocatedQuantity - orderDetail.AllocatedQuantity) > 0.01m)
			{
			string error = $"è®¢åæç»åéæ°éå¼å¸¸ååï¼æåå: {orderDetail.AllocatedQuantity}, æåå: {refreshedOrderDetail.AllocatedQuantity}";
			validationErrors.Add(error);
			allValid = false;
			_logger.LogError(error);
			}

			// 6. éªè¯åéå®è®°å½æ°æ®æªæ¹åï¼åéæ°éä¸åï¼
			if (Math.Abs(refreshedLockInfo.AssignQuantity - lockInfo.AssignQuantity) > 0.01m)
			{
			string error = $"éå®è®°å½åéæ°éå¼å¸¸ååï¼æåå: {lockInfo.AssignQuantity}, æåå: {refreshedLockInfo.AssignQuantity}";
			validationErrors.Add(error);
			allValid = false;
			_logger.LogError(error);
			}

			// 7. ãæ°å¢ãéªè¯æ»åºåå®æ
			// æååæ»åºå = ååºåæ°é
			// æååæ»åºå = ååºåç°ææ°é + æ°åºåæ°é
			decimal totalStockAfterSplit = refreshedStockDetail.StockQuantity;
			if (splitRecords.Any() && !string.IsNullOrEmpty(splitRecords.First().NewBarcode))
			{
			var newStock = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
			.FirstAsync(x => x.Barcode == splitRecords.First().NewBarcode);
			if (newStock != null)
			{
			totalStockAfterSplit += newStock.StockQuantity;
			}
			}

			_logger.LogInformation($"åºåå®æéªè¯:");
			_logger.LogInformation($" æååæ»åºå: {originalStockQtyBeforeSplit}");
			_logger.LogInformation($" æååæ»åºå: {totalStockAfterSplit}");
			_logger.LogInformation($" å·®å¼: {originalStockQtyBeforeSplit - totalStockAfterSplit}");

			// åè®¸å¾å°çæµ®ç¹æ°è¯¯å·®
			if (Math.Abs(originalStockQtyBeforeSplit - totalStockAfterSplit) > 0.02m)
			{
			string error = $"åºåä¸å®æï¼æåå: {originalStockQtyBeforeSplit}, æååæ»åºå: {totalStockAfterSplit}";
			validationErrors.Add(error);
			allValid = false;
			_logger.LogError(error);
			}

			// æ±æ»éªè¯ç»æ
			if (allValid)
			{
			_logger.LogInformation($"â èªå¨æååéªè¯å¨é¨éè¿");
			}
			else
			{
			string errorSummary = $"èªå¨æååéªè¯å¤±è´¥ï¼åç°{validationErrors.Count}ä¸ªé®é¢ï¼" +
			string.Join("; ", validationErrors.Take(3));
			_logger.LogError(errorSummary);

			// è®°å½è¯¦ç»é®é¢å°æ¥å¿
			for (int i = 0; i < validationErrors.Count; i++)
			{
			_logger.LogError($"é®é¢{i + 1}: {validationErrors[i]}");
			}
			}

			return allValid;
			}
			catch (Exception ex)
			{
			_logger.LogError($"èªå¨æååéªè¯å¼å¸¸: {ex.Message}");
			return false;
			}
			}


			/// <summary>
			/// æ£éåéªè¯
			/// </summary>
			private async Task ValidateAfterPicking(string orderNo, string palletCode, string barcode, decimal pickedQty)
			{
			try
			{
			_logger.LogInformation($"å¼å§æ£éåéªè¯");

			// 1. éªè¯åºåæç»
			var stockDetail = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
			.FirstAsync(x => x.Barcode == barcode);

			// 2. æ¥æ¾è¯¥æ¡ç çæææ£éè®°å½
			var pickingRecords = await Db.Queryable<Dt_PickingRecord>()
			.Where(x => x.Barcode == barcode && x.OrderNo == orderNo && !x.IsCancelled)
			.ToListAsync();

			decimal totalPickedFromRecords = pickingRecords.Sum(x => x.PickQuantity);

			_logger.LogInformation($"æ£ééªè¯ - æ¡ç : {barcode}");
			_logger.LogInformation($" åºååºåºæ°é: {stockDetail.OutboundQuantity}");
			_logger.LogInformation($" æ£éè®°å½æ»å: {totalPickedFromRecords}");

			if (Math.Abs(stockDetail.OutboundQuantity - totalPickedFromRecords) > 0.01m)
			{
			_logger.LogError($"æ£éæ°æ®ä¸ä¸è´ï¼åºååºåºæ°é({stockDetail.OutboundQuantity}) â æ£éè®°å½æ»å({totalPickedFromRecords})");

			// èªå¨ä¿®å¤ï¼ä»¥æ£éè®°å½æ»åä¸ºå
			decimal originalOutbound = stockDetail.OutboundQuantity;
			stockDetail.OutboundQuantity = totalPickedFromRecords;
			await _stockInfoDetailService.Db.Updateable(stockDetail).ExecuteCommandAsync();

			_logger.LogWarning($"å·²èªå¨ä¿®å¤åºåºæ°é: {originalOutbound} -> {totalPickedFromRecords}");
			}

			_logger.LogInformation($"æ£éåéªè¯å®æ");
			}
			catch (Exception ex)
			{
			_logger.LogError($"æ£éåéªè¯å¤±è´¥: {ex.Message}");
			}
			}


			/// <summary>
			/// åæ¶åæ£
			/// </summary>
			@@ -368,12 +662,13 @@
			#region åèµ°ç©ºç®±é»è¾



			/// <summary>
			/// éªè¯ç©ºç®±åèµ°æ¡ä»¶
			/// éªè¯ç©ºç®±åèµ°æ¡ä»¶
			/// </summary>
			private async Task<ValidationResult<List<Dt_OutStockLockInfo>>> ValidateEmptyPalletRemoval(string orderNo, string palletCode)
			{
			_logger.LogInformation($"å¼å§éªè¯ç©ºæçåèµ° - è®¢å: {orderNo}, æç: {palletCode}");

			// è·åæççææéå®è®°å½
			var lockInfos = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
			.Where(x => x.OrderNo == orderNo && x.PalletCode == palletCode)
			@@ -382,7 +677,33 @@
			if (!lockInfos.Any())
			return ValidationResult<List<Dt_OutStockLockInfo>>.Error("è¯¥æçæ²¡æéå®è®°å½");

			// æ£æ¥æ¯å¦ææªå®æçéå®è®°å½
			// è·ååºåä¿¡æ¯
			var stockInfo = await _stockInfoService.Db.Queryable<Dt_StockInfo>()
			.FirstAsync(x => x.PalletCode == palletCode);

			if (stockInfo == null)
			{
			_logger.LogWarning($"æªæ¾å°æççåºåä¿¡æ¯ï¼å¯è½å·²è¢«æ¸ç");
			// å¦ææ¾ä¸å°åºåä¿¡æ¯ï¼åªæ£æ¥éå®è®°å½
			}
			else
			{
			// æ£æ¥æçä¸æ¯å¦è¿æåºåè´§ç©
			var remainingStock = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
			.Where(x => x.StockId == stockInfo.Id &&
			x.StockQuantity > 0) // åªæ£æ¥æ°éå¤§äº0çåºå
			.ToListAsync();

			if (remainingStock.Any())
			{
			var remainingQty = remainingStock.Sum(x => x.StockQuantity);
			var barcodes = string.Join(", ", remainingStock.Select(x => x.Barcode).Take(5)); // åªæ¾ç¤ºå5ä¸ª
			return ValidationResult<List<Dt_OutStockLockInfo>>.Error(
			$"æçä¸è¿æåºåè´§ç©ï¼æ°é{remainingQty}ï¼æ¡ç : {barcodes}ï¼ä¸è½åèµ°ç©ºç®±");
			}
			}

			// æ£æ¥æ¯å¦ææªå®æçéå®è®°å½ï¼ç¶æä¸ºåºåºä¸æååºä¸ï¼
			var unfinishedLocks = lockInfos.Where(x =>
			x.Status == (int)OutLockStockStatusEnum.åºåºä¸ \|\|
			x.Status == (int)OutLockStockStatusEnum.ååºä¸).ToList();
			@@ -395,35 +716,19 @@
			$"æçè¿æ{unfinishedCount}æ¡æªå®æè®°å½ï¼å©ä½æ°é{unfinishedQty}ï¼ä¸è½åèµ°ç©ºç®±");
			}

			// æ£æ¥æçä¸æ¯å¦è¿æåºåè´§ç©
			var stockInfo = await _stockInfoService.Db.Queryable<Dt_StockInfo>()
			.FirstAsync(x => x.PalletCode == palletCode);

			if (stockInfo != null)
			{
			var remainingStock = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
			.Where(x => x.StockId == stockInfo.Id &&
			x.Status == (int)StockStatusEmun.åºåºéå® &&
			x.StockQuantity > 0)
			.ToListAsync();

			if (remainingStock.Any())
			{
			var remainingQty = remainingStock.Sum(x => x.StockQuantity);
			return ValidationResult<List<Dt_OutStockLockInfo>>.Error(
			$"æçä¸è¿æåºåè´§ç©ï¼æ°é{remainingQty}ï¼ä¸è½åèµ°ç©ºç®±");
			}
			}

			// è·åå·²å®æçéå®è®°å½
			// è·åå·²å®æçéå®è®°å½ï¼ç¶æä¸ºæ£éå®ææå·²åèµ°ï¼
			var completedLocks = lockInfos.Where(x =>
			x.Status == (int)OutLockStockStatusEnum.æ£éå®æ).ToList();
			x.Status == (int)OutLockStockStatusEnum.æ£éå®æ \|\|
			x.Status == (int)OutLockStockStatusEnum.å·²åèµ°).ToList();

			if (!completedLocks.Any())
			return ValidationResult<List<Dt_OutStockLockInfo>>.Error("è¯¥æçæ²¡æå·²å®ææ£éçè®°å½");

			_logger.LogInformation($"ç©ºæçéªè¯éè¿ - æ¾å° {completedLocks.Count} æ¡å·²å®æè®°å½");

			return ValidationResult<List<Dt_OutStockLockInfo>>.Success(completedLocks);
			}


			/// <summary>
			/// æ¸çå·²å®æçéå®è®°å½
			@@ -442,21 +747,86 @@
			}
			}


			/// <summary>
			/// æ¸çåºåä¿¡æ¯
			/// æ¸çåºåä¿¡æ¯ - å®æ´ä¿®æ£ç
			/// ç¡®ä¿OutboundQuantityæ£ç¡®æ¸é¶
			/// </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 && stockDetail.Status == (int)StockStatusEmun.åºåºå®æ)
			try
			{
			stockDetail.Status = (int)StockStatusEmun.å·²æ¸ç;
			await _stockInfoDetailService.Db.Updateable(stockDetail).ExecuteCommandAsync();
			_logger.LogInformation($"æ¸çåºåä¿¡æ¯ - éå®ID: {lockInfo.Id}, æ¡ç : {lockInfo.CurrentBarcode}");

			// æ¥æ¾éå®çåºåæç»
			var stockDetail = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
			.FirstAsync(x => x.Barcode == lockInfo.CurrentBarcode && x.StockId == lockInfo.StockId);

			if (stockDetail != null)
			{
			// è®°å½æ¸çåçç¶æ
			decimal originalStockQty = stockDetail.StockQuantity;
			decimal originalOutboundQty = stockDetail.OutboundQuantity;
			int originalStatus = stockDetail.Status;

			_logger.LogInformation($"æ¸çåç¶æ - åºå: {originalStockQty}, åºåº: {originalOutboundQty}, ç¶æ: {GetStockStatusName(originalStatus)}");

			// ãéè¦ãæ£æ¥åºåæ°éæ¯å¦åºè¯¥ä¸º0
			// å¦æéå®ç¶ææ¯æ£éå®æï¼çè®ºä¸åºååºè¯¥ä¸º0
			if (lockInfo.Status == (int)OutLockStockStatusEnum.æ£éå®æ)
			{
			if (stockDetail.StockQuantity > 0)
			{
			_logger.LogWarning($"æ£éå®æä½åºåä¸ä¸º0 - æ¡ç : {stockDetail.Barcode}, åºå: {stockDetail.StockQuantity}");
			}
			}

			// æ¸çåºåååºåºæ°é
			stockDetail.StockQuantity = 0;
			stockDetail.OutboundQuantity = 0; // ãä¿®æ£ãç¡®ä¿åºåºæ°éæ¸é¶
			stockDetail.Status = (int)StockStatusEmun.å·²æ¸ç;

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

			_logger.LogInformation($"æ¸çåºåæç»å®æ");
			_logger.LogInformation($" åºåæ°é: {originalStockQty} -> 0");
			_logger.LogInformation($" åºåºæ°é: {originalOutboundQty} -> 0");
			_logger.LogInformation($" ç¶æ: {GetStockStatusName(originalStatus)} -> å·²æ¸ç");
			}
			else
			{
			_logger.LogWarning($"æªæ¾å°æ¡ç å¯¹åºçåºåæç»: {lockInfo.CurrentBarcode}");
			}

			// æ¸çè¯¥æçä¸çææåºåï¼é¿åéæ¼ï¼
			var allStockDetails = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
			.Where(x => x.StockId == lockInfo.StockId && x.StockQuantity > 0)
			.ToListAsync();

			if (allStockDetails.Any())
			{
			_logger.LogInformation($"æ¸çæçä¸å¶ä»åºå - å± {allStockDetails.Count} æ¡è®°å½");

			foreach (var stock in allStockDetails)
			{
			decimal originalQty = stock.StockQuantity;
			decimal originalOutbound = stock.OutboundQuantity;

			stock.StockQuantity = 0;
			stock.OutboundQuantity = 0; // ãä¿®æ£ãç¡®ä¿åºåºæ°éæ¸é¶
			stock.Status = (int)StockStatusEmun.å·²æ¸ç;

			await _stockInfoDetailService.Db.Updateable(stock).ExecuteCommandAsync();
			_logger.LogInformation($"æ¸çéæ¼åºå - æ¡ç : {stock.Barcode}, åºå: {originalQty}->0, åºåº: {originalOutbound}->0");
			}
			}
			}
			catch (Exception ex)
			{
			_logger.LogError($"æ¸çåºåä¿¡æ¯å¤±è´¥ - éå®ID: {lockInfo.Id}, æ¡ç : {lockInfo.CurrentBarcode}, Error: {ex.Message}");
			// ä¸æåºå¼å¸¸ï¼ç»§ç»å¤çå¶ä»è®°å½
			}
			}


			/// <summary>
			/// æ´æ°è®¢åç¶æ
			@@ -492,17 +862,17 @@
			/// </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)
			};
			//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();
			//await Db.Insertable(removalRecord).ExecuteCommandAsync();
			}

			#endregion
			@@ -533,7 +903,6 @@
			}
			};
			}



			#region æå¨æå
			@@ -673,101 +1042,199 @@
			return lockInfos.Sum(x => x.AssignQuantity);
			}



			/// <summary>
			/// æ§è¡æå¨æåé»è¾ - å¢å¼ºåéæ°éæ§å¶
			/// æ§è¡æå¨æåé»è¾ - ä¿®å¤çæ¬
			/// </summary>
			private async Task<List<SplitResult>> ExecuteManualSplitLogic(Dt_OutStockLockInfo lockInfo, Dt_StockInfoDetail stockDetail,
			decimal splitQuantity, string palletCode)
			{
			_logger.LogInformation($"å¼å§æ§è¡æå¨æåé»è¾ - åæ¡ç : {stockDetail.Barcode}, æåæ°é: {splitQuantity}");

			// éªè¯æåæ°é
			if (lockInfo.AssignQuantity < splitQuantity)
			try
			{
			throw new InvalidOperationException($"æåæ°éè¶è¿éå®ä¿¡æ¯åéæ°éï¼æåæ°é: {splitQuantity}, åéæ°é: {lockInfo.AssignQuantity}");
			// éªè¯åºåæ°éæ¯å¦è¶³å¤
			decimal availableStock = stockDetail.StockQuantity;
			if (availableStock < splitQuantity)
			{
			throw new InvalidOperationException($"åºåä¸è¶³ï¼å½ååºå: {availableStock}, éè¦æå: {splitQuantity}");
			}

			// éªè¯æåæ°éä¸è½çäºæå¤§äºåéå®ä¿¡æ¯åéæ°é
			if (splitQuantity >= lockInfo.AssignQuantity)
			{
			throw new InvalidOperationException($"æåæ°éä¸è½çäºæå¤§äºåéå®ä¿¡æ¯åéæ°éï¼æåæ°é: {splitQuantity}, ååéæ°é: {lockInfo.AssignQuantity}");
			}

			// è®¡ç®å©ä½æ°é
			decimal remainQty = lockInfo.AssignQuantity - splitQuantity;

			// éªè¯å©ä½æ°éæ¯å¦åç
			if (remainQty <= 0)
			{
			throw new InvalidOperationException($"æååå©ä½æ°éå¿é¡»å¤§äº0ï¼å½åå©ä½: {remainQty}");
			}

			_logger.LogInformation($"æåè®¡ç® - ååéæ°é: {lockInfo.AssignQuantity}, æåæ°é: {splitQuantity}, å©ä½æ°é: {remainQty}");
			_logger.LogInformation($"ååºåä¿¡æ¯ - åºåæ°é: {stockDetail.StockQuantity}, åºåºæ°é: {stockDetail.OutboundQuantity}");

			// çææ°æ¡ç
			string newBarcode = await GenerateNewBarcode();
			_logger.LogInformation($"çææ°æ¡ç : {newBarcode}");

			// è®°å½æååçå³é®æ°æ®
			decimal originalLockAssignQty = lockInfo.AssignQuantity;
			decimal originalLockOrderQty = lockInfo.OrderQuantity;
			decimal originalStockQty = stockDetail.StockQuantity;
			decimal originalOutboundQty = stockDetail.OutboundQuantity;

			// ä¿®å¤ï¼è®¡ç®æ°åºåæç»çæ£ç¡®æ°é
			// æ°æ¡ç åºè¯¥åªææåæ°éï¼èä¸æ¯2å
			decimal newStockQuantity = splitQuantity;
			decimal originalRemainingStockQuantity = originalStockQty - splitQuantity;

			_logger.LogInformation($"æ°éåé - æ°æ¡ç æ°é: {newStockQuantity}, åæ¡ç å©ä½æ°é: {originalRemainingStockQuantity}");

			// åå»ºæ°åºåæç» - ä¿®å¤æ°éé®é¢
			var newStockDetail = new Dt_StockInfoDetail
			{
			StockId = stockDetail.StockId,
			MaterielCode = stockDetail.MaterielCode,
			OrderNo = stockDetail.OrderNo,
			BatchNo = stockDetail.BatchNo,
			StockQuantity = newStockQuantity, // ä¿®å¤ï¼ä½¿ç¨æ£ç¡®çæåæ°é
			OutboundQuantity = 0, // æ°æ¡ç åå§åºåºæ°éä¸º0
			Barcode = newBarcode,
			Status = (int)StockStatusEmun.åºåºéå®,
			SupplyCode = stockDetail.SupplyCode,
			Unit = stockDetail.Unit,
			BarcodeQty = stockDetail.BarcodeQty,
			BarcodeUnit = stockDetail.BarcodeUnit,
			BusinessType = stockDetail.BusinessType,
			InboundOrderRowNo = stockDetail.InboundOrderRowNo,
			};

			await _stockInfoDetailService.Db.Insertable(newStockDetail).ExecuteCommandAsync();
			_logger.LogInformation($"åå»ºæ°åºåæç»æå - æ¡ç : {newBarcode}, åºåæ°é: {newStockQuantity}");

			// ä¿®æ£ï¼æ´æ°ååºåæç» - ç¡®ä¿æ°æ®ä¸è´æ§
			stockDetail.StockQuantity = originalRemainingStockQuantity;

			// ç¡®ä¿ä¸ä¼ä¸ºè´æ°
			if (stockDetail.StockQuantity < 0)
			{
			_logger.LogWarning($"ååºåæ°éåºç°è´æ°ï¼éç½®ä¸º0");
			stockDetail.StockQuantity = 0;
			}

			// åºåºæ°éä¿æä¸åï¼å ä¸ºæ¯æåï¼ä¸æ¯å®éåºåº
			// stockDetail.OutboundQuantity = stockDetail.OutboundQuantity;

			await _stockInfoDetailService.Db.Updateable(stockDetail).ExecuteCommandAsync();
			_logger.LogInformation($"æ´æ°ååºåæç» - æ¡ç : {stockDetail.Barcode}, " +
			$"åºåæ°é: {originalStockQty} -> {stockDetail.StockQuantity}, " +
			$"åºåºæ°é: {originalOutboundQty} -> {stockDetail.OutboundQuantity}");

			// åå»ºæ°éå®ä¿¡æ¯
			var newLockInfo = new Dt_OutStockLockInfo
			{
			OrderNo = lockInfo.OrderNo,
			OrderDetailId = lockInfo.OrderDetailId,
			OutboundBatchNo = lockInfo.OutboundBatchNo,
			MaterielCode = lockInfo.MaterielCode,
			MaterielName = lockInfo.MaterielName,
			StockId = lockInfo.StockId,
			OrderQuantity = splitQuantity,
			AssignQuantity = splitQuantity,
			PickedQty = 0,
			LocationCode = lockInfo.LocationCode,
			PalletCode = lockInfo.PalletCode,
			TaskNum = lockInfo.TaskNum,
			Status = (int)OutLockStockStatusEnum.åºåºä¸,
			Unit = lockInfo.Unit,
			SupplyCode = lockInfo.SupplyCode,
			OrderType = lockInfo.OrderType,
			CurrentBarcode = newBarcode,
			IsSplitted = 1,
			ParentLockId = lockInfo.Id,
			Operator = App.User.UserName,
			FactoryArea = lockInfo.FactoryArea,
			lineNo = lockInfo.lineNo,
			WarehouseCode = lockInfo.WarehouseCode,
			BarcodeQty = lockInfo.BarcodeQty,
			BarcodeUnit = lockInfo.BarcodeUnit,
			};

			await _outStockLockInfoService.Db.Insertable(newLockInfo).ExecuteCommandAsync();
			_logger.LogInformation($"åå»ºæ°éå®ä¿¡æ¯æå - æ¡ç : {newBarcode}, åéæ°é: {splitQuantity}");

			// æ´æ°åéå®ä¿¡æ¯
			lockInfo.AssignQuantity = remainQty;
			lockInfo.OrderQuantity = remainQty;

			await _outStockLockInfoService.Db.Updateable(lockInfo).ExecuteCommandAsync();
			_logger.LogInformation($"æ´æ°åéå®ä¿¡æ¯ - åéæ°é: {originalLockAssignQty} -> {lockInfo.AssignQuantity}, " +
			$"è®¢åæ°é: {originalLockOrderQty} -> {lockInfo.OrderQuantity}");

			// éªè¯æååæ°æ®ä¸è´æ§
			await ValidateDataConsistencyAfterSplit(lockInfo.OrderDetailId, originalLockAssignQty, originalLockOrderQty);

			// è®°å½æååå²
			await RecordSplitHistory(lockInfo, stockDetail, splitQuantity, newBarcode, false, originalStockQty);

			// åå»ºæåç»æåè¡¨
			var splitResults = CreateSplitResults(lockInfo, splitQuantity, remainQty, newBarcode, stockDetail.Barcode);

			_logger.LogInformation($"æå¨æåé»è¾æ§è¡å®æ - åæ¡ç : {stockDetail.Barcode}, æ°æ¡ç : {newBarcode}, æåæ°é: {splitQuantity}");

			return splitResults;
			}

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

			// è®¡ç®å©ä½æ°é
			decimal remainQty = lockInfo.AssignQuantity - splitQuantity;

			// åå»ºæ°åºåæç»
			var newStockDetail = new Dt_StockInfoDetail
			catch (Exception ex)
			{
			StockId = stockDetail.StockId,
			MaterielCode = stockDetail.MaterielCode,
			OrderNo = stockDetail.OrderNo,
			BatchNo = stockDetail.BatchNo,
			StockQuantity = splitQuantity,
			OutboundQuantity = 0,
			Barcode = newBarcode,
			Status = (int)StockStatusEmun.åºåºéå®,
			SupplyCode = stockDetail.SupplyCode,
			Unit = stockDetail.Unit,
			BarcodeQty = stockDetail.BarcodeQty,
			BarcodeUnit = stockDetail.BarcodeUnit,
			BusinessType = stockDetail.BusinessType,
			InboundOrderRowNo = stockDetail.InboundOrderRowNo,
			};
			await _stockInfoDetailService.Db.Insertable(newStockDetail).ExecuteCommandAsync();
			_logger.LogError($"æå¨æåé»è¾æ§è¡å¤±è´¥ - åæ¡ç : {stockDetail.Barcode}, æåæ°é: {splitQuantity}, Error: {ex.Message}");
			throw;
			}
			}

			// æ´æ°ååºåæç»
			stockDetail.StockQuantity -= splitQuantity;
			if (stockDetail.StockQuantity < 0) stockDetail.StockQuantity = 0;
			await _stockInfoDetailService.Db.Updateable(stockDetail).ExecuteCommandAsync();

			// åå»ºæ°éå®ä¿¡æ¯
			var newLockInfo = new Dt_OutStockLockInfo
			/// <summary>
			/// éªè¯æååè®¢åæç»çåéæ°éæ¯å¦ä¿æä¸å
			/// </summary>
			private async Task ValidateOrderDetailAllocationAfterSplit(long orderDetailId, decimal originalTotalAssignQty)
			{
			try
			{
			OrderNo = lockInfo.OrderNo,
			OrderDetailId = lockInfo.OrderDetailId, // ç»å®å°åä¸ä¸ªè®¢åæç»
			OutboundBatchNo = lockInfo.OutboundBatchNo,
			MaterielCode = lockInfo.MaterielCode,
			MaterielName = lockInfo.MaterielName,
			StockId = lockInfo.StockId,
			OrderQuantity = splitQuantity,
			AssignQuantity = splitQuantity,
			PickedQty = 0,
			LocationCode = lockInfo.LocationCode,
			PalletCode = lockInfo.PalletCode,
			TaskNum = lockInfo.TaskNum,
			Status = (int)OutLockStockStatusEnum.åºåºä¸,
			Unit = lockInfo.Unit,
			SupplyCode = lockInfo.SupplyCode,
			OrderType = lockInfo.OrderType,
			CurrentBarcode = newBarcode,
			IsSplitted = 1,
			ParentLockId = lockInfo.Id,
			Operator = App.User.UserName,
			FactoryArea = lockInfo.FactoryArea,
			lineNo = lockInfo.lineNo,
			WarehouseCode = lockInfo.WarehouseCode,
			BarcodeQty = lockInfo.BarcodeQty,
			BarcodeUnit = lockInfo.BarcodeUnit,
			};
			// è·åè®¢åæç»çææéå®ä¿¡æ¯çæ»åéæ°é
			var allLocks = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
			.Where(x => x.OrderDetailId == orderDetailId)
			.ToListAsync();

			await _outStockLockInfoService.Db.Insertable(newLockInfo).ExecuteCommandAsync();
			decimal totalLockAssignQty = allLocks.Sum(x => x.AssignQuantity);

			// æ´æ°åéå®ä¿¡æ¯
			lockInfo.AssignQuantity = remainQty;
			lockInfo.OrderQuantity = remainQty;
			await _outStockLockInfoService.Db.Updateable(lockInfo).ExecuteCommandAsync();
			_logger.LogInformation($"æåååéæ°ééªè¯ - è®¢åæç»ID: {orderDetailId}");
			_logger.LogInformation($"åå§æ»åéæ°é: {originalTotalAssignQty}, å½åæ»åéæ°é: {totalLockAssignQty}");

			// éè¦ï¼æå¨æåä¸æ¹åè®¢åæç»çæ»åéæ°é
			// å ä¸ºåéæ°éåªæ¯ä»ä¸ä¸ªéå®ä¿¡æ¯è½¬ç§»å°å¦ä¸ä¸ªéå®ä¿¡æ¯
			_logger.LogInformation($"æå¨æå - è®¢åæç»æ»åéæ°éä¿æä¸å");
			// æå¨æååæ»åéæ°éåºè¯¥ä¿æä¸å
			if (Math.Abs(originalTotalAssignQty - totalLockAssignQty) > 0.01m)
			{
			_logger.LogWarning($"æååæ»åéæ°éåçåå - ææ: {originalTotalAssignQty}, å®é: {totalLockAssignQty}");

			// è®°å½æååå²
			await RecordSplitHistory(lockInfo, stockDetail, splitQuantity, newBarcode, false);

			// åå»ºæåç»æåè¡¨
			var splitResults = CreateSplitResults(lockInfo, splitQuantity, remainQty, newBarcode, stockDetail.Barcode);

			_logger.LogInformation($"æå¨æåé»è¾æ§è¡å®æ");

			return splitResults;
			// å¦æååå¾å°ï¼å¯è½æ¯ç²¾åº¦é®é¢ï¼è®°å½ä½ä¸æåºå¼å¸¸
			if (Math.Abs(originalTotalAssignQty - totalLockAssignQty) > 1.0m)
			{
			throw new InvalidOperationException($"æååæ»åéæ°éå¼å¸¸ååï¼ææ: {originalTotalAssignQty}, å®é: {totalLockAssignQty}");
			}
			}
			else
			{
			_logger.LogInformation($"æåååéæ°ééªè¯éè¿ - æ»åéæ°éä¿æä¸å");
			}
			}
			catch (Exception ex)
			{
			_logger.LogError($"éªè¯æåååéæ°éå¤±è´¥ - OrderDetailId: {orderDetailId}, Error: {ex.Message}");
			throw;
			}
			}
			/// <summary>
			/// éªè¯æååæ°æ®ä¸è´æ§
			@@ -808,8 +1275,6 @@
			}
			}
			#endregion



			#region åæ¶æå

			@@ -867,6 +1332,45 @@
			{
			_logger.LogInformation($"å¼å§æ§è¡åæ¶æåé»è¾ - åæ¡ç : {splitRecord.OriginalBarcode}, æ°æ¡ç : {splitRecord.NewBarcode}, æåæ°é: {splitRecord.SplitQty}");

			try
			{
			// æ ¹æ®æåç±»åè°ç¨ä¸åçå¤çæ¹æ³
			if (splitRecord.IsAutoSplit)
			{
			await HandleAutoSplitCancel(splitRecord, originalLockInfo, newLockInfo, newStockDetail);
			}
			else
			{
			await HandleManualSplitCancel(splitRecord, originalLockInfo, newLockInfo, newStockDetail);
			}

			// éªè¯åæ¶æååæ°æ®ä¸è´æ§
			await ValidateDataConsistencyAfterCancelSplit(originalLockInfo.OrderDetailId,
			originalLockInfo.AssignQuantity, originalLockInfo.OrderQuantity,
			splitRecord.IsAutoSplit, splitRecord.SplitQty);

			// æ£æ¥å¹¶æ´æ°æ¹æ¬¡åè®¢åç¶æ
			await CheckAndUpdateBatchStatus(originalLockInfo.BatchNo);
			await CheckAndUpdateOrderStatus(originalLockInfo.OrderNo);

			_logger.LogInformation($"åæ¶æåé»è¾æ§è¡å®æ");
			}
			catch (Exception ex)
			{
			_logger.LogError($"åæ¶æåé»è¾æ§è¡å¤±è´¥: {ex.Message}");
			throw;
			}
			}

			/// <summary>
			/// å¤çèªå¨æååæ¶
			/// </summary>
			private async Task HandleAutoSplitCancel(Dt_SplitPackageRecord splitRecord,
			Dt_OutStockLockInfo originalLockInfo, Dt_OutStockLockInfo newLockInfo,
			Dt_StockInfoDetail newStockDetail)
			{
			_logger.LogInformation($"å¤çèªå¨æååæ¶ - åæ¡ç : {splitRecord.OriginalBarcode}, æ°æ¡ç : {splitRecord.NewBarcode}");

			// è·åè®¢åæç»
			var orderDetail = await _outboundOrderDetailService.Db.Queryable<Dt_OutboundOrderDetail>()
			.FirstAsync(x => x.Id == originalLockInfo.OrderDetailId);
			@@ -874,124 +1378,113 @@
			if (orderDetail == null)
			throw new InvalidOperationException("æªæ¾å°è®¢åæç»");

			// è®°å½åæ¶æååçå³é®æ°æ®
			decimal originalOrderDetailAllocatedQty = orderDetail.AllocatedQuantity;
			decimal originalOrderDetailLockQty = orderDetail.LockQuantity;
			// 1. æ¢å¤è®¢åæç»çåéæ°éï¼èªå¨æåä¼å¢å åéæ°éï¼
			decimal originalAllocatedQty = orderDetail.AllocatedQuantity;
			decimal originalLockQty = orderDetail.LockQuantity;

			_logger.LogInformation($"åæ¶æååæ°æ® - è®¢åæç»åéæ°é: {originalOrderDetailAllocatedQty}, éå®æ°é: {originalOrderDetailLockQty}");
			orderDetail.AllocatedQuantity -= splitRecord.SplitQty;
			orderDetail.LockQuantity -= splitRecord.SplitQty;

			// æ¢å¤åéå®ä¿¡æ¯
			decimal originalAssignQtyBefore = originalLockInfo.AssignQuantity;
			decimal originalOrderQtyBefore = originalLockInfo.OrderQuantity;
			// è¾¹çæ£æ¥
			if (orderDetail.AllocatedQuantity < 0) orderDetail.AllocatedQuantity = 0;
			if (orderDetail.LockQuantity < 0) orderDetail.LockQuantity = 0;

			// æ ¹æ®æåç±»åå³å®å¦ä½æ¢å¤
			if (splitRecord.IsAutoSplit)
			{
			// èªå¨æåï¼åéå®ä¿¡æ¯ä¿æä¸åï¼åªéè¦å é¤æ°éå®ä¿¡æ¯
			_logger.LogInformation($"åæ¶èªå¨æå - åéå®ä¿¡æ¯ä¿æä¸å");
			}
			else
			{
			// æå¨æåï¼æ¢å¤åéå®ä¿¡æ¯çåéæ°é
			originalLockInfo.AssignQuantity += splitRecord.SplitQty;
			originalLockInfo.OrderQuantity += splitRecord.SplitQty;
			await _outboundOrderDetailService.Db.Updateable(orderDetail).ExecuteCommandAsync();
			_logger.LogInformation($"èªå¨æååæ¶æ¢å¤è®¢åæç» - åéæ°é: {originalAllocatedQty} -> {orderDetail.AllocatedQuantity}");

			_logger.LogInformation($"åæ¶æå¨æå - æ¢å¤åéå®ä¿¡æ¯åéæ°éä» {originalAssignQtyBefore} å¢å å° {originalLockInfo.AssignQuantity}");
			}

			// å¦æåéå®ä¿¡æ¯çç¶ææ¯æ£éå®æï¼éè¦éæ°è®¾ç½®ä¸ºåºåºä¸
			if (originalLockInfo.Status == (int)OutLockStockStatusEnum.æ£éå®æ)
			{
			originalLockInfo.Status = (int)OutLockStockStatusEnum.åºåºä¸;
			_logger.LogInformation($"åéå®ä¿¡æ¯ç¶æä»æ£éå®ææ¢å¤ä¸ºåºåºä¸");
			}

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

			if (originalStock != null)
			{
			if (splitRecord.IsAutoSplit)
			decimal originalStockQty = originalStock.StockQuantity;
			originalStock.StockQuantity += splitRecord.SplitQty;

			// å¦æååºåç¶ææ¯åºåºå®æï¼æ¢å¤ä¸ºåºåºéå®
			if (originalStock.Status == (int)StockStatusEmun.åºåºå®æ)
			{
			// èªå¨æåï¼ååºåæç»ä¿æä¸å
			_logger.LogInformation($"åæ¶èªå¨æå - ååºåæç»ä¿æä¸å");
			originalStock.Status = (int)StockStatusEmun.åºåºéå®;
			}
			else
			{
			// æå¨æåï¼æ¢å¤ååºåæ°é
			decimal originalStockQtyBefore = originalStock.StockQuantity;
			originalStock.StockQuantity += splitRecord.SplitQty;

			_logger.LogInformation($"åæ¶æå¨æå - æ¢å¤ååºåæç»æ°éä» {originalStockQtyBefore} å¢å å° {originalStock.StockQuantity}");

			// å¦æååºåç¶ææ¯åºåºå®æï¼éè¦éæ°è®¾ç½®ä¸ºåºåºéå®
			if (originalStock.Status == (int)StockStatusEmun.åºåºå®æ)
			{
			originalStock.Status = (int)StockStatusEmun.åºåºéå®;
			_logger.LogInformation($"ååºåç¶æä»åºåºå®ææ¢å¤ä¸ºåºåºéå®");
			}

			await _stockInfoDetailService.Db.Updateable(originalStock).ExecuteCommandAsync();
			}
			await _stockInfoDetailService.Db.Updateable(originalStock).ExecuteCommandAsync();
			_logger.LogInformation($"èªå¨æååæ¶æ¢å¤ååºå - æ¡ç : {originalStock.Barcode}, æ°é: {originalStockQty} -> {originalStock.StockQuantity}");
			}

			// 3. å é¤æ°éå®ä¿¡æ¯ååºåæç»
			await DeleteNewSplitRecords(newLockInfo, newStockDetail);
			}

			/// <summary>
			/// å¤çæå¨æååæ¶
			/// </summary>
			private async Task HandleManualSplitCancel(Dt_SplitPackageRecord splitRecord,
			Dt_OutStockLockInfo originalLockInfo, Dt_OutStockLockInfo newLockInfo,
			Dt_StockInfoDetail newStockDetail)
			{
			_logger.LogInformation($"å¤çæå¨æååæ¶ - åæ¡ç : {splitRecord.OriginalBarcode}, æ°æ¡ç : {splitRecord.NewBarcode}");

			// 1. æ¢å¤åéå®ä¿¡æ¯çåéæ°é
			decimal originalAssignQty = originalLockInfo.AssignQuantity;
			decimal originalOrderQty = originalLockInfo.OrderQuantity;

			originalLockInfo.AssignQuantity += splitRecord.SplitQty;
			originalLockInfo.OrderQuantity += splitRecord.SplitQty;

			// æ¢å¤ç¶æ
			if (originalLockInfo.Status == (int)OutLockStockStatusEnum.æ£éå®æ)
			{
			originalLockInfo.Status = (int)OutLockStockStatusEnum.åºåºä¸;
			}

			await _outStockLockInfoService.Db.Updateable(originalLockInfo).ExecuteCommandAsync();
			_logger.LogInformation($"æå¨æååæ¶æ¢å¤åéå®ä¿¡æ¯ - åéæ°é: {originalAssignQty} -> {originalLockInfo.AssignQuantity}");

			// 2. æ¢å¤ååºåæç»
			var originalStock = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
			.FirstAsync(x => x.Barcode == splitRecord.OriginalBarcode && x.StockId == splitRecord.StockId);

			if (originalStock != null)
			{
			decimal originalStockQty = originalStock.StockQuantity;
			originalStock.StockQuantity += splitRecord.SplitQty;

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

			await _stockInfoDetailService.Db.Updateable(originalStock).ExecuteCommandAsync();
			_logger.LogInformation($"æå¨æååæ¶æ¢å¤ååºå - æ¡ç : {originalStock.Barcode}, æ°é: {originalStockQty} -> {originalStock.StockQuantity}");
			}

			// 3. å é¤æ°éå®ä¿¡æ¯ååºåæç»
			await DeleteNewSplitRecords(newLockInfo, newStockDetail);
			}

			/// <summary>
			/// å é¤æ°æåè®°å½ç¸å³çæ°æ®
			/// </summary>
			private async Task DeleteNewSplitRecords(Dt_OutStockLockInfo newLockInfo, Dt_StockInfoDetail newStockDetail)
			{
			// å é¤æ°éå®ä¿¡æ¯
			_logger.LogInformation($"å é¤æ°éå®ä¿¡æ¯ - æ¡ç : {newLockInfo.CurrentBarcode}, åéæ°é: {newLockInfo.AssignQuantity}");
			await _outStockLockInfoService.Db.Deleteable<Dt_OutStockLockInfo>()
			.Where(x => x.Id == newLockInfo.Id)
			.ExecuteCommandAsync();
			if (newLockInfo != null)
			{
			_logger.LogInformation($"å é¤æ°éå®ä¿¡æ¯ - æ¡ç : {newLockInfo.CurrentBarcode}, åéæ°é: {newLockInfo.AssignQuantity}");
			await _outStockLockInfoService.Db.Deleteable<Dt_OutStockLockInfo>()
			.Where(x => x.Id == newLockInfo.Id)
			.ExecuteCommandAsync();
			}

			// å é¤æ°åºåæç»
			_logger.LogInformation($"å é¤æ°åºåæç» - æ¡ç : {newStockDetail.Barcode}, åºåæ°é: {newStockDetail.StockQuantity}");
			await _stockInfoDetailService.Db.Deleteable<Dt_StockInfoDetail>()
			.Where(x => x.Barcode == newLockInfo.CurrentBarcode)
			.ExecuteCommandAsync();

			// å¦ææ¯èªå¨æåï¼éè¦åå°è®¢åæç»çåéæ°éåéå®æ°é
			if (splitRecord.IsAutoSplit)
			if (newStockDetail != null)
			{
			decimal originalAllocatedBefore = orderDetail.AllocatedQuantity;
			decimal originalLockBefore = orderDetail.LockQuantity;

			orderDetail.AllocatedQuantity -= splitRecord.SplitQty;
			orderDetail.LockQuantity -= splitRecord.SplitQty;

			// è¾¹çæ£æ¥ï¼ç¡®ä¿æ°éä¸ä¼ä¸ºè´æ°
			if (orderDetail.AllocatedQuantity < 0)
			{
			_logger.LogWarning($"åéæ°éåºç°è´æ°ï¼éç½®ä¸º0ãåå¼: {orderDetail.AllocatedQuantity + splitRecord.SplitQty}, åå°: {splitRecord.SplitQty}");
			orderDetail.AllocatedQuantity = 0;
			}
			if (orderDetail.LockQuantity < 0)
			{
			_logger.LogWarning($"éå®æ°éåºç°è´æ°ï¼éç½®ä¸º0ãåå¼: {orderDetail.LockQuantity + splitRecord.SplitQty}, åå°: {splitRecord.SplitQty}");
			orderDetail.LockQuantity = 0;
			}

			await _outboundOrderDetailService.Db.Updateable(orderDetail).ExecuteCommandAsync();

			_logger.LogInformation($"åæ¶èªå¨æååå°è®¢åæç»æ°é - åéæ°éä» {originalAllocatedBefore} åå°å° {orderDetail.AllocatedQuantity}");
			_logger.LogInformation($"åæ¶èªå¨æååå°è®¢åæç»æ°é - éå®æ°éä» {originalLockBefore} åå°å° {orderDetail.LockQuantity}");
			_logger.LogInformation($"å é¤æ°åºåæç» - æ¡ç : {newStockDetail.Barcode}, åºåæ°é: {newStockDetail.StockQuantity}");
			await _stockInfoDetailService.Db.Deleteable<Dt_StockInfoDetail>()
			.Where(x => x.Barcode == newStockDetail.Barcode)
			.ExecuteCommandAsync();
			}

			// æ è®°æåè®°å½ä¸ºå·²æ¤é
			splitRecord.IsReverted = true;
			splitRecord.RevertTime = DateTime.Now;
			splitRecord.RevertOperator = App.User.UserName;
			await _splitPackageService.Db.Updateable(splitRecord).ExecuteCommandAsync();
			_logger.LogInformation($"æ è®°æåè®°å½ä¸ºå·²æ¤é");

			// éªè¯åæ¶æååæ°æ®ä¸è´æ§
			await ValidateDataConsistencyAfterCancelSplit(orderDetail.Id, originalOrderDetailAllocatedQty, originalOrderDetailLockQty, splitRecord.IsAutoSplit, splitRecord.SplitQty);

			// æ£æ¥å¹¶æ´æ°æ¹æ¬¡åè®¢åç¶æ
			await CheckAndUpdateBatchStatus(originalLockInfo.BatchNo);
			await CheckAndUpdateOrderStatus(originalLockInfo.OrderNo);

			_logger.LogInformation($"åæ¶æåé»è¾æ§è¡å®æ");
			}
			/// <summary>
			/// éªè¯åæ¶æååæ°æ®ä¸è´æ§ - ææ°çæ¬
			@@ -1679,45 +2172,93 @@

			return totalQty;
			}


			/// <summary>
			/// ç»ä¸ååºæ¹æ³ - å¤çæçä¸ææå©ä½è´§ç©
			/// ç»ä¸ååºæ¹æ³
			/// </summary>
			public async Task<WebResponseContent> ExecutePalletReturn(string orderNo, string palletCode, string returnReason = "åæ¹ååº")
			{
			try
			{
			_logger.LogInformation($"ãå¢å¼ºååºå¼å§ãè®¢å: {orderNo}, æç: {palletCode}");

			_unitOfWorkManage.BeginTran();

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

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

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

			int stockId = stockInfo.Id;

			// æ§è¡ååºåæ°æ®éªè¯
			var validationResult = await ValidateDataBeforeReturn(orderNo, palletCode, stockId);
			if (!validationResult.IsValid)
			{
			_logger.LogWarning($"ååºåæ°æ®éªè¯å¤±è´¥: {validationResult.ErrorMessage}");
			// å¯ä»¥æ ¹æ®å®éæåµå³å®æ¯å¦ç»§ç»
			}

			// åææçç¶æ
			var statusAnalysis = await AnalyzePalletStatusForReturn(orderNo, palletCode, stockInfo.Id);

			if (!statusAnalysis.HasItemsToReturn)
			return await HandleEmptyPalletReturn(orderNo, palletCode, stockInfo);
			{
			try
			{
			_logger.LogInformation($"ãæ ååºç©åãå¤çç©ºæç");
			var result = await HandleEmptyPalletReturn(orderNo, palletCode, stockInfo);
			_unitOfWorkManage.CommitTran();
			return result;
			}
			catch (Exception ex)
			{
			_unitOfWorkManage.RollbackTran();
			_logger.LogError($"ç©ºç®±ååºå¤±è´¥: {ex.Message}");
			return WebResponseContent.Instance.Error($"ç©ºç®±ååºå¤±è´¥ï¼{ex.Message}");
			}
			}

			_logger.LogInformation($"å¼å§ååºæä½ - è®¢å: {orderNo}, æç: {palletCode}, ååºæ°é: {statusAnalysis.TotalReturnQty}");
			_logger.LogInformation($"ãå¼å§ååºãæ»ååºæ°é: {statusAnalysis.TotalReturnQty}, æ¡ç æ°: {statusAnalysis.AllBarcodes.Count}");

			// æ§è¡ååºæ°æ®æä½
			await ExecuteReturnDataOperations(statusAnalysis);
			// æ§è¡ååºæä½
			try
			{
			await ExecuteEnhancedReturnOperations(statusAnalysis);
			}
			catch (Exception ex)
			{
			_logger.LogError($"ä¸»ååºæ¹æ³å¤±è´¥: {ex.Message}");
			// å°è¯ç®åæ¹æ³
			await ExecuteSimpleReturnDataOperations(statusAnalysis);
			}

			// æ´æ°è®¢åç¶æ
			// æ´æ°è®¢åç¶æ
			await UpdateOrderStatusAfterReturn(orderNo);



			// åå»ºååºä»»å¡
			try
			{
			await CreateReturnTask(orderNo, palletCode, stockInfo);
			}
			catch (Exception taskEx)
			{
			_logger.LogError($"ååºä»»å¡åå»ºå¤±è´¥: {taskEx.Message}");
			// ä»»å¡åå»ºå¤±è´¥ä¸å½±åæ°æ®ååº
			}
			_unitOfWorkManage.CommitTran();
			// 8. ååºåéªè¯
			await ValidateDataAfterReturn(orderNo, palletCode, stockId);

			// åå»ºååºä»»å¡ï¼AGVï¼
			await CreateReturnTask(orderNo, palletCode, stockInfo);

			return WebResponseContent.Instance.OK($"ååºæä½æåï¼å±ååºæ°éï¼{statusAnalysis.TotalReturnQty}", new
			return WebResponseContent.Instance.OK($"ååºæåï¼ååºæ°éï¼{statusAnalysis.TotalReturnQty}", new
			{
			ReturnQuantity = statusAnalysis.TotalReturnQty,
			ReturnBarcodes = statusAnalysis.AllBarcodes,
			@@ -1729,13 +2270,910 @@
			catch (Exception ex)
			{
			_unitOfWorkManage.RollbackTran();
			_logger.LogError($"ååºæä½å¤±è´¥ - OrderNo: {orderNo}, PalletCode: {palletCode}, Error: {ex.Message}");
			return WebResponseContent.Instance.Error($"ååºæä½å¤±è´¥: {ex.Message}");
			_logger.LogError($"ååºå¤±è´¥: {ex.Message}");
			return WebResponseContent.Instance.Error($"ååºå¤±è´¥ï¼{ex.Message}");
			}
			}

			/// <summary>
			/// å¢å¼ºçååºåæ°æ®éªè¯
			/// </summary>
			private async Task<ValidationResult<bool>> ValidateDataBeforeReturn(string orderNo, string palletCode, int stockId)
			{
			var errors = new List<string>();

			try
			{
			// 1. éªè¯åºåæ°æ®
			var stockDetails = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
			.Where(x => x.StockId == stockId)
			.ToListAsync();

			// æ£æ¥åºåæ°éæ¯å¦ä¸ºè´æ°
			var negativeStocks = stockDetails.Where(x => x.StockQuantity < 0).ToList();
			if (negativeStocks.Any())
			{
			errors.Add($"åç°è´æ°åºå: {string.Join(", ", negativeStocks.Select(x => $"{x.Barcode}:{x.StockQuantity}"))}");
			}

			// 2. éªè¯éå®è®°å½
			var lockInfos = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
			.Where(x => x.OrderNo == orderNo && x.PalletCode == palletCode)
			.ToListAsync();

			// æ£æ¥å·²æ£éæ°éæ¯å¦å¤§äºåéæ°é
			var invalidLocks = lockInfos.Where(x => x.PickedQty > x.AssignQuantity).ToList();
			if (invalidLocks.Any())
			{
			errors.Add($"åç°å·²æ£éæ°éå¤§äºåéæ°éçéå®è®°å½");
			}

			// 3. éªè¯æåè®°å½
			var splitRecords = await _splitPackageService.Db.Queryable<Dt_SplitPackageRecord>()
			.Where(x => x.OrderNo == orderNo && x.PalletCode == palletCode)
			.ToListAsync();

			// æ£æ¥å¾ªç¯æå
			var barcodeMap = new Dictionary<string, string>();
			foreach (var record in splitRecords.Where(x => !x.IsReverted))
			{
			if (!barcodeMap.ContainsKey(record.OriginalBarcode))
			barcodeMap[record.OriginalBarcode] = record.NewBarcode;
			}

			// æ£æ¥å¾ªç¯å¼ç¨
			foreach (var record in splitRecords)
			{
			var current = record.OriginalBarcode;
			var visited = new HashSet<string>();

			while (barcodeMap.ContainsKey(current))
			{
			if (visited.Contains(current))
			{
			errors.Add($"åç°å¾ªç¯æåå¼ç¨: {record.OriginalBarcode}");
			break;
			}
			visited.Add(current);
			current = barcodeMap[current];
			}
			}

			if (errors.Any())
			{
			return ValidationResult<bool>.Error($"ååºåæ°æ®éªè¯åç°é®é¢: {string.Join("; ", errors)}");
			}

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

			// <summary>
			/// æ§è¡å¢å¼ºçååºæä½ - ä¿®æ£çï¼é¿åéå¤å¤çï¼
			/// </summary>
			private async Task ExecuteEnhancedReturnOperations(PalletStatusAnalysis statusAnalysis)
			{
			_logger.LogInformation($"ãå¼å§æ§è¡ååºæä½ãè®¢å: {statusAnalysis.OrderNo}, æç: {statusAnalysis.PalletCode}");

			// ä½¿ç¨æ¬å°å·²å¤çéåï¼é¿åéå¤
			var locallyProcessedBarcodes = new HashSet<string>();
			decimal totalProcessedQty = 0;

			// 1. å¤çå·²åéçéå®è®°å½
			if (statusAnalysis.HasRemainingLocks)
			{
			_logger.LogInformation($"å¤çå·²åééå®è®°å½ - {statusAnalysis.RemainingLocks.Count} æ¡");
			foreach (var lockInfo in statusAnalysis.RemainingLocks)
			{
			if (string.IsNullOrEmpty(lockInfo.CurrentBarcode) \|\|
			locallyProcessedBarcodes.Contains(lockInfo.CurrentBarcode))
			{
			_logger.LogInformation($"è·³è¿å·²å¤çæ¡ç çéå®è®°å½: {lockInfo.CurrentBarcode}");
			continue;
			}

			decimal returnQty = lockInfo.AssignQuantity - lockInfo.PickedQty;
			if (returnQty > 0)
			{
			// ãä¿®å¤ãä¼ é isUnallocated = false
			await ProcessSingleBarcodeReturn(lockInfo.CurrentBarcode, statusAnalysis.StockId, returnQty, false);
			locallyProcessedBarcodes.Add(lockInfo.CurrentBarcode);
			totalProcessedQty += returnQty;
			_logger.LogInformation($"å·²å¤çéå®è®°å½ - æ¡ç : {lockInfo.CurrentBarcode}, æ°é: {returnQty}");
			}
			}
			}

			// 2. å¤çæªåéçéå®è®°å½
			if (statusAnalysis.HasUnallocatedLocks)
			{
			_logger.LogInformation($"å¤çæªåééå®è®°å½ - {statusAnalysis.UnallocatedLocks.Count} æ¡");
			foreach (var lockInfo in statusAnalysis.UnallocatedLocks)
			{
			if (string.IsNullOrEmpty(lockInfo.CurrentBarcode) \|\|
			locallyProcessedBarcodes.Contains(lockInfo.CurrentBarcode))
			{
			_logger.LogInformation($"è·³è¿å·²å¤çæ¡ç çæªåééå®: {lockInfo.CurrentBarcode}");
			continue;
			}

			decimal returnQty = lockInfo.AssignQuantity - lockInfo.PickedQty;
			if (returnQty > 0)
			{
			// ãä¿®å¤ãä½¿ç¨ä¸é¨çæªåééå®å¤çæ¹æ³
			await ProcessUnallocatedLockReturn(lockInfo, returnQty);
			locallyProcessedBarcodes.Add(lockInfo.CurrentBarcode);
			totalProcessedQty += returnQty;
			_logger.LogInformation($"å·²å¤çæªåééå® - æ¡ç : {lockInfo.CurrentBarcode}, æ°é: {returnQty}");
			}
			}
			}

			// 3. å¤çæªåéçåºåè´§ç©
			if (statusAnalysis.HasPalletStockGoods)
			{
			_logger.LogInformation($"å¤çæªåéåºåè´§ç© - {statusAnalysis.PalletStockGoods.Count} ä¸ª");
			foreach (var stockDetail in statusAnalysis.PalletStockGoods)
			{
			if (string.IsNullOrEmpty(stockDetail.Barcode) \|\|
			locallyProcessedBarcodes.Contains(stockDetail.Barcode))
			{
			_logger.LogInformation($"è·³è¿å·²å¤çæ¡ç çåºå: {stockDetail.Barcode}");
			continue;
			}

			decimal returnQty = stockDetail.StockQuantity;
			if (returnQty > 0)
			{
			await ProcessUnallocatedStockReturn(stockDetail);
			locallyProcessedBarcodes.Add(stockDetail.Barcode);
			totalProcessedQty += returnQty;
			_logger.LogInformation($"å·²å¤çæªåéåºå - æ¡ç : {stockDetail.Barcode}, æ°é: {returnQty}");
			}
			}
			}

			// 4. ãä¿®æ£ãå¤çæåè®°å½ - åªå¤çæªè¢«å¶ä»é»è¾è¦ççæ¡ç
			if (statusAnalysis.HasSplitRecords && statusAnalysis.SplitReturnQty > 0)
			{
			_logger.LogInformation($"å¤çæåè®°å½ç¸å³åºå - æ°å¢æ°é: {statusAnalysis.SplitReturnQty}");

			// åªå¤çå¨SplitRecordsä¸ä½ä¸å¨å·²å¤çéåä¸çæ¡ç
			var splitBarcodes = statusAnalysis.SplitRecords
			.SelectMany(r => new[] { r.OriginalBarcode, r.NewBarcode })
			.Where(b => !string.IsNullOrEmpty(b))
			.Distinct()
			.ToList();

			foreach (var barcode in splitBarcodes)
			{
			if (locallyProcessedBarcodes.Contains(barcode))
			{
			_logger.LogInformation($"è·³è¿å·²å¤ççæåæ¡ç : {barcode}");
			continue;
			}

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

			if (stockDetail != null && stockDetail.StockQuantity > 0)
			{
			decimal returnQty = stockDetail.StockQuantity;
			await ProcessSingleBarcodeReturn(barcode, statusAnalysis.StockId, returnQty);
			locallyProcessedBarcodes.Add(barcode);
			totalProcessedQty += returnQty;
			_logger.LogInformation($"å¤çæåæ¡ç - {barcode}, æ°é: {returnQty}");
			}
			}
			}

			_logger.LogInformation($"ãååºæä½å®æãæ»å¤çæ°é: {totalProcessedQty}, å¤çæ¡ç æ°: {locallyProcessedBarcodes.Count}");

			// éªè¯å¤çæ°éä¸é¢æä¸è´
			if (Math.Abs(totalProcessedQty - statusAnalysis.TotalReturnQty) > 0.01m)
			{
			_logger.LogWarning($"å¤çæ°é({totalProcessedQty})ä¸é¢æ({statusAnalysis.TotalReturnQty})ä¸ä¸è´ï¼ä½ç»§ç»æ§è¡");
			}
			}


			/// <summary>
			/// å¤çå·²åééå®è®°å½çååº
			/// å·²åééå®è®°å½éè¦ï¼1.æ¢å¤åºå 2.æ´æ°éå®ç¶æ 3.åå°è®¢åæç»åéæ°é
			/// </summary>
			private async Task ProcessSingleLockReturn(Dt_OutStockLockInfo lockInfo, decimal returnQty)
			{
			try
			{
			_logger.LogInformation($"å¼å§å¤çå·²åééå®è®°å½ååº - éå®ID: {lockInfo.Id}, æ¡ç : {lockInfo.CurrentBarcode}, ååºæ°é: {returnQty}");

			if (returnQty <= 0)
			{
			_logger.LogInformation($"ååºæ°éæ æ({returnQty})ï¼è·³è¿å¤ç");
			return;
			}

			// 1. éªè¯éå®è®°å½ç¶æ
			if (lockInfo.Status != (int)OutLockStockStatusEnum.åºåºä¸ &&
			lockInfo.Status != (int)OutLockStockStatusEnum.ååºä¸)
			{
			_logger.LogWarning($"éå®è®°å½ç¶æä¸æ¯åºåºä¸æååºä¸ï¼è·³è¿å¤ç - ç¶æ: {lockInfo.Status}");
			return;
			}

			// 2. è·åå³èçåºåæç»
			var stockDetail = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
			.FirstAsync(x => x.Barcode == lockInfo.CurrentBarcode && x.StockId == lockInfo.StockId);

			if (stockDetail == null)
			{
			_logger.LogError($"æªæ¾å°åºåæç» - æ¡ç : {lockInfo.CurrentBarcode}, StockId: {lockInfo.StockId}");
			throw new InvalidOperationException($"åºåæç»ä¸åå¨: {lockInfo.CurrentBarcode}");
			}

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

			if (orderDetail == null)
			{
			_logger.LogError($"æªæ¾å°è®¢åæç» - OrderDetailId: {lockInfo.OrderDetailId}");
			throw new InvalidOperationException($"è®¢åæç»ä¸åå¨: {lockInfo.OrderDetailId}");
			}

			// è®°å½åå§å¼ï¼ç¨äºæ¥å¿ååæ»æ£æ¥ï¼
			decimal originalStockQty = stockDetail.StockQuantity;
			decimal originalOutboundQty = stockDetail.OutboundQuantity;
			int originalStockStatus = stockDetail.Status;

			decimal originalAllocatedQty = orderDetail.AllocatedQuantity;
			decimal originalLockQty = orderDetail.LockQuantity;
			decimal originalOverOutQty = orderDetail.OverOutQuantity;

			decimal originalLockPickedQty = lockInfo.PickedQty;
			decimal originalLockAssignQty = lockInfo.AssignQuantity;
			int originalLockStatus = lockInfo.Status;

			_logger.LogInformation($"ååºåæ°æ®ç¶æ:");
			_logger.LogInformation($" åºå - æ¡ç : {stockDetail.Barcode}, æ°é: {originalStockQty}, åºåº: {originalOutboundQty}, ç¶æ: {GetStockStatusName(originalStockStatus)}");
			_logger.LogInformation($" è®¢åæç» - åé: {originalAllocatedQty}, éå®: {originalLockQty}, å·²åºåº: {originalOverOutQty}");
			_logger.LogInformation($" éå®è®°å½ - åé: {originalLockAssignQty}, å·²æ£é: {originalLockPickedQty}, ç¶æ: {GetLockStatusName(originalLockStatus)}");

			// 4. ãæ ¸å¿é»è¾ãæ¢å¤åºåæ°æ®
			// 4.1 å¢å åºåæ°é
			stockDetail.StockQuantity += returnQty;

			// 4.2 åå°åºåºæ°éï¼ä½éç¡®ä¿ä¸ä¼åºç°è´æ°ï¼
			if (stockDetail.OutboundQuantity >= returnQty)
			{
			stockDetail.OutboundQuantity -= returnQty;
			}
			else
			{
			// å¦æåºåºæ°éå°äºååºæ°éï¼è¯´ææ°æ®å¼å¸¸
			_logger.LogWarning($"åºåºæ°é({stockDetail.OutboundQuantity})å°äºååºæ°é({returnQty})ï¼æ°æ®å¼å¸¸");
			stockDetail.OutboundQuantity = 0;
			}

			// 4.3 æ´æ°åºåç¶æ
			if (stockDetail.OutboundQuantity <= 0 && stockDetail.StockQuantity > 0)
			{
			stockDetail.Status = (int)StockStatusEmun.å¥åºå®æ;
			_logger.LogInformation($"åºåç¶ææ´æ°ä¸º: å¥åºå®æ");
			}
			else if (stockDetail.StockQuantity > 0)
			{
			stockDetail.Status = (int)StockStatusEmun.åºåºéå®;
			_logger.LogInformation($"åºåç¶æä¿æä¸º: åºåºéå®");
			}

			await _stockInfoDetailService.Db.Updateable(stockDetail).ExecuteCommandAsync();
			_logger.LogInformation($"åºåæ´æ°å®æ - æ¡ç : {stockDetail.Barcode}");
			_logger.LogInformation($" åºåæ°é: {originalStockQty} -> {stockDetail.StockQuantity}");
			_logger.LogInformation($" åºåºæ°é: {originalOutboundQty} -> {stockDetail.OutboundQuantity}");
			_logger.LogInformation($" ç¶æ: {GetStockStatusName(originalStockStatus)} -> {GetStockStatusName(stockDetail.Status)}");

			// 5. æ´æ°éå®è®°å½ç¶æ
			lockInfo.Status = (int)OutLockStockStatusEnum.å·²ååº;
			lockInfo.Operator = App.User.UserName;

			// ãéè¦ãå¦æéå®è®°å½æ¯é¨åæ£éåååºï¼éè¦è°æ´å·²æ£éæ°é
			// ä½ä¸è¬æåµä¸ï¼ååºçæ¯æªæ£éçé¨åï¼æä»¥PickedQtyä¿æä¸å

			await _outStockLockInfoService.Db.Updateable(lockInfo).ExecuteCommandAsync();
			_logger.LogInformation($"éå®è®°å½æ´æ°å®æ - ID: {lockInfo.Id}");
			_logger.LogInformation($" ç¶æ: {GetLockStatusName(originalLockStatus)} -> {GetLockStatusName(lockInfo.Status)}");
			_logger.LogInformation($" åéæ°é: {originalLockAssignQty} (ä¸å)");
			_logger.LogInformation($" å·²æ£éæ°é: {originalLockPickedQty} (ä¸å)");

			// 6. æ´æ°è®¢åæç»æ°æ®
			// 6.1 åå°å·²åéæ°é
			if (orderDetail.AllocatedQuantity >= returnQty)
			{
			orderDetail.AllocatedQuantity -= returnQty;
			}
			else
			{
			// å¦æåéæ°éå°äºååºæ°éï¼è¯´ææ°æ®å¼å¸¸
			_logger.LogWarning($"åéæ°é({orderDetail.AllocatedQuantity})å°äºååºæ°é({returnQty})ï¼éç½®ä¸º0");
			orderDetail.AllocatedQuantity = 0;
			}

			// 6.2 åå°éå®æ°éï¼åºä¸åéæ°éä¿æåæ¥ï¼
			if (orderDetail.LockQuantity >= returnQty)
			{
			orderDetail.LockQuantity -= returnQty;
			}
			else
			{
			_logger.LogWarning($"éå®æ°é({orderDetail.LockQuantity})å°äºååºæ°é({returnQty})ï¼éç½®ä¸º0");
			orderDetail.LockQuantity = 0;
			}

			// 6.3 å·²åºåºæ°éä¿æä¸åï¼ååºä¸å½±åå·²åºåºæ°éï¼
			// orderDetail.OverOutQuantity = orderDetail.OverOutQuantity;

			// 6.4 æ´æ°æ¹æ¬¡åéç¶æ
			await UpdateBatchAllocateStatus(orderDetail);

			await _outboundOrderDetailService.Db.Updateable(orderDetail).ExecuteCommandAsync();
			_logger.LogInformation($"è®¢åæç»æ´æ°å®æ - ID: {orderDetail.Id}");
			_logger.LogInformation($" åéæ°é: {originalAllocatedQty} -> {orderDetail.AllocatedQuantity}");
			_logger.LogInformation($" éå®æ°é: {originalLockQty} -> {orderDetail.LockQuantity}");
			_logger.LogInformation($" å·²åºåºæ°é: {originalOverOutQty} (ä¿æä¸å)");

			// 7. éªè¯ååºåçæ°æ®ä¸è´æ§
			await ValidateAfterLockReturn(lockInfo, stockDetail, orderDetail, returnQty);

			_logger.LogInformation($"å·²åééå®è®°å½ååºå¤çå®æ - éå®ID: {lockInfo.Id}, ååºæ°é: {returnQty}");
			}
			catch (Exception ex)
			{
			_logger.LogError($"å¤çå·²åééå®è®°å½ååºå¤±è´¥ - éå®ID: {lockInfo.Id}, Error: {ex.Message}");
			throw new InvalidOperationException($"å¤çéå®è®°å½ååºå¤±è´¥: {ex.Message}", ex);
			}
			}

			/// <summary>
			/// éå®è®°å½ååºåéªè¯æ°æ®ä¸è´æ§
			/// </summary>
			private async Task ValidateAfterLockReturn(Dt_OutStockLockInfo lockInfo, Dt_StockInfoDetail stockDetail,
			Dt_OutboundOrderDetail orderDetail, decimal returnQty)
			{
			try
			{
			_logger.LogInformation($"å¼å§ååºåæ°æ®éªè¯ - éå®ID: {lockInfo.Id}");

			bool allValid = true;
			List<string> validationErrors = new List<string>();

			// 1. éæ°è·åææ°æ°æ®
			var refreshedStock = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
			.FirstAsync(x => x.Id == stockDetail.Id);

			var refreshedOrder = await _outboundOrderDetailService.Db.Queryable<Dt_OutboundOrderDetail>()
			.FirstAsync(x => x.Id == orderDetail.Id);

			var refreshedLock = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
			.FirstAsync(x => x.Id == lockInfo.Id);

			// 2. éªè¯åºåæ°æ®
			// è®¡ç®åºåæ°éåºè¯¥å¢å ååºæ°é
			decimal expectedStockQty = stockDetail.StockQuantity + returnQty;
			if (Math.Abs(refreshedStock.StockQuantity - expectedStockQty) > 0.01m)
			{
			string error = $"åºåæ°éä¸æ£ç¡®ï¼ææ: {expectedStockQty}, å®é: {refreshedStock.StockQuantity}";
			validationErrors.Add(error);
			allValid = false;
			_logger.LogError(error);
			}

			// éªè¯åºåç¶æåºä¸ºå¥åºå®ææåºåºéå®
			if (refreshedStock.Status != (int)StockStatusEmun.å¥åºå®æ &&
			refreshedStock.Status != (int)StockStatusEmun.åºåºéå®)
			{
			string error = $"åºåç¶æå¼å¸¸ï¼ææ:å¥åºå®ææåºåºéå®, å®é:{GetStockStatusName(refreshedStock.Status)}";
			validationErrors.Add(error);
			allValid = false;
			_logger.LogError(error);
			}

			// 3. éªè¯éå®è®°å½ç¶æ
			if (refreshedLock.Status != (int)OutLockStockStatusEnum.å·²ååº)
			{
			string error = $"éå®è®°å½ç¶æå¼å¸¸ï¼ææ:å·²ååº, å®é:{GetLockStatusName(refreshedLock.Status)}";
			validationErrors.Add(error);
			allValid = false;
			_logger.LogError(error);
			}

			// 4. éªè¯è®¢åæç»æ°æ®
			// è®¡ç®åéæ°éåºè¯¥åå°ååºæ°é
			decimal expectedAllocatedQty = Math.Max(0, orderDetail.AllocatedQuantity - returnQty);
			if (Math.Abs(refreshedOrder.AllocatedQuantity - expectedAllocatedQty) > 0.01m)
			{
			string error = $"è®¢ååéæ°éä¸æ£ç¡®ï¼ææ: {expectedAllocatedQty}, å®é: {refreshedOrder.AllocatedQuantity}";
			validationErrors.Add(error);
			allValid = false;
			_logger.LogError(error);
			}

			// åéæ°éåºä¸éå®æ°éä¸è´
			if (Math.Abs(refreshedOrder.AllocatedQuantity - refreshedOrder.LockQuantity) > 0.01m)
			{
			string error = $"è®¢ååéæ°éä¸éå®æ°éä¸ä¸è´ï¼åé: {refreshedOrder.AllocatedQuantity}, éå®: {refreshedOrder.LockQuantity}";
			validationErrors.Add(error);
			allValid = false;
			_logger.LogError(error);
			}

			// 5. æ°æ®å³èæ§éªè¯
			// éå®è®°å½çå·²æ£éæ°é + å½ååºåçåºåºæ°éåºçäºåå§åºåºæ°é
			decimal totalOutboundFromLock = refreshedLock.PickedQty + refreshedStock.OutboundQuantity;

			// æ¥æ¾è¯¥æ¡ç çæææªåæ¶æ£éè®°å½
			var pickingRecords = await Db.Queryable<Dt_PickingRecord>()
			.Where(x => x.Barcode == stockDetail.Barcode && !x.IsCancelled)
			.ToListAsync();

			decimal totalPickedFromRecords = pickingRecords.Sum(x => x.PickQuantity);

			if (Math.Abs(totalOutboundFromLock - totalPickedFromRecords) > 0.01m)
			{
			string error = $"æ°æ®å³èæ§å¼å¸¸ï¼éå®æ£é({refreshedLock.PickedQty})+åºååºåº({refreshedStock.OutboundQuantity})={totalOutboundFromLock}, ä½æ£éè®°å½æ»å={totalPickedFromRecords}";
			validationErrors.Add(error);
			allValid = false;
			_logger.LogError(error);
			}

			// 6. è¾åºéªè¯ç»æ
			if (allValid)
			{
			_logger.LogInformation($"ååºåæ°æ®éªè¯å¨é¨éè¿");
			}
			else
			{
			_logger.LogError($"ååºåæ°æ®éªè¯å¤±è´¥ï¼åç°{validationErrors.Count}ä¸ªé®é¢");
			foreach (var error in validationErrors.Take(3)) // åªæ¾ç¤ºå3ä¸ªé®é¢
			{
			_logger.LogError($"éªè¯é®é¢: {error}");
			}

			// å¦æé®é¢ä¸¥éï¼å¯ä»¥æåºå¼å¸¸
			if (validationErrors.Any(e => e.Contains("å¼å¸¸")))
			{
			throw new InvalidOperationException($"ååºåæ°æ®éªè¯å¤±è´¥: {string.Join("; ", validationErrors.Take(2))}");
			}
			}
			}
			catch (Exception ex)
			{
			_logger.LogError($"ååºåéªè¯å¼å¸¸: {ex.Message}");
			// ä¸éæ°æåºï¼é¿åå½±åä¸»æµç¨
			}
			}

			/// <summary>
			/// å¤çåä¸ªæ¡ç ååºï¼éç¨æ¹æ³ï¼- åºåå·²åéåæªåé
			/// </summary>
			private async Task ProcessSingleBarcodeReturn(string barcode, int stockId, decimal returnQty, bool isUnallocated = false)
			{
			try
			{
			_logger.LogInformation($"å¤çåä¸ªæ¡ç ååº - {barcode}, æ°é: {returnQty}, æ¯å¦æªåé: {isUnallocated}");

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

			if (stockDetail == null)
			{
			_logger.LogWarning($"æªæ¾å°åºåæç»: {barcode}");
			return;
			}

			decimal originalStockQty = stockDetail.StockQuantity;
			decimal originalOutboundQty = stockDetail.OutboundQuantity;
			int originalStatus = stockDetail.Status;

			_logger.LogInformation($"ååºåç¶æ - åºå: {originalStockQty}, åºåº: {originalOutboundQty}, ç¶æ: {GetStockStatusName(originalStatus)}");

			// ãä¿®å¤ãæ ¹æ®æ¯å¦æªåéå³å®å¤çé»è¾
			if (isUnallocated)
			{
			// æªåééå®ï¼åªæ¢å¤ç¶æï¼ä¸æ¹ååºåæ°é
			// åºåºæ°éåºä¸º0
			if (stockDetail.OutboundQuantity > 0)
			{
			_logger.LogWarning($"æªåééå®çåºååºåºæ°éä¸ä¸º0ï¼éç½®ä¸º0 - æ¡ç : {stockDetail.Barcode}, å½ååºåº: {stockDetail.OutboundQuantity}");
			stockDetail.OutboundQuantity = 0;
			}

			// åºåæ°éä¿æä¸å
			_logger.LogInformation($"æªåééå®ååº - åºåæ°éä¿æä¸å: {stockDetail.StockQuantity}");
			}
			else
			{
			// å·²åééå®ï¼æ¢å¤åºåæ°é
			stockDetail.StockQuantity += returnQty;

			// åå°åºåºæ°éï¼å¦æåºåºæ°éå¤§äº0ï¼
			if (stockDetail.OutboundQuantity >= returnQty)
			{
			stockDetail.OutboundQuantity -= returnQty;
			}
			else
			{
			// å¦æåºåºæ°éå°äºååºæ°éï¼è¯´ææ°æ®å¼å¸¸ï¼åºåºæ°éæ¸é¶
			_logger.LogWarning($"åºåºæ°é({stockDetail.OutboundQuantity})å°äºååºæ°é({returnQty})ï¼æ¸é¶");
			stockDetail.OutboundQuantity = 0;
			}

			_logger.LogInformation($"å·²åééå®ååº - åºåæ°éå¢å : {originalStockQty} -> {stockDetail.StockQuantity}");
			}

			// æ´æ°ç¶æ
			stockDetail.Status = (int)StockStatusEmun.å¥åºå®æ;

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

			_logger.LogInformation($"æ¡ç ååºå®æ - {barcode}: åºå {originalStockQty}->{stockDetail.StockQuantity}, åºåº {originalOutboundQty}->{stockDetail.OutboundQuantity}");
			}
			catch (Exception ex)
			{
			_logger.LogError($"å¤çæ¡ç ååºå¤±è´¥ - {barcode}: {ex.Message}");
			throw;
			}
			}
			/// <summary>
			/// æ§è¡ååºæ°æ®æä½
			/// ç¡®ä¿ä¸ä¼å°çæçæ¡ç æ°ééè¯¯ç»å®å°éå®æ°é
			/// å¤çæªåééå®è®°å½ååº - ä¿®å¤çæ¬
			/// æªåééå®è®°å½ï¼åªæ¢å¤ç¶æï¼ä¸å¢å åºåæ°é
			/// </summary>
			private async Task ProcessUnallocatedLockReturn(Dt_OutStockLockInfo lockInfo, decimal returnQty)
			{
			_logger.LogInformation($"å¤çæªåééå®ååº - éå®ID: {lockInfo.Id}, æ¡ç : {lockInfo.CurrentBarcode}, æ°é: {returnQty}");

			try
			{
			// éªè¯éå®è®°å½ç¶æ
			if (lockInfo.Status != (int)OutLockStockStatusEnum.åºåºä¸ &&
			lockInfo.Status != (int)OutLockStockStatusEnum.ååºä¸)
			{
			_logger.LogWarning($"éå®è®°å½ç¶æä¸æ¯åºåºä¸æååºä¸ï¼è·³è¿å¤ç - ç¶æ: {lockInfo.Status}");
			return;
			}

			// ãä¿®å¤ãè·ååºåæç»
			var stockDetail = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
			.FirstAsync(x => x.Barcode == lockInfo.CurrentBarcode && x.StockId == lockInfo.StockId);

			if (stockDetail == null)
			{
			_logger.LogError($"æªæ¾å°åºåæç» - æ¡ç : {lockInfo.CurrentBarcode}, StockId: {lockInfo.StockId}");
			throw new InvalidOperationException($"åºåæç»ä¸åå¨: {lockInfo.CurrentBarcode}");
			}

			// è®°å½åå§ç¶æ
			decimal originalStockQty = stockDetail.StockQuantity;
			decimal originalOutboundQty = stockDetail.OutboundQuantity;
			int originalStatus = stockDetail.Status;

			_logger.LogInformation($"æªåééå®ååºåç¶æ:");
			_logger.LogInformation($" åºå - æ¡ç : {stockDetail.Barcode}, æ°é: {originalStockQty}, åºåº: {originalOutboundQty}, ç¶æ: {GetStockStatusName(originalStatus)}");

			// ãä¿®å¤å³é®ãå¯¹äºæªåééå®è®°å½ï¼åºåæ°éä¸åºæ¹åï¼
			// å ä¸ºåºåæ¬æ¥å°±åå¨ï¼åªæ¯ç¶æè¢«éå®
			// stockDetail.StockQuantity ä¿æä¸å

			// åºåºæ°éåºä¸º0ï¼æªåééå®ä¸åºè¯¥æåºåºï¼
			if (stockDetail.OutboundQuantity > 0)
			{
			_logger.LogWarning($"æªåééå®çåºååºåºæ°éä¸ä¸º0ï¼éç½®ä¸º0 - æ¡ç : {stockDetail.Barcode}, å½ååºåº: {stockDetail.OutboundQuantity}");
			stockDetail.OutboundQuantity = 0;
			}

			// æ´æ°åºåç¶æä¸ºå¥åºå®æï¼æ¢å¤ä¸ºå¯ç¨ç¶æï¼
			stockDetail.Status = (int)StockStatusEmun.å¥åºå®æ;

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

			_logger.LogInformation($"æ´æ°æªåéåºåç¶æ - æ¡ç : {stockDetail.Barcode}");
			_logger.LogInformation($" åºåæ°é: {originalStockQty} -> {stockDetail.StockQuantity} (ä¿æä¸å)");
			_logger.LogInformation($" åºåºæ°é: {originalOutboundQty} -> {stockDetail.OutboundQuantity}");
			_logger.LogInformation($" ç¶æ: {GetStockStatusName(originalStatus)} -> {GetStockStatusName(stockDetail.Status)}");

			// æ´æ°éå®è®°å½ç¶æä¸ºå·²ååº
			lockInfo.Status = (int)OutLockStockStatusEnum.å·²ååº;
			lockInfo.Operator = App.User.UserName;

			await _outStockLockInfoService.Db.Updateable(lockInfo).ExecuteCommandAsync();

			_logger.LogInformation($"æ´æ°æªåééå®ç¶æ - éå®ID: {lockInfo.Id}, ç¶æ: åºåºä¸ -> å·²ååº");
			}
			catch (Exception ex)
			{
			_logger.LogError($"å¤çæªåééå®ååºå¤±è´¥ - éå®ID: {lockInfo.Id}, Error: {ex.Message}");
			throw new InvalidOperationException($"å¤çæªåééå®ååºå¤±è´¥: {ex.Message}", ex);
			}
			}

			/// <summary>
			/// å¤çæªåéåºåååº
			/// </summary>
			private async Task ProcessUnallocatedStockReturn(Dt_StockInfoDetail stockDetail)
			{
			_logger.LogInformation($"å¤çæªåéåºåååº - æ¡ç : {stockDetail.Barcode}, æ°é: {stockDetail.StockQuantity}");

			// ç´æ¥æ´æ°åºåç¶æ
			stockDetail.Status = (int)StockStatusEmun.å¥åºå®æ;
			await _stockInfoDetailService.Db.Updateable(stockDetail).ExecuteCommandAsync();
			}


			/// <summary>
			/// ååºåæ°æ®éªè¯ - å¢å¼ºç
			/// </summary>
			private async Task ValidateDataAfterReturn(string orderNo, string palletCode, int stockId)
			{
			try
			{
			_logger.LogInformation($"å¼å§ååºåæ°æ®éªè¯");

			// 1. éªè¯åºåç¶æåæ°é
			var stockDetails = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
			.Where(x => x.StockId == stockId)
			.ToListAsync();

			decimal totalStock = stockDetails.Sum(x => x.StockQuantity);

			// éªè¯åºåæ°éæ¯å¦åç
			var unreasonableStocks = stockDetails.Where(x => x.StockQuantity < 0).ToList();
			if (unreasonableStocks.Any())
			{
			_logger.LogError($"åç°è´æ°åºåæ°éï¼æ¡ç : {string.Join(", ", unreasonableStocks.Select(x => x.Barcode))}");
			}

			// 2. éªè¯éå®è®°å½ç¶æ
			var lockInfos = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
			.Where(x => x.OrderNo == orderNo && x.PalletCode == palletCode)
			.ToListAsync();

			var notReturnedLocks = lockInfos.Where(x =>
			x.Status != (int)OutLockStockStatusEnum.å·²ååº &&
			x.Status != (int)OutLockStockStatusEnum.å·²åèµ° &&
			x.Status != (int)OutLockStockStatusEnum.æ£éå®æ).ToList();

			if (notReturnedLocks.Any())
			{
			_logger.LogWarning($"ååºåä»ææªååºç¶æçéå®è®°å½: {notReturnedLocks.Count}æ¡");
			foreach (var lockInfo in notReturnedLocks)
			{
			_logger.LogWarning($"æªååºéå® - ID: {lockInfo.Id}, ç¶æ: {GetLockStatusName(lockInfo.Status)}, æ¡ç : {lockInfo.CurrentBarcode}");
			}
			}

			// 3. æ°æ®ä¸è´æ§éªè¯
			decimal totalExpectedReturnQty = lockInfos
			.Where(x => x.Status == (int)OutLockStockStatusEnum.å·²ååº)
			.Sum(x => x.AssignQuantity - x.PickedQty);

			_logger.LogInformation($"ååºéªè¯æ±æ»:");
			_logger.LogInformation($" ååºååºåæ»é: {totalStock}");
			_logger.LogInformation($" å·²ååºéå®è®°å½æ°é: {lockInfos.Count(x => x.Status == (int)OutLockStockStatusEnum.å·²ååº)}");
			_logger.LogInformation($" æ»ååºæ°éï¼éå®è®°å½è®¡ç®ï¼: {totalExpectedReturnQty}");

			// 4. éªè¯åºåæ°éä¸éå®è®°å½çä¸è´æ§
			foreach (var lockInfo in lockInfos.Where(x => !string.IsNullOrEmpty(x.CurrentBarcode)))
			{
			var stock = stockDetails.FirstOrDefault(x => x.Barcode == lockInfo.CurrentBarcode);
			if (stock != null)
			{
			// å¦æéå®è®°å½æ¯å·²ååºç¶æï¼å¯¹åºçåºååºè¯¥æ¯å¥åºå®æç¶æ
			if (lockInfo.Status == (int)OutLockStockStatusEnum.å·²ååº &&
			stock.Status != (int)StockStatusEmun.å¥åºå®æ)
			{
			_logger.LogWarning($"éå®è®°å½å·²ååºä½åºåç¶æä¸æ£ç¡® - æ¡ç : {lockInfo.CurrentBarcode}, åºåç¶æ: {GetStockStatusName(stock.Status)}");
			}
			}
			}

			_logger.LogInformation($"ååºåæ°æ®éªè¯å®æ");
			}
			catch (Exception ex)
			{
			_logger.LogError($"ååºåéªè¯å¤±è´¥: {ex.Message}");
			}
			}

			/// <summary>
			/// éªè¯ååºååæ°æ®ä¸è´æ§
			/// </summary>
			private async Task<bool> ValidateReturnData(string orderNo, string palletCode, int stockId, bool isBefore = true)
			{
			string phase = isBefore ? "ååºå" : "ååºå";
			try
			{

			_logger.LogInformation($"ã{phase}æ°æ®éªè¯ãå¼å§ - è®¢å: {orderNo}, æç: {palletCode}");

			// 1. æ£æ¥åºåæç»
			var stockDetails = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
			.Where(x => x.StockId == stockId)
			.ToListAsync();

			decimal totalStockQty = stockDetails.Sum(x => x.StockQuantity);
			_logger.LogInformation($"{phase}åºåæ»é: {totalStockQty}");

			// 2. æ£æ¥éå®è®°å½
			var lockInfos = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
			.Where(x => x.OrderNo == orderNo && x.PalletCode == palletCode)
			.ToListAsync();

			// æ£æ¥éå®è®°å½ç¶æåå¸
			var statusGroups = lockInfos.GroupBy(x => x.Status)
			.Select(g => new { Status = g.Key, Count = g.Count() })
			.ToList();

			foreach (var group in statusGroups)
			{
			_logger.LogInformation($"{phase}éå®ç¶æ {GetLockStatusName(group.Status)}: {group.Count} æ¡");
			}

			// 3. åºæ¬éªè¯
			bool isValid = true;

			// éªè¯1: å¦æéå®è®°å½ç¶æä¸º"æ£éå®æ"ï¼å¯¹åºåºååºè¯¥ä¸º0
			var completedLocks = lockInfos.Where(x => x.Status == (int)OutLockStockStatusEnum.æ£éå®æ).ToList();
			foreach (var lockInfo in completedLocks)
			{
			if (!string.IsNullOrEmpty(lockInfo.CurrentBarcode))
			{
			var stock = stockDetails.FirstOrDefault(x => x.Barcode == lockInfo.CurrentBarcode);
			if (stock != null && stock.StockQuantity > 0)
			{
			_logger.LogWarning($"{phase}éªè¯è¦å - éå®ID {lockInfo.Id} æ£éå®æä½åºåä¸ä¸º0: {stock.StockQuantity}");
			}
			}
			}

			// éªè¯2: åºåç¶æä¸è´æ§
			foreach (var stock in stockDetails)
			{
			if (stock.Status == (int)StockStatusEmun.åºåºéå® && stock.StockQuantity == 0)
			{
			_logger.LogWarning($"{phase}éªè¯è¦å - æ¡ç {stock.Barcode} ç¶æä¸ºåºåºéå®ä½åºåä¸º0");
			}
			}

			_logger.LogInformation($"ã{phase}æ°æ®éªè¯ãå®æ - ç¶æ: {(isValid ? "éè¿" : "æè¦å")}");
			return isValid;
			}
			catch (Exception ex)
			{
			_logger.LogError($"{phase} æ°æ®éªè¯å¤±è´¥: {ex.Message}");
			return false;
			}
			}

			private string GetLockStatusName(int status)
			{
			return status switch
			{
			1 => "åºåºä¸",
			2 => "æ£éå®æ",
			3 => "å·²ååº",
			4 => "å·²åèµ°",
			_ => $"æªç¥({status})"
			};
			}

			/// <summary>
			/// ç®åååºæ°æ®æä½ï¼å½ä¸»æ¹æ³å¤±è´¥æ¶ä½¿ç¨ï¼
			/// </summary>
			private async Task ExecuteSimpleReturnDataOperations(PalletStatusAnalysis statusAnalysis)
			{
			_logger.LogInformation($"ãç®åååºãå¼å§æ§è¡ç®åååºæä½");

			try
			{
			// è·åè¯¥æççæææ¡ç ï¼åæ¬ææç¶æçåºåï¼
			var allStockDetails = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
			.Where(x => x.StockId == statusAnalysis.StockId)
			.ToListAsync();

			_logger.LogInformation($"æ¾å° {allStockDetails.Count} ä¸ªåºåæç»è®°å½");

			foreach (var stockDetail in allStockDetails)
			{
			// è®°å½åå§ç¶æ
			int originalStatus = stockDetail.Status;
			decimal originalStockQty = stockDetail.StockQuantity;

			// å°ææåºåºç¸å³çç¶ææ¢å¤ä¸ºå¥åºå®æ
			if (stockDetail.Status == (int)StockStatusEmun.åºåºéå® \|\|
			//stockDetail.Status == (int)StockStatusEmun.åºåºä¸ \|\|
			stockDetail.Status == (int)StockStatusEmun.åºåºå®æ)
			{
			// å¦ææ¯åºåºå®æç¶æä¸åºåä¸º0ï¼å¯è½éè¦ç¹æ®å¤ç
			if (stockDetail.Status == (int)StockStatusEmun.åºåºå®æ && stockDetail.StockQuantity == 0)
			{
			_logger.LogInformation($"è·³è¿å·²åºåºå®æçé¶åºåæ¡ç : {stockDetail.Barcode}");
			continue;
			}

			stockDetail.Status = (int)StockStatusEmun.å¥åºå®æ;

			// å¦ææ¯åºåºéå®ç¶æä½åºåä¸º0ï¼éç½®åºåä¸º1ï¼é¿åé¶åºåé®é¢ï¼
			if (stockDetail.Status == (int)StockStatusEmun.åºåºéå® && stockDetail.StockQuantity == 0)
			{
			// æ¥æ¾æ¯å¦æå¯¹åºçéå®è®°å½æ¥ç¡®å®åºè¯¥æ¢å¤çæ°é
			var lockInfo = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
			.Where(x => x.CurrentBarcode == stockDetail.Barcode &&
			x.StockId == stockDetail.StockId)
			.FirstAsync();

			if (lockInfo != null)
			{
			stockDetail.StockQuantity = lockInfo.AssignQuantity - lockInfo.PickedQty;
			_logger.LogInformation($"æ¢å¤é¶åºåæ¡ç çæ°é - æ¡ç : {stockDetail.Barcode}, æ°é: {stockDetail.StockQuantity}");
			}
			}

			await _stockInfoDetailService.Db.Updateable(stockDetail).ExecuteCommandAsync();
			_logger.LogInformation($"ç®åååº - æ¡ç : {stockDetail.Barcode}, ç¶æ: {GetStockStatusName(originalStatus)} -> å¥åºå®æ, æ°é: {originalStockQty} -> {stockDetail.StockQuantity}");
			}
			}

			// æ´æ°ææéå®è®°å½ä¸ºå·²ååº
			var allLocks = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
			.Where(x => x.OrderNo == statusAnalysis.OrderNo &&
			x.PalletCode == statusAnalysis.PalletCode &&
			(x.Status == (int)OutLockStockStatusEnum.åºåºä¸ \|\|
			x.Status == (int)OutLockStockStatusEnum.æ£éå®æ))
			.ToListAsync();

			foreach (var lockInfo in allLocks)
			{
			lockInfo.Status = (int)OutLockStockStatusEnum.å·²ååº;
			lockInfo.Operator = App.User.UserName;

			await _outStockLockInfoService.Db.Updateable(lockInfo).ExecuteCommandAsync();
			_logger.LogInformation($"ç®åååº - éå®è®°å½: {lockInfo.Id}, ç¶æ: å·²ååº");
			}

			_logger.LogInformation($"ãç®åååºãå®æ - å¤ç {allStockDetails.Count} ä¸ªæ¡ç , {allLocks.Count} æ¡éå®è®°å½");
			}
			catch (Exception ex)
			{
			_logger.LogError($"ç®åååºå¤±è´¥: {ex.Message}");
			throw;
			}
			}

			/// <summary>
			/// è·ååºåç¶æåç§°
			/// </summary>
			private string GetStockStatusName(int status)
			{
			return status switch
			{
			1 => "å¥åºç¡®è®¤",
			2 => "å¥åºå®æ",
			3 => "åºåºéå®",
			4 => "åºåºä¸",
			5 => "åºåºå®æ",
			6 => "å·²æ¸ç",
			_ => $"æªç¥({status})"
			};
			}


			/// <summary>
			/// æ§è¡ååºæ°æ®æä½ - ç®åçæ¬
			/// </summary>
			private async Task ExecuteReturnDataOperations(PalletStatusAnalysis statusAnalysis)
			{
			@@ -1743,28 +3181,142 @@

			try
			{
			// ä½¿ç¨ HashSet é¿åéå¤å¤çæ¡ç
			var processedBarcodes = new HashSet<string>();
			decimal totalReturnedQty = 0;

			// 1. å¤çå·²åéçæªåæ£éå®è®°å½
			if (statusAnalysis.HasRemainingLocks)
			{
			_logger.LogInformation($"å¤ç {statusAnalysis.RemainingLocks.Count} æ¡å·²åéæªåæ£éå®è®°å½");
			await HandleAllocatedLocksReturn(statusAnalysis.RemainingLocks);

			foreach (var lockInfo in statusAnalysis.RemainingLocks)
			{
			if (string.IsNullOrEmpty(lockInfo.CurrentBarcode) \|\| processedBarcodes.Contains(lockInfo.CurrentBarcode))
			{
			_logger.LogInformation($"è·³è¿éå¤æç©ºæ¡ç çéå®è®°å½ - ID: {lockInfo.Id}");
			continue;
			}

			// è®¡ç®ååºæ°éï¼æªæ£éçé¨åï¼
			decimal returnQty = lockInfo.AssignQuantity - lockInfo.PickedQty;

			if (returnQty > 0)
			{
			_logger.LogInformation($"å¤çéå®è®°å½ååº - ID: {lockInfo.Id}, æ¡ç : {lockInfo.CurrentBarcode}, ååºæ°é: {returnQty}");

			// å¤çåºå
			await ProcessStockForReturn(lockInfo.CurrentBarcode, statusAnalysis.StockId, returnQty);

			// æ è®°ä¸ºå·²ååº
			lockInfo.Status = (int)OutLockStockStatusEnum.å·²ååº;
			lockInfo.Operator = App.User.UserName;


			await _outStockLockInfoService.Db.Updateable(lockInfo).ExecuteCommandAsync();

			// åå°è®¢åæç»çåéæ°é
			if (lockInfo.OrderDetailId > 0)
			{
			var orderDetail = await _outboundOrderDetailService.Db.Queryable<Dt_OutboundOrderDetail>().FirstAsync(x => x.Id == lockInfo.OrderDetailId);
			await ReduceOrderDetailAllocation(orderDetail, returnQty);
			}

			processedBarcodes.Add(lockInfo.CurrentBarcode);
			totalReturnedQty += returnQty;

			_logger.LogInformation($"éå®è®°å½ååºå®æ - ID: {lockInfo.Id}, ååºæ°é: {returnQty}");
			}
			else
			{
			_logger.LogInformation($"éå®è®°å½æ éååº - ID: {lockInfo.Id}, å·²æ£éå®æ");
			}
			}
			}

			// 2. å¤çæªåéçéå®è®°å½ï¼å¦èªå¨æåäº§ççï¼
			if (statusAnalysis.HasUnallocatedLocks)
			{
			_logger.LogInformation($"å¤ç {statusAnalysis.UnallocatedLocks.Count} æ¡æªåééå®è®°å½");
			await HandleUnallocatedLocksReturn(statusAnalysis.UnallocatedLocks);
			}

			// 3. å¤çæªåéçåºåè´§ç©
			// 2. å¤çæªåéçåºåè´§ç©
			if (statusAnalysis.HasPalletStockGoods)
			{
			_logger.LogInformation($"å¤ç {statusAnalysis.PalletStockGoods.Count} ä¸ªæªåéåºåè´§ç©");
			await HandleUnallocatedStockReturn(statusAnalysis.PalletStockGoods);

			foreach (var stockDetail in statusAnalysis.PalletStockGoods)
			{
			if (string.IsNullOrEmpty(stockDetail.Barcode) \|\| processedBarcodes.Contains(stockDetail.Barcode))
			{
			_logger.LogInformation($"è·³è¿éå¤æç©ºæ¡ç çåºå - åºåID: {stockDetail.Id}");
			continue;
			}

			if (stockDetail.StockQuantity > 0)
			{
			decimal returnQty = stockDetail.StockQuantity;
			_logger.LogInformation($"å¤çæªåéåºåååº - æ¡ç : {stockDetail.Barcode}, ååºæ°é: {returnQty}");

			// ç´æ¥æ¢å¤åºåç¶æ
			stockDetail.Status = (int)StockStatusEmun.å¥åºå®æ;

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

			processedBarcodes.Add(stockDetail.Barcode);
			totalReturnedQty += returnQty;

			_logger.LogInformation($"æªåéåºåååºå®æ - æ¡ç : {stockDetail.Barcode}, æ°é: {returnQty}");
			}
			}
			}

			_logger.LogInformation($"ååºæ°æ®æä½å®æ - æ»ååºæ°é: {statusAnalysis.TotalReturnQty}");
			// 3. å¤çæåè®°å½ç¸å³çæ¡ç
			if (statusAnalysis.HasSplitRecords)
			{
			_logger.LogInformation($"å¤ç {statusAnalysis.SplitRecords.Count} æ¡æåè®°å½");

			// æ¶éæåç¸å³çæææ¡ç
			var splitBarcodes = new List<string>();
			foreach (var splitRecord in statusAnalysis.SplitRecords)
			{
			if (!string.IsNullOrEmpty(splitRecord.OriginalBarcode))
			splitBarcodes.Add(splitRecord.OriginalBarcode);
			if (!string.IsNullOrEmpty(splitRecord.NewBarcode))
			splitBarcodes.Add(splitRecord.NewBarcode);
			}

			// å»é
			splitBarcodes = splitBarcodes.Distinct().ToList();

			foreach (var barcode in splitBarcodes)
			{
			if (processedBarcodes.Contains(barcode))
			{
			_logger.LogInformation($"æåæ¡ç å·²å¤ç: {barcode}");
			continue;
			}

			// æ¥æ¾åºå
			var stockDetail = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
			.FirstAsync(x => x.Barcode == barcode && x.StockId == statusAnalysis.StockId);

			if (stockDetail != null && stockDetail.StockQuantity > 0)
			{
			decimal returnQty = stockDetail.StockQuantity;
			_logger.LogInformation($"å¤çæåç¸å³åºåååº - æ¡ç : {barcode}, ååºæ°é: {returnQty}");

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

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

			processedBarcodes.Add(barcode);
			totalReturnedQty += returnQty;

			_logger.LogInformation($"æååºåååºå®æ - æ¡ç : {barcode}, æ°é: {returnQty}");
			}
			}
			}
			}

			_logger.LogInformation($"ååºæ°æ®æä½å®æ - æ»ååºæ°é: {totalReturnedQty}, å¤çæ¡ç æ°: {processedBarcodes.Count}");
			}
			catch (Exception ex)
			{
			@@ -1772,9 +3324,154 @@
			throw;
			}
			}
			// <summary>
			/// å¤çæªåéçéå®è®°å½ååº
			/// ä¸éè¦åå°è®¢åæç»çåéæ°é


			/// <summary>
			/// å¤çåºåååº - å®æ´ä¿®æ£ç
			/// ç¡®ä¿OutboundQuantityæ£ç¡®åå°
			/// </summary>
			private async Task ProcessStockForReturn(string barcode, int stockId, decimal returnQty)
			{
			try
			{
			_logger.LogInformation($"å¤çåºåååº - æ¡ç : {barcode}, ååºæ°é: {returnQty}");

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

			if (stockDetail == null)
			{
			_logger.LogWarning($"æªæ¾å°åºåæç» - æ¡ç : {barcode}");
			return;
			}

			// è®°å½åå§å¼
			decimal originalStockQty = stockDetail.StockQuantity;
			decimal originalOutboundQty = stockDetail.OutboundQuantity;
			int originalStatus = stockDetail.Status;

			_logger.LogInformation($"ååºåç¶æ - åºå: {originalStockQty}, åºåº: {originalOutboundQty}, ç¶æ: {GetStockStatusName(originalStatus)}");

			// ãæ ¸å¿ä¿®æ£ãç¡®ä¿ååºæä½æ£ç¡®å¤ç
			// 1. åºåæ°éå¢å ï¼ååºçè´§ç©åå°åºåï¼
			stockDetail.StockQuantity += returnQty;

			// 2. åºåºæ°éåå°ï¼å ä¸ºè´§ç©æ²¡æåºåºï¼èæ¯ååºäºï¼
			// ä½éè¦ç¡®ä¿ä¸ä¼åºç°è´æ°
			if (stockDetail.OutboundQuantity >= returnQty)
			{
			stockDetail.OutboundQuantity -= returnQty;
			}
			else
			{
			// å¦æåºåºæ°éå°äºååºæ°éï¼è¯´ææ°æ®å¼å¸¸
			_logger.LogWarning($"åºåºæ°é({stockDetail.OutboundQuantity})å°äºååºæ°é({returnQty})ï¼éç½®åºåºæ°éä¸º0");
			stockDetail.OutboundQuantity = 0;
			}

			// 3. æ´æ°ç¶æä¸ºå¥åºå®æ
			stockDetail.Status = (int)StockStatusEmun.å¥åºå®æ;

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

			_logger.LogInformation($"åºåååºå®æ - æ¡ç : {barcode}");
			_logger.LogInformation($" åºåæ°é: {originalStockQty} -> {stockDetail.StockQuantity}");
			_logger.LogInformation($" åºåºæ°é: {originalOutboundQty} -> {stockDetail.OutboundQuantity}");
			_logger.LogInformation($" ç¶æ: {GetStockStatusName(originalStatus)} -> {GetStockStatusName(stockDetail.Status)}");

			// éªè¯ååºåçæ°æ®
			await ValidateStockAfterReturn(barcode, stockId, returnQty);
			}
			catch (Exception ex)
			{
			_logger.LogError($"å¤çåºåååºå¤±è´¥ - æ¡ç : {barcode}, Error: {ex.Message}");
			throw;
			}
			}

			/// <summary>
			/// éªè¯ååºååºåæ°æ®
			/// </summary>
			private async Task ValidateStockAfterReturn(string barcode, int stockId, decimal returnQty)
			{
			try
			{
			var stockDetail = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
			.FirstAsync(x => x.Barcode == barcode && x.StockId == stockId);

			// æ£æ¥åºåºæ°éæ¯å¦ä¸º0æåç
			if (stockDetail.OutboundQuantity > stockDetail.StockQuantity)
			{
			_logger.LogWarning($"ååºåæ°æ®å¼å¸¸ - åºåºæ°é({stockDetail.OutboundQuantity})å¤§äºåºåæ°é({stockDetail.StockQuantity})");
			}

			// æ£æ¥ç¶ææ¯å¦æ£ç¡®
			if (stockDetail.Status != (int)StockStatusEmun.å¥åºå®æ)
			{
			_logger.LogWarning($"ååºåç¶æå¼å¸¸ - ææ:å¥åºå®æ, å®é:{GetStockStatusName(stockDetail.Status)}");
			}
			}
			catch (Exception ex)
			{
			_logger.LogError($"éªè¯ååºåæ°æ®å¤±è´¥: {ex.Message}");
			}
			}

			/// <summary>
			/// ä¸ºéå®è®°å½åå°è®¢åæç»çåéæ°é
			/// </summary>
			private async Task ReduceOrderDetailAllocationForLock(long orderDetailId, decimal reduceQty)
			{
			if (orderDetailId <= 0)
			return;

			var orderDetail = await _outboundOrderDetailService.Db.Queryable<Dt_OutboundOrderDetail>()
			.FirstAsync(x => x.Id == orderDetailId);

			if (orderDetail == null)
			return;

			decimal originalAllocated = orderDetail.AllocatedQuantity;
			decimal originalLock = orderDetail.LockQuantity;

			// éªè¯åå°æ°éä¸ä¼å¯¼è´è´æ°
			if (orderDetail.AllocatedQuantity < reduceQty)
			{
			_logger.LogWarning($"åéæ°éä¸è¶³ï¼è°æ´åå°æ°é - åè®¡ååå°: {reduceQty}, å®éå¯ç¨: {orderDetail.AllocatedQuantity}");
			reduceQty = orderDetail.AllocatedQuantity;
			}

			// åå°åéæ°éåéå®æ°é
			orderDetail.AllocatedQuantity -= reduceQty;
			orderDetail.LockQuantity -= reduceQty;

			// ç¡®ä¿æ°éä¸ä¼ä¸ºè´æ°
			if (orderDetail.AllocatedQuantity < 0)
			{
			_logger.LogWarning($"åéæ°éåºç°è´æ°ï¼éç½®ä¸º0ãåå¼: {orderDetail.AllocatedQuantity + reduceQty}, åå°: {reduceQty}");
			orderDetail.AllocatedQuantity = 0;
			}

			if (orderDetail.LockQuantity < 0)
			{
			_logger.LogWarning($"éå®æ°éåºç°è´æ°ï¼éç½®ä¸º0ãåå¼: {orderDetail.LockQuantity + reduceQty}, åå°: {reduceQty}");
			orderDetail.LockQuantity = 0;
			}

			// æ´æ°æ¹æ¬¡åéç¶æ
			await UpdateBatchAllocateStatus(orderDetail);

			await _outboundOrderDetailService.Db.Updateable(orderDetail).ExecuteCommandAsync();

			_logger.LogInformation($"åå°è®¢åæç»åé - OrderDetailId: {orderDetail.Id}, " +
			$"åéæ°é: {originalAllocated} -> {orderDetail.AllocatedQuantity}, " +
			$"éå®æ°é: {originalLock} -> {orderDetail.LockQuantity}, " +
			$"åå°æ°é: {reduceQty}");
			}

			/// <summary>
			/// å¤çæªåéçéå®è®°å½ååº - ä¿®æ£ç
			/// æ³¨æï¼æªåééå®è®°å½æ²¡æç»å®è®¢åæç»ï¼ä¸éè¦åå°è®¢åæç»çåéæ°é
			/// </summary>
			private async Task HandleUnallocatedLocksReturn(List<Dt_OutStockLockInfo> unallocatedLocks)
			{
			@@ -1794,22 +3491,40 @@
			_logger.LogInformation($"å¤çæªåééå®è®°å½ååº - éå®ID: {lockInfo.Id}, æ¡ç : {lockInfo.CurrentBarcode}, ååºæ°é: {returnQty}");

			// æ¢å¤åºåç¶æ
			await RestoreStockForLockInfo(lockInfo, returnQty);
			var stockDetail = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
			.FirstAsync(x => x.Barcode == lockInfo.CurrentBarcode && x.StockId == lockInfo.StockId);

			if (stockDetail != null)
			{
			// ãä¿®æ£ãæ¢å¤åºåæ°éï¼åºåºæ°éä¿æä¸åï¼å ä¸ºæªåééå®çåºåºæ°éæ¬æ¥å°±æ¯0ï¼
			decimal originalStockQty = stockDetail.StockQuantity;
			stockDetail.StockQuantity += returnQty;

			// åºåºæ°éä¿æä¸º0ä¸åï¼
			// stockDetail.OutboundQuantity = stockDetail.OutboundQuantity; // ä¿æä¸å

			// æ¢å¤åºåç¶æä¸ºå¯ç¨ç¶æ
			if (stockDetail.Status == (int)StockStatusEmun.åºåºéå®)
			{
			stockDetail.Status = (int)StockStatusEmun.å¥åºå®æ;
			}

			await _stockInfoDetailService.Db.Updateable(stockDetail).ExecuteCommandAsync();
			_logger.LogInformation($"æ¢å¤æªåéåºå - æ¡ç : {stockDetail.Barcode}, åºåæ°é: {originalStockQty} -> {stockDetail.StockQuantity}");
			}

			// æ´æ°éå®è®°å½ç¶æä¸ºå·²ååº
			lockInfo.Status = (int)OutLockStockStatusEnum.å·²ååº;
			lockInfo.Operator = App.User.UserName;
			lockInfo.Operator = App.User.UserName;

			await _outStockLockInfoService.Db.Updateable(lockInfo).ExecuteCommandAsync();

			_logger.LogInformation($"æ´æ°æªåééå®ç¶æ - éå®ID: {lockInfo.Id}, ç¶æ: åºåºä¸ -> å·²ååº");

			// éè¦ï¼æªåééå®è®°å½ä¸éè¦åå°è®¢åæç»çåéæ°é
			_logger.LogInformation($"æªåééå®è®°å½ååºå®æ - éå®ID: {lockInfo.Id}, ååºæ°é: {returnQty}, æ éæ´æ°è®¢åæç»");
			}

			_logger.LogInformation($"æªåééå®è®°å½ååºå¤çå®æ - å±å¤ç {unallocatedLocks.Count} æ¡è®°å½");
			}

			private async Task HandleAllocatedLocksReturn(List<Dt_OutStockLockInfo> allocatedLocks)
			{
			_logger.LogInformation($"å¼å§å¤çå·²åééå®è®°å½ååº - å± {allocatedLocks.Count} æ¡è®°å½");
			@@ -1854,7 +3569,7 @@

			// æ´æ°éå®è®°å½ç¶æä¸ºå·²ååº
			lockInfo.Status = (int)OutLockStockStatusEnum.å·²ååº;
			lockInfo.Operator = App.User.UserName;
			lockInfo.Operator = App.User.UserName;

			await _outStockLockInfoService.Db.Updateable(lockInfo).ExecuteCommandAsync();

			@@ -1945,11 +3660,33 @@
			PalletType = stockInfo.PalletType,
			WarehouseId = currentTask.WarehouseId
			};
			var targetAddress = currentTask.TargetAddress;

			await _taskRepository.Db.Insertable(returnTask).ExecuteCommandAsync();
			try
			{
			await _taskRepository.Db.Insertable(returnTask).ExecuteCommandAsync();

			_logger.LogInformation($"CreateReturnTaskAndHandleESS åæ¹å é¤åå²ä»»å¡: {orderNo} ï¼ {currentTask.TaskNum}");
			// å é¤åå§åºåºä»»å¡
			//_taskRepository.DeleteAndMoveIntoHty(originalTask, OperateTypeEnum.èªå¨å®æ);
			var result = _task_HtyService.DeleteAndMoveIntoHty(currentTask, OperateTypeEnum.äººå·¥å é¤);
			await _taskRepository.Db.Deleteable(currentTask).ExecuteCommandAsync();

			if (!result)
			{
			await _taskRepository.Db.Deleteable(currentTask).ExecuteCommandAsync();
			}
			_logger.LogInformation($"CreateReturnTaskAndHandleESS åæ¹å é¤åå²ä»»å¡: {orderNo} ï¼ {currentTask.TaskNum},å½±åè¡ {result}");

			}
			catch (Exception ex)
			{
			_logger.LogInformation($"åå»ºååºä»»å¡å¤±è´¥ - è®¢å: {orderNo}, æç: {palletCode}");
			throw new Exception($"åå»ºååºä»»å¡å¤±è´¥ - è®¢å: {orderNo}, æç: {palletCode}");

			}
			// åéESSå½ä»¤
			await SendESSCommands(palletCode, currentTask.TargetAddress, returnTask);
			await SendESSCommands(palletCode, targetAddress, returnTask);

			_logger.LogInformation($"åå»ºååºä»»å¡æå - è®¢å: {orderNo}, æç: {palletCode}");
			}
			@@ -2019,114 +3756,231 @@
			/// åææçç¶æç¨äºååº
			/// ç¡®ä¿ä¸ä¼éè¯¯è¯å«éè¦ååºçç©å
			/// </summary>

			/// <summary>
			/// åææçç¶æç¨äºååº - ä¿®æ£çï¼è§£å³æåè®°å½éå¤è®¡ç®é®é¢ï¼
			/// </summary>
			private async Task<PalletStatusAnalysis> AnalyzePalletStatusForReturn(string orderNo, string palletCode, int stockId)
			{
			var result = new PalletStatusAnalysis
			{
			OrderNo = orderNo,
			PalletCode = palletCode,
			StockId = stockId
			StockId = stockId,
			AllBarcodes = new List<string>(),
			ProcessedBarcodes = new HashSet<string>()
			};

			// 1. åææªåæ£çéå®è®°å½ï¼ç¶æä¸ºåºåºä¸ï¼
			var unfinishedLocks = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
			.Where(x => x.OrderNo == orderNo &&
			x.PalletCode == palletCode &&
			x.Status == (int)OutLockStockStatusEnum.åºåºä¸)
			.ToListAsync();
			_logger.LogInformation($"ãååºåæãå¼å§åææçç¶æ - è®¢å: {orderNo}, æç: {palletCode}, StockId: {stockId}");

			if (unfinishedLocks.Any())
			try
			{
			// éè¦ï¼åºåå·²åéåæªåéçéå®è®°å½
			var allocatedLocks = unfinishedLocks.Where(x => x.IsUnallocated != 1 && x.OrderDetailId > 0).ToList();
			var unallocatedLocks = unfinishedLocks.Where(x => x.IsUnallocated == 1 \|\| x.OrderDetailId == 0).ToList();
			// 1. é¦åè·åæçä¸ææçåºåæç»ï¼åºç¡æ°æ®ï¼
			var allStockDetails = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
			.Where(x => x.StockId == stockId && x.StockQuantity > 0)
			.ToListAsync();

			// å¤çå·²åéçéå®è®°å½
			_logger.LogInformation($"æ¾å° {allStockDetails.Count} ä¸ªæåºåçæç»è®°å½");

			// 2. åæææéå®è®°å½ï¼å·²åéåæªåéï¼
			var allLockInfos = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
			.Where(x => x.OrderNo == orderNo && x.PalletCode == palletCode)
			.ToListAsync();

			// åºåå·²åéåæªåééå®è®°å½
			var allocatedLocks = allLockInfos
			.Where(x => x.IsUnallocated != 1 && x.OrderDetailId > 0 &&
			x.Status == (int)OutLockStockStatusEnum.åºåºä¸)
			.ToList();

			var unallocatedLocks = allLockInfos
			.Where(x => (x.IsUnallocated == 1 \|\| x.OrderDetailId == 0) &&
			x.Status == (int)OutLockStockStatusEnum.åºåºä¸)
			.ToList();

			// å¤çå·²åééå®è®°å½
			if (allocatedLocks.Any())
			{
			result.HasRemainingLocks = true;
			result.RemainingLocks = allocatedLocks;
			result.RemainingLocksReturnQty = allocatedLocks.Sum(x => x.AssignQuantity - x.PickedQty);

			// ãä¿®å¤ãå¯¹äºå·²åééå®è®°å½ï¼ååºæ°éæ¯æªæ£éçé¨å
			result.RemainingLocksReturnQty = allocatedLocks.Sum(x =>
			{
			var returnQty = x.AssignQuantity - x.PickedQty;
			return returnQty > 0 ? returnQty : 0;
			});

			foreach (var lockInfo in allocatedLocks)
			{
			if (!string.IsNullOrEmpty(lockInfo.CurrentBarcode))
			{
			result.AllBarcodes.Add(lockInfo.CurrentBarcode);
			result.ProcessedBarcodes.Add(lockInfo.CurrentBarcode);
			}
			}

			_logger.LogInformation($"åç°{allocatedLocks.Count}æ¡å·²åéæªåæ£éå®è®°å½ï¼æ»æ°é: {result.RemainingLocksReturnQty}");
			_logger.LogInformation($"åç° {allocatedLocks.Count} æ¡å·²åééå®è®°å½ï¼ååºæ°é: {result.RemainingLocksReturnQty}");
			}

			// å¤çæªåéçéå®è®°å½ï¼å¦èªå¨æåäº§ççï¼
			// å¤çæªåééå®è®°å½ï¼èªå¨æåäº§ççï¼
			if (unallocatedLocks.Any())
			{
			result.HasUnallocatedLocks = true;
			result.UnallocatedLocks = unallocatedLocks;
			result.UnallocatedLocksReturnQty = unallocatedLocks.Sum(x => x.AssignQuantity - x.PickedQty);

			// ãä¿®å¤ãå¯¹äºæªåééå®è®°å½ï¼ååºæ°éæ¯å®çåéæ°éï¼å ä¸ºæªæ£éè¿ï¼
			// ä½å®éä¸ï¼åºåæ¬æ¥å°±åå¨ï¼åªæ¯ç¶æéè¦æ¢å¤
			result.UnallocatedLocksReturnQty = unallocatedLocks.Sum(x => x.AssignQuantity);

			foreach (var lockInfo in unallocatedLocks)
			{
			if (!string.IsNullOrEmpty(lockInfo.CurrentBarcode))
			if (!string.IsNullOrEmpty(lockInfo.CurrentBarcode) &&
			!result.ProcessedBarcodes.Contains(lockInfo.CurrentBarcode))
			{
			result.AllBarcodes.Add(lockInfo.CurrentBarcode);
			result.ProcessedBarcodes.Add(lockInfo.CurrentBarcode);
			}
			}

			_logger.LogInformation($"åç°{unallocatedLocks.Count}æ¡æªåééå®è®°å½ï¼æ»æ°é: {result.UnallocatedLocksReturnQty}");
			_logger.LogInformation($"åç° {unallocatedLocks.Count} æ¡æªåééå®è®°å½ï¼ååºæ°éï¼ç¶ææ¢å¤ï¼: {result.UnallocatedLocksReturnQty}");
			}

			// 3. ãéè¦ä¿®å¤ãéæ°è®¡ç®æ»ååºæ°é
			// å¯¹äºå·²åééå®ï¼ååºæ°é = æªæ£éæ°é
			// å¯¹äºæªåééå®ï¼æ²¡æå®éçåºåæ°éååï¼åªæ¯ç¶ææ¢å¤
			result.TotalReturnQty = result.RemainingLocksReturnQty; // åªè®¡ç®å·²åééå®çååºæ°é

			// è®°å½åºåæ°éï¼ç¨äºéªè¯ï¼
			decimal totalStockOnPallet = allStockDetails.Sum(x => x.StockQuantity);

			_logger.LogInformation($"ååºåæå®æ:");
			_logger.LogInformation($" æçæ»åºå: {totalStockOnPallet}");
			_logger.LogInformation($" å·²åééå®ååºæ°é: {result.RemainingLocksReturnQty}");
			_logger.LogInformation($" æªåééå®ç¶ææ¢å¤æ°é: {result.UnallocatedLocksReturnQty}");
			_logger.LogInformation($" å®éç©çååºæ°é: {result.TotalReturnQty}");

			result.HasItemsToReturn = result.TotalReturnQty > 0 \|\| result.UnallocatedLocksReturnQty > 0;
			result.IsEmptyPallet = !result.HasItemsToReturn;

			return result;
			}

			// 2. åææçä¸çå©ä½åºåè´§ç©ï¼ç¶æä¸ºåºåºéå®ä½æªåéï¼
			var palletStockGoods = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
			.Where(x => x.StockId == stockId &&
			x.Status == (int)StockStatusEmun.åºåºéå® &&
			x.StockQuantity > 0)
			.ToListAsync();

			// è¿æ»¤æå·²ç»è¢«éå®è®°å½å ç¨çåºå
			var lockedBarcodes = unfinishedLocks.Select(x => x.CurrentBarcode).ToList();
			var unlockedStockGoods = palletStockGoods.Where(x => !lockedBarcodes.Contains(x.Barcode)).ToList();

			// è¿ä¸æ¥è¿æ»¤ï¼æ£æ¥è¿äºåºåæ¯å¦æå³èçéå®è®°å½
			var trulyUnallocatedGoods = new List<Dt_StockInfoDetail>();
			foreach (var stock in unlockedStockGoods)
			catch (Exception ex)
			{
			var hasLock = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
			.Where(x => x.CurrentBarcode == stock.Barcode &&
			x.Status == (int)OutLockStockStatusEnum.åºåºä¸)
			.AnyAsync();

			if (!hasLock)
			{
			trulyUnallocatedGoods.Add(stock);
			}
			_logger.LogError($"ååºåæå¤±è´¥ - è®¢å: {orderNo}, æç: {palletCode}, Error: {ex.Message}");
			throw;
			}

			if (trulyUnallocatedGoods.Any())
			{
			result.HasPalletStockGoods = true;
			result.PalletStockGoods = trulyUnallocatedGoods;
			result.PalletStockReturnQty = trulyUnallocatedGoods.Sum(x => x.StockQuantity);

			foreach (var stock in trulyUnallocatedGoods)
			{
			result.AllBarcodes.Add(stock.Barcode);
			}

			_logger.LogInformation($"åç°{trulyUnallocatedGoods.Count}ä¸ªçæ£æªåéåºåè´§ç©ï¼æ»æ°é: {result.PalletStockReturnQty}");
			}

			// 3. è®¡ç®æ»ååºæ°é
			result.TotalReturnQty = result.RemainingLocksReturnQty + result.UnallocatedLocksReturnQty + result.PalletStockReturnQty;
			result.HasItemsToReturn = result.TotalReturnQty > 0;
			result.IsEmptyPallet = !result.HasItemsToReturn;

			_logger.LogInformation($"æçç¶æåæå®æ - è®¢å: {orderNo}, æç: {palletCode}, æ»ååºæ°é: {result.TotalReturnQty}");

			return result;
			}


			/// <summary>
			/// éªè¯æ²¡æéå¤æ¡ç
			/// </summary>
			private async Task ValidateNoDuplicateBarcodes(PalletStatusAnalysis analysis, List<Dt_StockInfoDetail> allStockDetails)
			{
			try
			{
			// æ£æ¥AllBarcodesä¸æ¯å¦æéå¤
			var duplicateBarcodes = analysis.AllBarcodes
			.GroupBy(b => b)
			.Where(g => g.Count() > 1)
			.Select(g => g.Key)
			.ToList();

			if (duplicateBarcodes.Any())
			{
			_logger.LogError($"åç°éå¤æ¡ç : {string.Join(", ", duplicateBarcodes)}");

			// èªå¨å»é
			analysis.AllBarcodes = analysis.AllBarcodes.Distinct().ToList();
			_logger.LogWarning($"å·²èªå¨å»éï¼æ¡ç æ°: {analysis.AllBarcodes.Count}");
			}

			// æ£æ¥æ¯ä¸ªæ¡ç çå®éåºå
			decimal totalStockFromBarcodes = 0;
			foreach (var barcode in analysis.AllBarcodes)
			{
			var stock = allStockDetails.FirstOrDefault(x => x.Barcode == barcode);
			if (stock != null)
			{
			totalStockFromBarcodes += stock.StockQuantity;
			_logger.LogInformation($"æ¡ç åºå - {barcode}: {stock.StockQuantity}");
			}
			}

			_logger.LogInformation($"ååºåææ»åºå: {analysis.TotalReturnQty}, æ¡ç å®éæ»åºå: {totalStockFromBarcodes}");

			// å¦æåæçæ°éå¤§äºå®éåºåï¼è¯´ææéå¤è®¡ç®
			if (analysis.TotalReturnQty > totalStockFromBarcodes * 1.1m) // åè®¸10%çè¯¯å·®
			{
			_logger.LogError($"ååºæ°é({analysis.TotalReturnQty})ææ¾å¤§äºå®éåºå({totalStockFromBarcodes})ï¼å¯è½åå¨éå¤è®¡ç®ï¼");
			}
			}
			catch (Exception ex)
			{
			_logger.LogError($"éªè¯éå¤æ¡ç å¤±è´¥: {ex.Message}");
			}
			}


			/// <summary>
			/// éªè¯åæç»æï¼ç¡®ä¿æ°æ®ä¸è´æ§
			/// </summary>
			private async Task ValidateAnalysisResults(PalletStatusAnalysis analysis, int stockId)
			{
			_logger.LogInformation($"å¼å§éªè¯åæç»æ - è®¢å: {analysis.OrderNo}, æç: {analysis.PalletCode}");

			try
			{
			// 1. éªè¯éå®è®°å½ååºåæç»çå¹é
			foreach (var lockInfo in analysis.RemainingLocks.Concat(analysis.UnallocatedLocks))
			{
			if (!string.IsNullOrEmpty(lockInfo.CurrentBarcode))
			{
			var stockDetail = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
			.FirstAsync(x => x.Barcode == lockInfo.CurrentBarcode && x.StockId == lockInfo.StockId);

			if (stockDetail == null)
			{
			_logger.LogWarning($"éå®è®°å½ {lockInfo.Id} çæ¡ç {lockInfo.CurrentBarcode} å¨åºåæç»ä¸ä¸åå¨");
			}
			else if (stockDetail.StockQuantity <= 0)
			{
			_logger.LogWarning($"éå®è®°å½ {lockInfo.Id} çæ¡ç {lockInfo.CurrentBarcode} åºåæ°éä¸º0æè´æ°");
			}
			}
			}

			// 2. éªè¯æ»ååºæ°éçåçæ§
			// è·åæçä¸çæ»åºåæ°é
			var totalStockOnPallet = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
			.Where(x => x.StockId == stockId)
			.SumAsync(x => x.StockQuantity);

			if (analysis.TotalReturnQty > totalStockOnPallet)
			{
			_logger.LogWarning($"æ»ååºæ°é {analysis.TotalReturnQty} å¤§äºæçæ»åºå {totalStockOnPallet}ï¼å¯è½åå¨è®¡ç®éè¯¯");
			}

			// 3. éªè¯æ¡ç çå¯ä¸æ§
			var duplicateBarcodes = analysis.AllBarcodes
			.GroupBy(x => x)
			.Where(g => g.Count() > 1)
			.Select(g => g.Key)
			.ToList();

			if (duplicateBarcodes.Any())
			{
			_logger.LogWarning($"åç°éå¤çæ¡ç : {string.Join(", ", duplicateBarcodes)}");
			}

			_logger.LogInformation($"åæç»æéªè¯å®æ");
			}
			catch (Exception ex)
			{
			_logger.LogError($"åæç»æéªè¯å¤±è´¥ - Error: {ex.Message}");
			// ä¸æåºå¼å¸¸ï¼åªè®°å½éè¯¯
			}
			}

			/// <summary>
			/// å¤çæªåæ£çéå®è®°å½ååº
			/// ç¡®ä¿ä¸ä¼éè¯¯ç»å®æ¡ç æ°éå°éå®æ°é
			@@ -2223,7 +4077,7 @@
			// åéæ°éå¨è®¢åæç»å±é¢ç»ä¸å¤ç
			var originalStatus = lockInfo.Status;
			lockInfo.Status = (int)OutLockStockStatusEnum.å·²ååº;
			lockInfo.Operator = App.User.UserName;
			lockInfo.Operator = App.User.UserName;

			await _outStockLockInfoService.Db.Updateable(lockInfo).ExecuteCommandAsync();

			@@ -2383,44 +4237,117 @@
			}

			/// <summary>
			/// åèµ°ç©ºç®± - åæ§è¡ååºåæ¸ç - å¢å¼ºçæ¬
			/// åèµ°ç©ºç®± - ä¿®æ£çï¼æ£ç¡®å¤çæªåééå®è®°å½
			/// </summary>
			public async Task<WebResponseContent> RemoveEmptyPallet(string orderNo, string palletCode)
			{
			try
			{
			_logger.LogInformation($"ãåèµ°ç©ºç®±å¼å§ãè®¢å: {orderNo}, æç: {palletCode}");

			_unitOfWorkManage.BeginTran();

			_logger.LogInformation($"å¼å§åèµ°ç©ºç®± - è®¢å: {orderNo}, æç: {palletCode}");
			// 1. åå°è¯æ§è¡ååºæä½ï¼ç¡®ä¿ææç©åé½ååº
			_logger.LogInformation($"æ¥éª¤1: åæ§è¡ååºæä½");
			var returnResult = await ExecutePalletReturn(orderNo, palletCode, "åèµ°ç©ºç®±åååº");

			// 1. éªè¯ç©ºç®±åèµ°æ¡ä»¶ï¼å¿é¡»å¨é¨å®ææ£éï¼
			var validationResult = await ValidateEmptyPalletRemoval(orderNo, palletCode);
			if (!validationResult.IsValid)
			// å³ä½¿ååºå¤±è´¥ï¼ç»§ç»éªè¯ç©ºç®±æ¡ä»¶ï¼å¯è½æ¯ççç©ºæçï¼
			if (!returnResult.Status)
			{
			_unitOfWorkManage.RollbackTran();
			return WebResponseContent.Instance.Error(validationResult.ErrorMessage);
			_logger.LogWarning($"ååºæä½å¯è½å¤±è´¥ææ ç©å: {returnResult.Message}");
			}

			var completedLocks = validationResult.Data;
			// 2. éªè¯ç©ºç®±åèµ°æ¡ä»¶ï¼å¿é¡»å¨é¨å®ææ£éæå·²ååºï¼
			_logger.LogInformation($"æ¥éª¤2: éªè¯ç©ºç®±åèµ°æ¡ä»¶");

			// 2. æ¸çå·²å®æçéå®è®°å½ï¼æ è®°ä¸ºå·²åèµ°ï¼
			await CleanupCompletedLocks(completedLocks);
			// è·åæççææéå®è®°å½ï¼åæ¬å·²ååºåå·²åèµ°çï¼
			var allLockInfos = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
			.Where(x => x.OrderNo == orderNo && x.PalletCode == palletCode)
			.ToListAsync();

			// 3. æ¸çå¯¹åºçåºåè®°å½ç¶æ
			if (!allLockInfos.Any())
			{
			_unitOfWorkManage.RollbackTran();
			return WebResponseContent.Instance.Error("è¯¥æçæ²¡æéå®è®°å½");
			}

			// ãä¿®æ£ãæ£æ¥æ¯å¦ææªå®æçéå®è®°å½
			var unfinishedLocks = allLockInfos.Where(x =>
			x.Status == (int)OutLockStockStatusEnum.åºåºä¸ \|\|
			x.Status == (int)OutLockStockStatusEnum.ååºä¸).ToList();

			if (unfinishedLocks.Any())
			{
			var unfinishedCount = unfinishedLocks.Count;
			// åºåå·²åéåæªåé
			var allocatedUnfinished = unfinishedLocks.Where(x => x.IsUnallocated != 1).ToList();
			var unallocatedUnfinished = unfinishedLocks.Where(x => x.IsUnallocated == 1).ToList();

			string errorMsg = $"æçè¿æ{unfinishedCount}æ¡æªå®æè®°å½";
			if (allocatedUnfinished.Any()) errorMsg += $"ï¼å¶ä¸å·²åé{allocatedUnfinished.Count}æ¡";
			if (unallocatedUnfinished.Any()) errorMsg += $"ï¼æªåé{unallocatedUnfinished.Count}æ¡";

			errorMsg += "ï¼ä¸è½åèµ°ç©ºç®±";

			_unitOfWorkManage.RollbackTran();
			return WebResponseContent.Instance.Error(errorMsg);
			}

			// è·åå·²å®æçéå®è®°å½ï¼ç¶æä¸ºæ£éå®ææå·²åèµ°ï¼
			var completedLocks = allLockInfos.Where(x =>
			x.Status == (int)OutLockStockStatusEnum.æ£éå®æ \|\|
			x.Status == (int)OutLockStockStatusEnum.å·²åèµ°).ToList();

			if (!completedLocks.Any())
			{
			// æ£æ¥æ¯å¦é½æ¯å·²ååºç¶æ
			var returnedLocks = allLockInfos.Where(x => x.Status == (int)OutLockStockStatusEnum.å·²ååº).ToList();
			if (returnedLocks.Any())
			{
			_logger.LogInformation($"ææéå®è®°å½é½å·²ååºï¼å¯ä»¥åèµ°ç©ºç®±");
			completedLocks = returnedLocks;
			}
			else
			{
			_unitOfWorkManage.RollbackTran();
			return WebResponseContent.Instance.Error("è¯¥æçæ²¡æå·²å®ææ£éæå·²ååºçè®°å½");
			}
			}

			_logger.LogInformation($"éªè¯éè¿ï¼æ¾å° {completedLocks.Count} æ¡å·²å®æè®°å½");

			// 3. æ¸çå·²å®æçéå®è®°å½ï¼æ è®°ä¸ºå·²åèµ°ï¼
			_logger.LogInformation($"æ¥éª¤3: æ¸çéå®è®°å½");
			foreach (var lockInfo in completedLocks)
			{
			// åªå¤çç¶æä¸æ¯å·²åèµ°çè®°å½
			if (lockInfo.Status != (int)OutLockStockStatusEnum.å·²åèµ°)
			{
			lockInfo.Status = (int)OutLockStockStatusEnum.å·²åèµ°;
			lockInfo.Operator = App.User.UserName;
			await _outStockLockInfoService.Db.Updateable(lockInfo).ExecuteCommandAsync();
			_logger.LogInformation($"éå®è®°å½æ è®°ä¸ºå·²åèµ° - ID: {lockInfo.Id}");
			}
			}

			// 4. æ¸çå¯¹åºçåºåè®°å½ç¶æ
			_logger.LogInformation($"æ¥éª¤4: æ¸çåºåè®°å½");
			foreach (var lockInfo in completedLocks)
			{
			await CleanupStockInfo(lockInfo);
			}

			// 4. æ´æ°ç¸å³è®¢åç¶æ
			// 5. æ´æ°ç¸å³è®¢åç¶æ
			_logger.LogInformation($"æ¥éª¤5: æ´æ°è®¢åç¶æ");
			await UpdateOrderStatusAfterPalletRemoval(orderNo);

			// 5. è®°å½æä½åå²
			// 6. è®°å½æä½åå²
			_logger.LogInformation($"æ¥éª¤6: è®°å½æä½åå²");
			await RecordEmptyPalletRemoval(orderNo, palletCode, completedLocks);

			_unitOfWorkManage.CommitTran();

			_logger.LogInformation($"åèµ°ç©ºç®±æå - è®¢å: {orderNo}, æç: {palletCode}");
			_logger.LogInformation($"ãåèµ°ç©ºç®±æåãè®¢å: {orderNo}, æç: {palletCode}");

			return WebResponseContent.Instance.OK("åèµ°ç©ºç®±æå");
			}
			@@ -2431,6 +4358,8 @@
			return WebResponseContent.Instance.Error($"åèµ°ç©ºç®±å¤±è´¥ï¼{ex.Message}");
			}
			}


			/// <summary>
			/// æ¶ééè¦ååºçæ¡ç
			/// </summary>
			@@ -2550,7 +4479,7 @@
			/// <summary>
			/// å¤çæªåæ£çéå®è®°å½ååº
			/// </summary>



			/// <summary>
			/// å¤çæçä¸çåºåè´§ç©ååº
			@@ -2693,6 +4622,359 @@
			}
			}

			/// <summary>
			/// æ¶ééè¦ååºçæ¡ç ï¼é¿åéå¤ï¼
			/// </summary>
			private async Task<HashSet<string>> CollectBarcodesForReturn(string orderNo, string palletCode, int stockId)
			{
			var barcodes = new HashSet<string>();

			try
			{
			_logger.LogInformation($"å¼å§æ¶éååºæ¡ç - è®¢å: {orderNo}, æç: {palletCode}, StockId: {stockId}");

			// 1. ä»éå®è®°å½æ¶é
			var lockInfos = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
			.Where(x => x.OrderNo == orderNo &&
			x.PalletCode == palletCode &&
			(x.Status == (int)OutLockStockStatusEnum.åºåºä¸
			// \|\| x.Status == (int)OutLockStockStatusEnum.åºåºéå®)
			))
			.ToListAsync();

			foreach (var lockInfo in lockInfos)
			{
			if (!string.IsNullOrEmpty(lockInfo.CurrentBarcode))
			{
			barcodes.Add(lockInfo.CurrentBarcode);
			_logger.LogInformation($"ä»éå®è®°å½æ·»å æ¡ç : {lockInfo.CurrentBarcode}");
			}
			}

			// 2. ä»åºåæç»æ¶éï¼ç¶æä¸ºåºåºéå®çï¼
			var stockDetails = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
			.Where(x => x.StockId == stockId &&
			x.Status == (int)StockStatusEmun.åºåºéå® &&
			x.StockQuantity > 0)
			.ToListAsync();

			foreach (var stockDetail in stockDetails)
			{
			if (!barcodes.Contains(stockDetail.Barcode) && !string.IsNullOrEmpty(stockDetail.Barcode))
			{
			barcodes.Add(stockDetail.Barcode);
			_logger.LogInformation($"ä»åºåæç»æ·»å æ¡ç : {stockDetail.Barcode}, æ°é: {stockDetail.StockQuantity}");
			}
			}

			// 3. ä»æåè®°å½æ¶é
			var splitRecords = await _splitPackageService.Db.Queryable<Dt_SplitPackageRecord>()
			.Where(x => x.OrderNo == orderNo &&
			x.PalletCode == palletCode &&
			!x.IsReverted &&
			x.Status != (int)SplitPackageStatusEnum.å·²æ£é)
			.ToListAsync();

			foreach (var splitRecord in splitRecords)
			{
			// æ·»å åæ¡ç
			if (!string.IsNullOrEmpty(splitRecord.OriginalBarcode) && !barcodes.Contains(splitRecord.OriginalBarcode))
			{
			barcodes.Add(splitRecord.OriginalBarcode);
			_logger.LogInformation($"ä»æåè®°å½æ·»å åæ¡ç : {splitRecord.OriginalBarcode}");
			}

			// æ·»å æ°æ¡ç
			if (!string.IsNullOrEmpty(splitRecord.NewBarcode) && !barcodes.Contains(splitRecord.NewBarcode))
			{
			barcodes.Add(splitRecord.NewBarcode);
			_logger.LogInformation($"ä»æåè®°å½æ·»å æ°æ¡ç : {splitRecord.NewBarcode}");
			}
			}

			_logger.LogInformation($"æ¡ç æ¶éå®æ - å± {barcodes.Count} ä¸ªæ¡ç : {string.Join(", ", barcodes)}");

			return barcodes;
			}
			catch (Exception ex)
			{
			_logger.LogError($"æ¶éååºæ¡ç å¤±è´¥ - Error: {ex.Message}");
			return barcodes;
			}
			}

			/// <summary>
			/// ç»ä¸å¤çæ¡ç ååºï¼é¿åéå¤å¤çï¼
			/// </summary>
			private async Task ProcessBarcodeReturn(string barcode, int stockId, decimal returnQty, HashSet<string> processedBarcodes)
			{
			if (returnQty <= 0)
			return;

			// æ£æ¥æ¯å¦å·²å¤çè¿
			if (processedBarcodes.Contains(barcode))
			{
			_logger.LogInformation($"è·³è¿å·²å¤ççæ¡ç : {barcode}");
			return;
			}

			// è·ååºåæç»
			var stockDetail = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
			.FirstAsync(x => x.Barcode == barcode && x.StockId == stockId);

			if (stockDetail == null)
			{
			_logger.LogWarning($"æªæ¾å°æ¡ç å¯¹åºçåºåæç»: {barcode}");
			return;
			}

			// è®°å½åå§å¼
			decimal originalStockQty = stockDetail.StockQuantity;
			decimal originalOutboundQty = stockDetail.OutboundQuantity;
			int originalStatus = stockDetail.Status;

			_logger.LogInformation($"å¤çæ¡ç ååº - {barcode}: åå§åºå={originalStockQty}, åå§åºåº={originalOutboundQty}, ç¶æ={originalStatus}");

			// éªè¯æ°æ®ä¸è´æ§
			if (originalOutboundQty < returnQty)
			{
			_logger.LogWarning($"åºåºæ°éå°äºååºæ°éï¼è°æ´ååºæ°é - æ¡ç : {barcode}, åºåºæ°é: {originalOutboundQty}, ååºæ°é: {returnQty}");
			returnQty = originalOutboundQty;
			}

			// æ´æ°åºåï¼åºåºæ°éåå°ï¼åºåæ°éå¢å
			stockDetail.OutboundQuantity -= returnQty;
			stockDetail.StockQuantity += returnQty;

			// ç¡®ä¿ä¸ä¼åºç°è´æ°
			if (stockDetail.OutboundQuantity < 0)
			{
			_logger.LogWarning($"åºåºæ°éåºç°è´æ°ï¼éç½®ä¸º0 - æ¡ç : {barcode}");
			stockDetail.OutboundQuantity = 0;
			}

			// æ´æ°ç¶æ
			if (stockDetail.OutboundQuantity <= 0 && stockDetail.StockQuantity > 0)
			{
			stockDetail.Status = (int)StockStatusEmun.å¥åºå®æ;
			_logger.LogInformation($"åºåç¶ææ´æ°ä¸ºå¥åºå®æ - æ¡ç : {barcode}");
			}
			else if (stockDetail.StockQuantity > 0)
			{
			stockDetail.Status = (int)StockStatusEmun.åºåºéå®;
			_logger.LogInformation($"åºåç¶æä¿æä¸ºåºåºéå® - æ¡ç : {barcode}");
			}

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

			// æ è®°ä¸ºå·²å¤ç
			processedBarcodes.Add(barcode);

			_logger.LogInformation($"æ¡ç ååºå®æ - {barcode}: " +
			$"åºå {originalStockQty} -> {stockDetail.StockQuantity}, " +
			$"åºåº {originalOutboundQty} -> {stockDetail.OutboundQuantity}, " +
			$"ç¶æ {originalStatus} -> {stockDetail.Status}");
			}

			/// <summary>
			/// å¤çæåè®°å½ååº - é¿åéå¤
			/// </summary>
			private async Task HandleSplitRecordsReturn(List<Dt_SplitPackageRecord> splitRecords, int stockId, HashSet<string> processedBarcodes)
			{
			if (!splitRecords.Any())
			return;

			_logger.LogInformation($"å¼å§å¤çæåè®°å½ååº - å± {splitRecords.Count} æ¡è®°å½");

			foreach (var splitRecord in splitRecords)
			{
			// åªå¤çæªæ¤éçæåè®°å½
			if (splitRecord.IsReverted)
			{
			_logger.LogInformation($"è·³è¿å·²æ¤éçæåè®°å½ - ID: {splitRecord.Id}");
			continue;
			}

			// å¤çæ°æ¡ç
			if (!string.IsNullOrEmpty(splitRecord.NewBarcode) && !processedBarcodes.Contains(splitRecord.NewBarcode))
			{
			var newStock = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
			.FirstAsync(x => x.Barcode == splitRecord.NewBarcode && x.StockId == stockId);

			if (newStock != null && newStock.StockQuantity > 0)
			{
			// æåçæ°æ¡ç ååºæ°éåºè¯¥æ¯å¶åºåæ°é
			await ProcessBarcodeReturn(splitRecord.NewBarcode, stockId, newStock.StockQuantity, processedBarcodes);
			}
			}

			// å¤çåæ¡ç
			if (!string.IsNullOrEmpty(splitRecord.OriginalBarcode) && !processedBarcodes.Contains(splitRecord.OriginalBarcode))
			{
			var originalStock = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
			.FirstAsync(x => x.Barcode == splitRecord.OriginalBarcode && x.StockId == stockId);

			if (originalStock != null && originalStock.StockQuantity > 0)
			{
			// åæ¡ç çååºæ°éåºè¯¥æ¯æååå©ä½çæ°é
			await ProcessBarcodeReturn(splitRecord.OriginalBarcode, stockId, originalStock.StockQuantity, processedBarcodes);
			}
			}

			// æ´æ°æåè®°å½ç¶æä¸ºå·²ååº
			splitRecord.Status = (int)SplitPackageStatusEnum.å·²ååº;
			await _splitPackageService.Db.Updateable(splitRecord).ExecuteCommandAsync();

			_logger.LogInformation($"æåè®°å½ç¶ææ´æ°ä¸ºå·²ååº - è®°å½ID: {splitRecord.Id}");
			}

			_logger.LogInformation($"æåè®°å½ååºå¤çå®æ");
			}

			/// <summary>
			/// ç®åçååºæ¹æ³ - ç»è¿å¤æéªè¯
			/// </summary>
			public async Task<WebResponseContent> SimplePalletReturn(string orderNo, string palletCode, string returnReason = "ç®åååº")
			{
			try
			{
			_logger.LogInformation($"ãç®åååºå¼å§ãè®¢å: {orderNo}, æç: {palletCode}");

			_unitOfWorkManage.BeginTran();

			// 1. è·ååºåä¿¡æ¯ï¼è·³è¿å¤æéªè¯ï¼
			var stockInfo = await _stockInfoService.Db.Queryable<Dt_StockInfo>()
			.FirstAsync(x => x.PalletCode == palletCode);

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

			// 2. ç´æ¥æ¥æ¾éè¦ååºçæ¡ç ï¼ç®åé»è¾ï¼
			var barcodesToReturn = await GetBarcodesForSimpleReturn(orderNo, palletCode, stockInfo.Id);

			if (!barcodesToReturn.Any())
			{
			try
			{
			_logger.LogInformation($"ãæ ååºç©åãå¤çç©ºæç");
			var result = await HandleEmptyPalletReturn(orderNo, palletCode, stockInfo);
			_unitOfWorkManage.CommitTran();
			return result;
			}
			catch (Exception ex)
			{
			_unitOfWorkManage.RollbackTran();
			_logger.LogError($"ç©ºç®±ååºå¤±è´¥: {ex.Message}");
			return WebResponseContent.Instance.Error($"ç©ºç®±ååºå¤±è´¥ï¼{ex.Message}");
			}
			}

			// 3. ç®åå¤çæ¯ä¸ªæ¡ç
			foreach (var barcode in barcodesToReturn)
			{
			await ProcessSimpleBarcodeReturn(barcode, stockInfo.Id);
			}

			// 4. æ´æ°è®¢åç¶æï¼ç®åï¼
			await UpdateOrderStatusAfterReturn(orderNo);


			// 5. åå»ºååºä»»å¡
			await CreateReturnTask(orderNo, palletCode, stockInfo);

			_unitOfWorkManage.CommitTran();
			return WebResponseContent.Instance.OK($"ç®åååºæåï¼å¤ç {barcodesToReturn.Count} ä¸ªæ¡ç ");
			}
			catch (Exception ex)
			{
			_unitOfWorkManage.RollbackTran();
			_logger.LogError($"ç®åååºå¤±è´¥: {ex.Message}");
			return WebResponseContent.Instance.Error($"ååºå¤±è´¥: {ex.Message}");
			}
			}
			/// <summary>
			/// ç®åè·åååºæ¡ç
			/// </summary>
			private async Task<List<string>> GetBarcodesForSimpleReturn(string orderNo, string palletCode, int stockId)
			{
			var barcodes = new List<string>();

			try
			{
			// 1. ä»éå®è®°å½è·å
			var lockInfos = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
			.Where(x => x.OrderNo == orderNo && x.PalletCode == palletCode)
			.Select(x => x.CurrentBarcode)
			.ToListAsync();

			barcodes.AddRange(lockInfos.Where(b => !string.IsNullOrEmpty(b)));

			// 2. ä»åºåæç»è·å
			var stockDetails = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
			.Where(x => x.StockId == stockId && x.StockQuantity > 0)
			.Select(x => x.Barcode)
			.ToListAsync();

			barcodes.AddRange(stockDetails.Where(b => !string.IsNullOrEmpty(b)));

			// å»é
			return barcodes.Distinct().ToList();
			}
			catch (Exception ex)
			{
			_logger.LogError($"è·åååºæ¡ç å¤±è´¥: {ex.Message}");
			return barcodes;
			}
			}

			/// <summary>
			/// ç®åå¤çæ¡ç ååº
			/// </summary>
			private async Task ProcessSimpleBarcodeReturn(string barcode, int stockId)
			{
			try
			{
			// 1. è·ååºåæç»
			var stockDetail = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
			.FirstAsync(x => x.Barcode == barcode && x.StockId == stockId);

			if (stockDetail == null)
			{
			_logger.LogWarning($"æªæ¾å°æ¡ç å¯¹åºçåºåæç»: {barcode}");
			return;
			}

			// 2. å¦ææ¯åºåºéå®ç¶æï¼æ¢å¤ä¸ºå¥åºå®æ
			if (stockDetail.Status == (int)StockStatusEmun.åºåºéå®)
			{
			stockDetail.Status = (int)StockStatusEmun.å¥åºå®æ;
			await _stockInfoDetailService.Db.Updateable(stockDetail).ExecuteCommandAsync();
			_logger.LogInformation($"æ¡ç ç¶ææ¢å¤ - {barcode}: åºåºéå® -> å¥åºå®æ");
			}

			// 3. æ´æ°ç¸å³çéå®è®°å½
			var lockInfos = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
			.Where(x => x.CurrentBarcode == barcode &&
			(x.Status == (int)OutLockStockStatusEnum.åºåºä¸ \|\|
			x.Status == (int)OutLockStockStatusEnum.æ£éå®æ))
			.ToListAsync();

			foreach (var lockInfo in lockInfos)
			{
			lockInfo.Status = (int)OutLockStockStatusEnum.å·²ååº;
			lockInfo.Operator = App.User.UserName;
			await _outStockLockInfoService.Db.Updateable(lockInfo).ExecuteCommandAsync();
			_logger.LogInformation($"éå®è®°å½ç¶ææ´æ° - ID: {lockInfo.Id}: å·²ååº");
			}
			}
			catch (Exception ex)
			{
			_logger.LogError($"å¤çæ¡ç ååºå¤±è´¥ - æ¡ç : {barcode}, Error: {ex.Message}");
			}
			}
			#endregion

			#region è¾å©æ¹æ³
			@@ -2806,9 +5088,6 @@

			#endregion




			#region éªè¯æ¹æ³
			private async Task<ValidationResult<(Dt_OutStockLockInfo, Dt_OutboundOrderDetail, Dt_StockInfoDetail, Dt_OutboundBatch)>> ValidatePickingRequest(
			string orderNo, string palletCode, string barcode)
			@@ -2912,6 +5191,7 @@
			_logger.LogInformation($"è·³è¿æªåééå®è®°å½çèªå¨æåæ£æ¥ - éå®ID: {lockInfo.Id}");
			return null;
			}

			// æ£æ¥æ¯å¦éè¦èªå¨æåçæ¡ä»¶ï¼
			// 1. åºåæ°éå¤§äºåéæ°é
			// 2. éå®ä¿¡æ¯ç¶æä¸ºåºåºä¸
			@@ -2926,109 +5206,134 @@
			// è®¡ç®æåæ°é = åºåæ°é - åéæ°é
			decimal splitQuantity = stockDetail.StockQuantity - lockInfo.AssignQuantity;

			_logger.LogInformation($"éè¦èªå¨æå - åºå: {stockDetail.StockQuantity}, åé: {lockInfo.AssignQuantity}, æåæ°é: {splitQuantity}");

			// æ§è¡èªå¨æå
			var splitResult = await ExecuteAutoSplitLogic(lockInfo, stockDetail, splitQuantity, palletCode);

			// å°æåæ°éä¼ éç»è°ç¨æ¹ï¼ç¨äºéªè¯
			if (splitResult != null && splitResult.Any())
			{
			// å¨è¿åç»æä¸æºå¸¦æåæ°éä¿¡æ¯
			foreach (var result in splitResult)
			{
			result.quantityTotal = splitQuantity.ToString("F2");
			}
			}

			return splitResult;
			}

			/// <summary>
			/// æ§è¡èªå¨æåé»è¾
			/// ç¡®ä¿èªå¨æåä¸ä¼å½±åååºé»è¾
			/// æ§è¡èªå¨æåé»è¾ - å®å¨ä¿®æ£ç
			/// ååï¼åªåç¦»ç©çåºåï¼ä¸æ¹ååè®¢åçä»»ä½åéååºåºæ°é
			/// </summary>
			private async Task<List<SplitResult>> ExecuteAutoSplitLogic(Dt_OutStockLockInfo lockInfo, Dt_StockInfoDetail stockDetail,
			decimal splitQuantity, string palletCode)
			decimal splitQuantity, string palletCode)
			{
			_logger.LogInformation($"å¼å§æ§è¡èªå¨æåé»è¾ - åæ¡ç : {stockDetail.Barcode}, æåæ°é: {splitQuantity}");

			// éªè¯æåæ°éåçæ§
			if (splitQuantity <= 0)
			try
			{
			throw new InvalidOperationException($"æåæ°éå¿é¡»å¤§äº0ï¼å½åå¼: {splitQuantity}");
			// 1. éªè¯æåæ°éåçæ§
			if (splitQuantity <= 0)
			throw new InvalidOperationException($"æåæ°éå¿é¡»å¤§äº0ï¼å½åå¼: {splitQuantity}");

			if (stockDetail.StockQuantity < lockInfo.AssignQuantity + splitQuantity)
			throw new InvalidOperationException($"åºåæ°éä¸è¶³ä»¥è¿è¡èªå¨æåï¼åºå: {stockDetail.StockQuantity}, éè¦: {lockInfo.AssignQuantity + splitQuantity}");

			// 2. çææ°æ¡ç
			string newBarcode = await GenerateNewBarcode();
			_logger.LogInformation($"çææ°æ¡ç : {newBarcode}");

			// 3. ãæ ¸å¿ä¿®æ£ãæ´æ°ååºåæç»ï¼åªåå°ç©çåºåï¼ä¸å½±ååºåºæ°é
			decimal originalStockQty = stockDetail.StockQuantity;
			stockDetail.StockQuantity -= splitQuantity; // ä»åºååå°
			// stockDetail.OutboundQuantity ä¿æä¸åï¼

			await _stockInfoDetailService.Db.Updateable(stockDetail).ExecuteCommandAsync();
			_logger.LogInformation($"æ´æ°ååºåæç»ï¼æ¡ç {stockDetail.Barcode} åºå {originalStockQty} -> {stockDetail.StockQuantity}ï¼åºåºæ°éä¸å({stockDetail.OutboundQuantity})");

			// 4. åå»ºæ°åºåæç»ï¼å¤ä½é¨åï¼- åºåºæ°éä¸º0
			var newStockDetail = new Dt_StockInfoDetail
			{
			StockId = stockDetail.StockId,
			MaterielCode = stockDetail.MaterielCode,
			OrderNo = stockDetail.OrderNo,
			BatchNo = stockDetail.BatchNo,
			StockQuantity = splitQuantity, // æ°åºåæ°é
			OutboundQuantity = 0, // ãéç¹ãåå§åºåºæ°éä¸º0
			Barcode = newBarcode,
			Status = (int)StockStatusEmun.åºåºéå®, // ä»ä¸ºéå®ç¶æï¼ä½æªç»å®è®¢å
			SupplyCode = stockDetail.SupplyCode,
			Unit = stockDetail.Unit,
			BarcodeQty = stockDetail.BarcodeQty,
			BarcodeUnit = stockDetail.BarcodeUnit,
			BusinessType = stockDetail.BusinessType,
			InboundOrderRowNo = stockDetail.InboundOrderRowNo,
			};

			await _stockInfoDetailService.Db.Insertable(newStockDetail).ExecuteCommandAsync();
			_logger.LogInformation($"åå»ºæ°åºåæç»ï¼æ¡ç {newBarcode}ï¼åºå {splitQuantity}ï¼åºåº 0");

			// 5. åå»ºæ°éå®ä¿¡æ¯ - æ è®°ä¸ºæªåé
			var newLockInfo = new Dt_OutStockLockInfo
			{
			OrderNo = lockInfo.OrderNo,
			OrderDetailId = 0, // ãéç¹ãä¸ç»å®å°å·ä½è®¢åæç»ï¼è¡¨ç¤ºæªåé
			OutboundBatchNo = lockInfo.OutboundBatchNo,
			MaterielCode = lockInfo.MaterielCode,
			MaterielName = lockInfo.MaterielName,
			StockId = lockInfo.StockId,
			OrderQuantity = splitQuantity,
			AssignQuantity = splitQuantity,
			PickedQty = 0,
			LocationCode = lockInfo.LocationCode,
			PalletCode = lockInfo.PalletCode,
			TaskNum = lockInfo.TaskNum,
			Status = (int)OutLockStockStatusEnum.åºåºä¸,
			Unit = lockInfo.Unit,
			SupplyCode = lockInfo.SupplyCode,
			OrderType = lockInfo.OrderType,
			CurrentBarcode = newBarcode,
			IsSplitted = 1,
			ParentLockId = lockInfo.Id,
			Operator = App.User.UserName,
			FactoryArea = lockInfo.FactoryArea,
			lineNo = lockInfo.lineNo,
			WarehouseCode = lockInfo.WarehouseCode,
			BarcodeQty = lockInfo.BarcodeQty,
			BarcodeUnit = lockInfo.BarcodeUnit,
			IsUnallocated = 1 // ãéç¹ãæç¡®æ è®°ä¸º"æªåé"çéå®è®°å½
			};

			await _outStockLockInfoService.Db.Insertable(newLockInfo).ExecuteCommandAsync();
			_logger.LogInformation($"åå»ºæªåééå®è®°å½ï¼ID {newLockInfo.Id}ï¼æ¡ç {newBarcode}ï¼æ°é {splitQuantity}");

			// 6. ãå³é®ä¿®æ£ãåéå®è®°å½ååè®¢åæç»æ°æ®å®å¨ä¿æä¸åï¼
			// - ä¸ä¿®æ¹ lockInfo çä»»ä½åæ®µ
			// - ä¸ä¿®æ¹å³èç Dt_OutboundOrderDetail ç AllocatedQuantity å LockQuantity

			// è®°å½æååå²
			await RecordSplitHistory(lockInfo, stockDetail, splitQuantity, newBarcode, true, originalStockQty);

			// åå»ºæåç»æåè¡¨
			var splitResults = CreateSplitResults(lockInfo, splitQuantity, lockInfo.AssignQuantity, newBarcode, stockDetail.Barcode);

			_logger.LogInformation($"èªå¨æåé»è¾æ§è¡å®æ - åå»ºäºæªåéçåºååéå®è®°å½");

			return splitResults;
			}

			if (stockDetail.StockQuantity < lockInfo.AssignQuantity + splitQuantity)
			catch (Exception ex)
			{
			throw new InvalidOperationException($"åºåæ°éä¸è¶³ä»¥è¿è¡èªå¨æå");
			_logger.LogError($"èªå¨æåé»è¾æ§è¡å¤±è´¥ - åæ¡ç : {stockDetail.Barcode}, Error: {ex.Message}");
			throw;
			}

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

			// è®°å½æååçåéæ°é
			decimal originalAssignQty = lockInfo.AssignQuantity;
			decimal remainQty = originalAssignQty; // åéå®ä¿¡æ¯åéæ°éä¿æä¸å

			// åå»ºæ°åºåæç»ï¼å¤ä½é¨åï¼
			var newStockDetail = new Dt_StockInfoDetail
			{
			StockId = stockDetail.StockId,
			MaterielCode = stockDetail.MaterielCode,
			OrderNo = stockDetail.OrderNo,
			BatchNo = stockDetail.BatchNo,
			StockQuantity = splitQuantity,
			OutboundQuantity = 0,
			Barcode = newBarcode,
			Status = (int)StockStatusEmun.åºåºéå®,
			SupplyCode = stockDetail.SupplyCode,
			Unit = stockDetail.Unit,
			BarcodeQty = stockDetail.BarcodeQty,
			BarcodeUnit = stockDetail.BarcodeUnit,
			BusinessType = stockDetail.BusinessType,
			InboundOrderRowNo = stockDetail.InboundOrderRowNo,
			};
			await _stockInfoDetailService.Db.Insertable(newStockDetail).ExecuteCommandAsync();
			_logger.LogInformation($"åå»ºæ°åºåæç» - æ¡ç : {newBarcode}, åºåæ°é: {splitQuantity}");

			// åå»ºæ°éå®ä¿¡æ¯ï¼å¤ä½é¨åï¼- æ è®°ä¸ºæªåé
			var newLockInfo = new Dt_OutStockLockInfo
			{
			OrderNo = lockInfo.OrderNo,
			OrderDetailId = 0, // éè¦ï¼ä¸ç»å®å°å·ä½è®¢åæç»
			OutboundBatchNo = lockInfo.OutboundBatchNo,
			MaterielCode = lockInfo.MaterielCode,
			MaterielName = lockInfo.MaterielName,
			StockId = lockInfo.StockId,
			OrderQuantity = splitQuantity,
			AssignQuantity = splitQuantity,
			PickedQty = 0,
			LocationCode = lockInfo.LocationCode,
			PalletCode = lockInfo.PalletCode,
			TaskNum = lockInfo.TaskNum,
			Status = (int)OutLockStockStatusEnum.åºåºä¸,
			Unit = lockInfo.Unit,
			SupplyCode = lockInfo.SupplyCode,
			OrderType = lockInfo.OrderType,
			CurrentBarcode = newBarcode,
			IsSplitted = 1,
			ParentLockId = lockInfo.Id,
			Operator = App.User.UserName,
			FactoryArea = lockInfo.FactoryArea,
			lineNo = lockInfo.lineNo,
			WarehouseCode = lockInfo.WarehouseCode,
			BarcodeQty = lockInfo.BarcodeQty,
			BarcodeUnit = lockInfo.BarcodeUnit,
			IsUnallocated = 1 // æ è®°ä¸ºæªåé
			};

			await _outStockLockInfoService.Db.Insertable(newLockInfo).ExecuteCommandAsync();
			_logger.LogInformation($"åå»ºæ°éå®ä¿¡æ¯ - æ¡ç : {newBarcode}, åéæ°é: {splitQuantity}, æ è®°ä¸ºæªåé");

			// èªå¨æåä¸æ¹åè®¢åæç»çåéæ°é
			_logger.LogInformation($"èªå¨æå - è®¢åæç»åéæ°éä¿æä¸å");

			// è®°å½æååå²
			await RecordSplitHistory(lockInfo, stockDetail, splitQuantity, newBarcode, true, stockDetail.StockQuantity);

			// åå»ºæåç»æåè¡¨
			var splitResults = CreateSplitResults(lockInfo, splitQuantity, remainQty, newBarcode, stockDetail.Barcode);

			_logger.LogInformation($"èªå¨æåé»è¾æ§è¡å®æ");

			return splitResults;
			}

			/// <summary>
			/// éªè¯èªå¨æååæ°æ®ä¸è´æ§
			/// éªè¯èªå¨æååæ°æ®ä¸è´æ§ - ä¿®æ£ç
			/// ååï¼éªè¯æªåééå®è®°å½çåå»ºï¼èä¸æ¯è®¢åæç»æ°éçåå
			/// </summary>
			private async Task ValidateDataConsistencyAfterAutoSplit(long orderDetailId, decimal originalAllocatedQty, decimal originalLockQty, decimal splitQuantity)
			{
			@@ -3039,60 +5344,104 @@
			if (orderDetail == null)
			return;

			// è®¡ç®ææéå®ä¿¡æ¯çæ»åéæ°é
			var allLocks = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
			.Where(x => x.OrderDetailId == orderDetailId)
			.ToListAsync();

			decimal totalLockAssignQty = allLocks.Sum(x => x.AssignQuantity);

			_logger.LogInformation($"èªå¨æååæ°æ®ä¸è´æ§éªè¯ - è®¢åæç»åéæ°é: {orderDetail.AllocatedQuantity}, éå®ä¿¡æ¯æ»åéæ°é: {totalLockAssignQty}");

			// éªè¯èªå¨æååçæ°æ®ä¸è´æ§
			decimal expectedAllocatedQty = originalAllocatedQty + splitQuantity;
			decimal expectedLockQty = originalLockQty + splitQuantity;

			if (Math.Abs(orderDetail.AllocatedQuantity - expectedAllocatedQty) > 0.01m)
			// ãä¿®æ£ãèªå¨æååï¼è®¢åæç»åéæ°éåºè¯¥ä¿æä¸åï¼
			if (Math.Abs(orderDetail.AllocatedQuantity - originalAllocatedQty) > 0.01m)
			{
			_logger.LogWarning($"èªå¨æåååéæ°éå¼å¸¸ - ææ: {expectedAllocatedQty}, å®é: {orderDetail.AllocatedQuantity}");
			_logger.LogError($"èªå¨æååè®¢åæç»åéæ°éå¼å¸¸ååï¼ææä¿æä¸å: {originalAllocatedQty}, å®é: {orderDetail.AllocatedQuantity}");
			// è®°å½ä¸¥ééè¯¯ï¼ä½ä¸æåºå¼å¸¸ï¼çäº§ç¯å¢å¯è½éè¦åè¦ï¼
			}

			if (Math.Abs(orderDetail.LockQuantity - expectedLockQty) > 0.01m)
			if (Math.Abs(orderDetail.LockQuantity - originalLockQty) > 0.01m)
			{
			_logger.LogWarning($"èªå¨æååéå®æ°éå¼å¸¸ - ææ: {expectedLockQty}, å®é: {orderDetail.LockQuantity}");
			_logger.LogError($"èªå¨æååè®¢åæç»éå®æ°éå¼å¸¸ååï¼ææä¿æä¸å: {originalLockQty}, å®é: {orderDetail.LockQuantity}");
			}

			if (Math.Abs(orderDetail.AllocatedQuantity - totalLockAssignQty) > 0.01m)
			// éªè¯æªåééå®è®°å½çåå»º
			// æ¥æ¾ç¶éå®è®°å½
			var parentLockInfo = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
			.FirstAsync(x => x.OrderDetailId == orderDetailId);

			if (parentLockInfo != null)
			{
			_logger.LogWarning($"èªå¨æååæ°æ®ä¸ä¸è´ - è®¢åæç»åéæ°é: {orderDetail.AllocatedQuantity}, éå®ä¿¡æ¯æ»åéæ°é: {totalLockAssignQty}");
			// æ¥æ¾æªåéçåéå®è®°å½ï¼èªå¨æåçæçï¼
			var unallocatedChildLocks = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
			.Where(x => x.ParentLockId == parentLockInfo.Id &&
			x.IsUnallocated == 1 &&
			x.OrderDetailId == 0)
			.ToListAsync();

			if (unallocatedChildLocks.Any())
			{
			decimal totalUnallocatedQty = unallocatedChildLocks.Sum(x => x.AssignQuantity);
			_logger.LogInformation($"éªè¯éè¿ï¼åå»ºäº{unallocatedChildLocks.Count}æ¡æªåééå®è®°å½ï¼æ»æ°é: {totalUnallocatedQty}");

			if (Math.Abs(totalUnallocatedQty - splitQuantity) > 0.01m)
			{
			_logger.LogWarning($"æªåééå®è®°å½æ»æ°éä¸æåæ°éä¸å¹éï¼æåæ°é: {splitQuantity}, æªåéæ»æ°: {totalUnallocatedQty}");
			}
			}
			else
			{
			_logger.LogWarning($"æªæ¾å°èªå¨æåçæçæªåééå®è®°å½");
			}
			}

			_logger.LogInformation($"èªå¨æåæ°æ®ä¸è´æ§éªè¯å®æ");
			}

			#endregion

			#region æ ¸å¿é»è¾æ¹æ³

			/// <summary>
			/// æ§è¡åæ£é»è¾ - å®å¨ä¿®æ£ç
			/// ç¡®ä¿OutboundQuantityåç¡®ç´¯å ï¼ä¸åå«æåæ°é
			/// </summary>
			private async Task<PickingResult> ExecutePickingLogic(
			Dt_OutStockLockInfo lockInfo, Dt_OutboundOrderDetail orderDetail,
			Dt_StockInfoDetail stockDetail, decimal actualPickedQty)
			{
			_logger.LogInformation($"å¼å§æ§è¡åæ£é»è¾ - æ¡ç : {stockDetail.Barcode}, åéæ°é: {lockInfo.AssignQuantity}, å®éæ£é: {actualPickedQty}");

			// åæ¬¡éªè¯è®¢åæç»çåéæ°éï¼é²æ¢å¹¶åæä½ï¼
			if (orderDetail.AllocatedQuantity < actualPickedQty)
			// åæ¬¡éªè¯åºåæ°é
			if (stockDetail.StockQuantity < actualPickedQty)
			{
			throw new InvalidOperationException($"è®¢åæç»åéæ°éä¸è¶³ï¼éè¦æ£é {actualPickedQty}ï¼å¯ç¨åéæ°é {orderDetail.AllocatedQuantity}");
			throw new InvalidOperationException($"åºåæ°éä¸è¶³ï¼éè¦æ£é {actualPickedQty}ï¼å®éåºå {stockDetail.StockQuantity}");
			}

			if (orderDetail.LockQuantity < actualPickedQty)
			// è®°å½æ£éåçå¼
			decimal originalStockQty = stockDetail.StockQuantity;
			decimal originalOutboundQty = stockDetail.OutboundQuantity;
			int originalStatus = stockDetail.Status;

			// ãæ ¸å¿ä¿®æ£ãç¡®ä¿OutboundQuantityåªå¢å æ¬æ¬¡æ£éæ°éï¼ä¸åå«å¶ä»
			stockDetail.StockQuantity -= actualPickedQty;
			stockDetail.OutboundQuantity += actualPickedQty; // åªå¢å æ¬æ¬¡æ£éæ°é

			_logger.LogInformation($"æ´æ°åºåä¿¡æ¯ - æ¡ç : {stockDetail.Barcode}");
			_logger.LogInformation($" åºåæ°é: {originalStockQty} -> {stockDetail.StockQuantity}");
			_logger.LogInformation($" åºåºæ°é: {originalOutboundQty} -> {stockDetail.OutboundQuantity}");

			// æ´æ°åºåç¶æ
			if (stockDetail.StockQuantity <= 0)
			{
			throw new InvalidOperationException($"è®¢åæç»éå®æ°éä¸è¶³ï¼éè¦æ£é {actualPickedQty}ï¼å¯ç¨éå®æ°é {orderDetail.LockQuantity}");
			stockDetail.Status = (int)StockStatusEmun.åºåºå®æ;
			_logger.LogInformation($"åºåç¶ææ´æ°ä¸ºåºåºå®æ");
			}
			else
			{
			stockDetail.Status = (int)StockStatusEmun.åºåºéå®;
			_logger.LogInformation($"åºåç¶æä¿æä¸ºåºåºéå®");
			}

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

			// æ´æ°éå®ä¿¡æ¯
			decimal originalPickedQty = lockInfo.PickedQty;
			lockInfo.PickedQty += actualPickedQty;
			_logger.LogInformation($"æ´æ°éå®ä¿¡æ¯ - å·²æ£éæ°éä» {lockInfo.PickedQty - actualPickedQty} å¢å å° {lockInfo.PickedQty}");
			_logger.LogInformation($"æ´æ°éå®ä¿¡æ¯ - å·²æ£éæ°éä» {originalPickedQty} å¢å å° {lockInfo.PickedQty}");

			// åç¡®å¤ææ£éå®æç¶æ
			// å¤ææ£éå®æç¶æ
			if (Math.Abs(lockInfo.PickedQty - lockInfo.AssignQuantity) < 0.001m)
			{
			lockInfo.Status = (int)OutLockStockStatusEnum.æ£éå®æ;
			@@ -3107,29 +5456,8 @@
			lockInfo.Operator = App.User.UserName;
			await _outStockLockInfoService.Db.Updateable(lockInfo).ExecuteCommandAsync();

			// æ´æ°åºåä¿¡æ¯
			decimal originalStockQty = stockDetail.StockQuantity;
			decimal originalOutboundQty = stockDetail.OutboundQuantity;

			stockDetail.StockQuantity -= actualPickedQty;
			stockDetail.OutboundQuantity += actualPickedQty;

			_logger.LogInformation($"æ´æ°åºåä¿¡æ¯ - åºåæ°éä» {originalStockQty} åå°å° {stockDetail.StockQuantity}");
			_logger.LogInformation($"æ´æ°åºåä¿¡æ¯ - åºåºæ°éä» {originalOutboundQty} å¢å å° {stockDetail.OutboundQuantity}");

			// åç¡®å¤æåºåç¶æ
			if (stockDetail.StockQuantity <= 0)
			{
			stockDetail.Status = (int)StockStatusEmun.åºåºå®æ;
			_logger.LogInformation($"åºåç¶ææ´æ°ä¸ºåºåºå®æ");
			}
			else
			{
			stockDetail.Status = (int)StockStatusEmun.åºåºéå®;
			_logger.LogInformation($"åºåç¶æä¿æä¸ºåºåºéå®");
			}

			await _stockInfoDetailService.Db.Updateable(stockDetail).ExecuteCommandAsync();
			// éªè¯æ£éåçæ°æ®ä¸è´æ§
			await ValidatePickingDataConsistency(lockInfo, stockDetail, actualPickedQty);

			_logger.LogInformation($"åæ£é»è¾æ§è¡å®æ - æ¡ç : {stockDetail.Barcode}");

			@@ -3138,6 +5466,40 @@
			FinalLockInfo = lockInfo,
			ActualPickedQty = actualPickedQty
			};
			}

			/// <summary>
			/// éªè¯æ£éåæ°æ®ä¸è´æ§
			/// </summary>
			private async Task ValidatePickingDataConsistency(Dt_OutStockLockInfo lockInfo, Dt_StockInfoDetail stockDetail, decimal pickedQty)
			{
			_logger.LogInformation($"éªè¯æ£éæ°æ®ä¸è´æ§ - æ¡ç : {stockDetail.Barcode}");

			// 1. éªè¯åºåæç»çOutboundQuantityå¢å éçäºæ£éæ°é
			var refreshedStockDetail = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
			.FirstAsync(x => x.Id == stockDetail.Id);

			decimal outboundIncrease = refreshedStockDetail.OutboundQuantity - stockDetail.OutboundQuantity;

			if (Math.Abs(outboundIncrease - pickedQty) > 0.01m)
			{
			_logger.LogError($"æ£éæ°æ®ä¸ä¸è´ï¼åºåºæ°éå¢å {outboundIncrease}ï¼ä½æ£éæ°éæ¯ {pickedQty}");
			// ä¿®å¤ï¼ç¡®ä¿OutboundQuantityæ£ç¡®
			refreshedStockDetail.OutboundQuantity = stockDetail.OutboundQuantity + pickedQty;
			await _stockInfoDetailService.Db.Updateable(refreshedStockDetail).ExecuteCommandAsync();
			_logger.LogWarning($"å·²ä¿®å¤åºåºæ°éï¼{stockDetail.OutboundQuantity} -> {refreshedStockDetail.OutboundQuantity}");
			}

			// 2. éªè¯éå®è®°å½çå·²æ£éæ°é
			var refreshedLockInfo = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
			.FirstAsync(x => x.Id == lockInfo.Id);

			if (Math.Abs(refreshedLockInfo.PickedQty - (lockInfo.PickedQty - pickedQty) - pickedQty) > 0.01m)
			{
			_logger.LogError($"éå®è®°å½å·²æ£éæ°éä¸ä¸è´");
			}

			_logger.LogInformation($"æ£éæ°æ®ä¸è´æ§éªè¯éè¿");
			}

			private async Task<RevertPickingResult> RevertPickingData(Dt_PickingRecord pickingRecord)
			@@ -3230,59 +5592,85 @@

			#region æ°æ®æ´æ°æ¹æ³

			/// <summary>
			/// æ´æ°æ¹æ¬¡åè®¢åæ°æ® - ä¿®æ£ç
			/// ç¡®ä¿åªæ´æ°å®éçæ£éæ°é
			/// </summary>
			private async Task UpdateBatchAndOrderData(Dt_OutboundBatch batch, Dt_OutboundOrderDetail orderDetail, decimal pickedQty, string orderNo)
			{
			_logger.LogInformation($"å¼å§æ´æ°æ¹æ¬¡åè®¢åæ°æ® - æ£éæ°é: {pickedQty}");
			var latestOrderDetail = await _outboundOrderDetailService.Db.Queryable<Dt_OutboundOrderDetail>().FirstAsync(x => x.Id == orderDetail.Id);

			// éæ°è·åææ°æ°æ®ï¼é²æ¢å¹¶åé®é¢ï¼
			var latestOrderDetail = await _outboundOrderDetailService.Db.Queryable<Dt_OutboundOrderDetail>()
			.FirstAsync(x => x.Id == orderDetail.Id);

			if (latestOrderDetail == null)
			throw new InvalidOperationException("æªæ¾å°è®¢åæç»");

			orderDetail = latestOrderDetail;
			// éªè¯åéæ°éä¸ä¼åæè´æ°
			if (orderDetail.AllocatedQuantity < pickedQty)

			// éªè¯æ£éæ°éåçæ§
			if (pickedQty <= 0)
			{
			decimal actualPickedQty = orderDetail.AllocatedQuantity;
			_logger.LogWarning($"åéæ°éä¸è¶³ï¼è°æ´æ£éæ°é - åéè¦: {pickedQty}, å®éå¯ç¨: {actualPickedQty}");
			pickedQty = actualPickedQty;
			_logger.LogWarning($"æ£éæ°éæ æ: {pickedQty}");
			return;
			}

			if (orderDetail.LockQuantity < pickedQty)
			{
			decimal actualPickedQty = orderDetail.LockQuantity;
			_logger.LogWarning($"éå®æ°éä¸è¶³ï¼è°æ´æ£éæ°é - åéè¦: {pickedQty}, å®éå¯ç¨: {actualPickedQty}");
			pickedQty = actualPickedQty;
			}

			// 1. æ´æ°æ¹æ¬¡å®ææ°é
			decimal originalBatchCompletedQty = batch.CompletedQuantity;
			batch.CompletedQuantity += pickedQty;

			_logger.LogInformation($"æ´æ°æ¹æ¬¡å®ææ°é - ä» {originalBatchCompletedQty} å¢å å° {batch.CompletedQuantity}");

			if (batch.CompletedQuantity >= batch.BatchQuantity)
			{
			batch.BatchStatus = (int)BatchStatusEnum.å·²å®æ;
			_logger.LogInformation($"æ¹æ¬¡ç¶ææ´æ°ä¸ºå·²å®æ");
			}
			await _outboundBatchRepository.Db.Updateable(batch).ExecuteCommandAsync();

			// æ´æ°è®¢åæç»
			// è®°å½åå§å¼
			decimal originalOverOutQty = orderDetail.OverOutQuantity;
			decimal originalAllocatedQty = orderDetail.AllocatedQuantity;
			decimal originalLockQty = orderDetail.LockQuantity;

			orderDetail.OverOutQuantity += pickedQty;
			orderDetail.AllocatedQuantity -= pickedQty;
			// LockQuantity åæ¥åå°
			orderDetail.LockQuantity = orderDetail.AllocatedQuantity;
			if (orderDetail.AllocatedQuantity < 0) orderDetail.AllocatedQuantity = 0;
			if (orderDetail.LockQuantity < 0) orderDetail.LockQuantity = 0;
			_logger.LogInformation($"æ´æ°è®¢åæç» - å·²åºåºæ°éä» {originalOverOutQty} å¢å å° {orderDetail.OverOutQuantity}");
			_logger.LogInformation($"æ´æ°è®¢åæç» - å·²åéæ°éä» {originalAllocatedQty} åå°å° {orderDetail.AllocatedQuantity}");
			_logger.LogInformation($"æ´æ°è®¢åæç» - éå®æ°éä» {originalLockQty} åå°å° {orderDetail.LockQuantity}");
			// æ´æ°è®¢åæç»
			orderDetail.OverOutQuantity += pickedQty; // å·²åºåºæ°éå¢å
			orderDetail.AllocatedQuantity -= pickedQty; // å·²åéæ°éåå°
			orderDetail.LockQuantity -= pickedQty; // éå®æ°éåå°

			// ç¡®ä¿æ°éä¸ä¼ä¸ºè´æ°
			if (orderDetail.AllocatedQuantity < 0)
			{
			_logger.LogWarning($"åéæ°éåºç°è´æ°ï¼éç½®ä¸º0ãåå¼: {orderDetail.AllocatedQuantity + pickedQty}");
			orderDetail.AllocatedQuantity = 0;
			}

			if (orderDetail.LockQuantity < 0)
			{
			_logger.LogWarning($"éå®æ°éåºç°è´æ°ï¼éç½®ä¸º0ãåå¼: {orderDetail.LockQuantity + pickedQty}");
			orderDetail.LockQuantity = 0;
			}

			// æ´æ°æ¹æ¬¡åéç¶æ
			await UpdateBatchAllocateStatus(orderDetail);

			await _outboundOrderDetailService.Db.Updateable(orderDetail).ExecuteCommandAsync();

			_logger.LogInformation($"æ´æ°è®¢åæç»æå");
			_logger.LogInformation($" å·²åºåºæ°é: {originalOverOutQty} -> {orderDetail.OverOutQuantity}");
			_logger.LogInformation($" å·²åéæ°é: {originalAllocatedQty} -> {orderDetail.AllocatedQuantity}");
			_logger.LogInformation($" éå®æ°é: {originalLockQty} -> {orderDetail.LockQuantity}");

			// æ´æ°æ¹æ¬¡å®ææ°é
			if (batch != null)
			{
			decimal originalBatchCompletedQty = batch.CompletedQuantity;
			batch.CompletedQuantity += pickedQty;

			_logger.LogInformation($"æ´æ°æ¹æ¬¡å®ææ°é - ä» {originalBatchCompletedQty} å¢å å° {batch.CompletedQuantity}");

			// æ´æ°æ¹æ¬¡ç¶æ
			if (batch.CompletedQuantity >= batch.BatchQuantity)
			{
			batch.BatchStatus = (int)BatchStatusEnum.å·²å®æ;
			_logger.LogInformation($"æ¹æ¬¡ç¶ææ´æ°ä¸ºå·²å®æ");
			}
			else if (batch.CompletedQuantity > 0)
			{
			batch.BatchStatus = (int)BatchStatusEnum.æ§è¡ä¸;
			_logger.LogInformation($"æ¹æ¬¡ç¶ææ´æ°ä¸ºæ§è¡ä¸");
			}

			await _outboundBatchRepository.Db.Updateable(batch).ExecuteCommandAsync();
			}

			// æ£æ¥è®¢åç¶æ
			await CheckAndUpdateOrderStatus(orderNo);
			@@ -3478,13 +5866,24 @@

			};
			// ä¿åååºä»»å¡
			await _taskRepository.Db.Insertable(returnTask).ExecuteCommandAsync();
			var insertcount = await _taskRepository.Db.Insertable(returnTask).ExecuteCommandAsync();
			if (insertcount <= 0)
			{
			throw new Exception("åå»ºä»»å¡å¤±è´¥ï¼");
			}
			var targetAddress = originalTask.TargetAddress;

			_logger.LogInformation($"CreateReturnTaskAndHandleESS åæ¹å é¤åå²ä»»å¡: {orderNo} ï¼ {originalTask.TaskNum}");
			// å é¤åå§åºåºä»»å¡
			_taskRepository.DeleteAndMoveIntoHty(originalTask, OperateTypeEnum.èªå¨å®æ);
			//_taskRepository.DeleteAndMoveIntoHty(originalTask, OperateTypeEnum.èªå¨å®æ);
			var result = _task_HtyService.DeleteAndMoveIntoHty(originalTask, OperateTypeEnum.äººå·¥å é¤);
			await _taskRepository.Db.Deleteable(originalTask).ExecuteCommandAsync();

			if (!result)
			{
			await _taskRepository.Db.Deleteable(originalTask).ExecuteCommandAsync();
			}
			_logger.LogInformation($"CreateReturnTaskAndHandleESS åæ¹å é¤åå²ä»»å¡: {orderNo} ï¼ {originalTask.TaskNum},å½±åè¡ {result}");


			// ç» ESS åéæµå¨ä¿¡å·ååå»ºä»»å¡
			@@ -3543,7 +5942,6 @@
			throw new Exception($"ESSç³»ç»éä¿¡å¤±è´¥: {ex.Message}");
			}
			}


			#region è¾å©æ¹æ³

			@@ -3632,7 +6030,6 @@
			};
			}
			#endregion


			#region DTOç±»
			/// <summary>