ZhongRui/ALDbanyunxiangmu.git

			@@ -10,14 +10,18 @@
			using WIDESEA_Common.CommonEnum;
			using WIDESEA_Common.OrderEnum;
			using WIDESEA_Common.StockEnum;
			using WIDESEA_Common.TaskEnum;
			using WIDESEA_Core;
			using WIDESEA_Core.BaseRepository;
			using WIDESEA_Core.BaseServices;
			using WIDESEA_Core.Enums;
			using WIDESEA_DTO.Basic;
			using WIDESEA_DTO.Outbound;
			using WIDESEA_IAllocateService;
			using WIDESEA_IBasicService;
			using WIDESEA_IOutboundService;
			using WIDESEA_IStockService;
			using WIDESEA_ITaskInfoService;
			using WIDESEA_Model.Models;
			using WIDESEA_Model.Models.Basic;
			using WIDESEA_Model.Models.Outbound;
			@@ -46,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>
			@@ -65,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;
			@@ -83,6 +88,7 @@
			_dailySequenceService = dailySequenceService;
			_allocateService = allocateService;
			_outboundBatchRepository = outboundBatchRepository;
			_task_HtyService = task_HtyService;
			}

			// <summary>
			@@ -217,7 +223,7 @@
			.Where(x => x.OrderNo == orderNo &&
			x.PalletCode == palletCode &&
			x.CurrentBarcode == barcode
			//&& x.Status == (int)OutLockStockStatusEnum.åºåºä¸
			//&& x.Status == (int)OutLockStockStatusEnum.åºåºä¸
			)
			.FirstAsync();

			@@ -241,166 +247,6 @@

			#endregion

			#region åèµ°ç©ºç®±é»è¾



			/// <summary>
			/// åèµ°ç©ºç®± - æ¸çå·²å®ææ£éçæçæ°æ®
			/// </summary>
			public async Task<WebResponseContent> RemoveEmptyPallet(string orderNo, string palletCode)
			{
			try
			{
			_unitOfWorkManage.BeginTran();

			// éªè¯æçæ¯å¦å¯ä»¥åèµ°ï¼å¿é¡»å¨é¨å®ææ£éï¼
			var validationResult = await ValidateEmptyPalletRemoval(orderNo, palletCode);
			if (!validationResult.IsValid)
			return WebResponseContent.Instance.Error(validationResult.ErrorMessage);

			var completedLocks = validationResult.Data;

			// æ¸çéå®è®°å½ï¼æ è®°ä¸ºå·²å®æï¼
			await CleanupCompletedLocks(completedLocks);

			// æ´æ°ç¸å³è®¢åç¶æ
			await UpdateOrderStatusAfterPalletRemoval(orderNo);

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

			_unitOfWorkManage.CommitTran();

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

			/// <summary>
			/// éªè¯ç©ºç®±åèµ°æ¡ä»¶
			/// </summary>
			private async Task<ValidationResult<List<Dt_OutStockLockInfo>>> ValidateEmptyPalletRemoval(string orderNo, string palletCode)
			{
			// è·åæççææéå®è®°å½
			var lockInfos = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
			.Where(x => x.OrderNo == orderNo && x.PalletCode == palletCode)
			.ToListAsync();

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

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

			if (unfinishedLocks.Any())
			{
			var unfinishedCount = unfinishedLocks.Count;
			var unfinishedQty = unfinishedLocks.Sum(x => x.AssignQuantity - x.PickedQty);
			return ValidationResult<List<Dt_OutStockLockInfo>>.Error(
			$"æçè¿æ{unfinishedCount}æ¡æªå®æè®°å½ï¼å©ä½æ°é{unfinishedQty}ï¼ä¸è½åèµ°ç©ºç®±");
			}

			// è·åå·²å®æçéå®è®°å½
			var completedLocks = lockInfos.Where(x =>
			x.Status == (int)OutLockStockStatusEnum.æ£éå®æ).ToList();

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

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

			/// <summary>
			/// æ¸çå·²å®æçéå®è®°å½
			/// </summary>
			private async Task CleanupCompletedLocks(List<Dt_OutStockLockInfo> completedLocks)
			{
			foreach (var lockInfo in completedLocks)
			{
			// æ è®°éå®è®°å½ä¸ºå·²åèµ°
			lockInfo.Status = (int)OutLockStockStatusEnum.å·²åèµ°;
			lockInfo.Operator = App.User.UserName;
			await _outStockLockInfoService.Db.Updateable(lockInfo).ExecuteCommandAsync();

			// æ¸çå¯¹åºçåºåè®°å½ç¶æ
			await CleanupStockInfo(lockInfo);
			}
			}

			/// <summary>
			/// æ¸çåºåä¿¡æ¯
			/// </summary>
			private async Task CleanupStockInfo(Dt_OutStockLockInfo lockInfo)
			{
			var stockDetail = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
			.FirstAsync(x => x.Barcode == lockInfo.CurrentBarcode && x.StockId == lockInfo.StockId);

			if (stockDetail != null && stockDetail.Status == (int)StockStatusEmun.åºåºå®æ)
			{
			stockDetail.Status = (int)StockStatusEmun.å·²æ¸ç;
			await _stockInfoDetailService.Db.Updateable(stockDetail).ExecuteCommandAsync();
			}
			}


			/// <summary>
			/// æ´æ°è®¢åç¶æ
			/// </summary>
			private async Task UpdateOrderStatusAfterPalletRemoval(string orderNo)
			{
			// æ£æ¥è®¢åæ¯å¦æææçé½å·²å®æ
			var allLocks = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
			.Where(x => x.OrderNo == orderNo)
			.ToListAsync();

			var unfinishedPallets = allLocks
			.GroupBy(x => x.PalletCode)
			.Where(g => g.Any(x => x.Status == (int)OutLockStockStatusEnum.åºåºä¸ \|\|
			x.Status == (int)OutLockStockStatusEnum.ååºä¸))
			.ToList();

			// å¦ææ²¡ææªå®æçæçï¼æ´æ°è®¢åç¶æä¸ºåºåºå®æ
			if (!unfinishedPallets.Any())
			{
			await _outboundOrderService.Db.Updateable<Dt_OutboundOrder>()
			.SetColumns(x => new Dt_OutboundOrder
			{
			OrderStatus = (int)OutOrderStatusEnum.åºåºå®æ,
			})
			.Where(x => x.OrderNo == orderNo)
			.ExecuteCommandAsync();
			}
			}

			/// <summary>
			/// è®°å½ç©ºç®±åèµ°åå²
			/// </summary>
			private async Task RecordEmptyPalletRemoval(string orderNo, string palletCode, List<Dt_OutStockLockInfo> completedLocks)
			{
			var removalRecord = new Dt_EmptyPalletRemoval
			{
			OrderNo = orderNo,
			PalletCode = palletCode,
			RemovalTime = DateTime.Now,
			Operator = App.User.UserName,
			CompletedItemsCount = completedLocks.Count,
			TotalPickedQuantity = completedLocks.Sum(x => x.PickedQty)
			};

			await Db.Insertable(removalRecord).ExecuteCommandAsync();
			}

			#endregion


			#region åæ¹åæ£

			/// <summary>
			@@ -415,7 +261,10 @@
			// éªè¯åæ£è¯·æ±
			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;

			@@ -433,7 +282,7 @@

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

			// éè¦ä¿®å¤ï¼èªå¨æååï¼ç«å³æ§è¡åæ¡ç çåæ£

			var actualPickedQty = lockInfo.AssignQuantity;
			var pickingResult = await ExecutePickingLogic(lockInfo, orderDetail, stockDetail, actualPickedQty);

			@@ -445,15 +294,7 @@

			_unitOfWorkManage.CommitTran();

			return WebResponseContent.Instance.OK("èªå¨æåå¹¶åæ£æå", new
			{
			AutoSplitted = true,
			NewBarcode = autoSplitResult.NewBarcode,
			OriginalBarcode = barcode,
			SplitQuantity = autoSplitResult.SplitQuantity,
			PickedQuantity = actualPickedQty,
			MaterialCode = lockInfo.MaterielCode
			});
			return WebResponseContent.Instance.OK("èªå¨æåå¹¶åæ£æå", autoSplitResult);
			}

			// æ£å¸¸åæ£æµç¨ï¼ä¸éè¦èªå¨æåï¼
			@@ -529,9 +370,237 @@
			}
			#endregion

			#region æå¨æå

			#region æå¨æåç¸å³æ¹æ³
			#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)
			.ToListAsync();

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

			if (unfinishedLocks.Any())
			{
			var unfinishedCount = unfinishedLocks.Count;
			var unfinishedQty = unfinishedLocks.Sum(x => x.AssignQuantity - x.PickedQty);
			return ValidationResult<List<Dt_OutStockLockInfo>>.Error(
			$"æçè¿æ{unfinishedCount}æ¡æªå®æè®°å½ï¼å©ä½æ°é{unfinishedQty}ï¼ä¸è½åèµ°ç©ºç®±");
			}

			// è·åå·²å®æçéå®è®°å½ï¼ç¶æä¸ºæ£éå®ææå·²åèµ°ï¼
			var completedLocks = lockInfos.Where(x =>
			x.Status == (int)OutLockStockStatusEnum.æ£éå®æ \|\|
			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>
			/// æ¸çå·²å®æçéå®è®°å½
			/// </summary>
			private async Task CleanupCompletedLocks(List<Dt_OutStockLockInfo> completedLocks)
			{
			foreach (var lockInfo in completedLocks)
			{
			// æ è®°éå®è®°å½ä¸ºå·²åèµ°
			lockInfo.Status = (int)OutLockStockStatusEnum.å·²åèµ°;
			lockInfo.Operator = App.User.UserName;
			await _outStockLockInfoService.Db.Updateable(lockInfo).ExecuteCommandAsync();

			// æ¸çå¯¹åºçåºåè®°å½ç¶æ
			await CleanupStockInfo(lockInfo);
			}
			}

			/// <summary>
			/// æ¸çåºåä¿¡æ¯ - å¢å¼ºçæ¬
			/// </summary>
			private async Task CleanupStockInfo(Dt_OutStockLockInfo lockInfo)
			{
			try
			{
			// æ¥æ¾éå®çåºåæç»
			var stockDetail = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
			.FirstAsync(x => x.Barcode == lockInfo.CurrentBarcode && x.StockId == lockInfo.StockId);

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

			// å¦æåºåæ°éå¤§äº0ï¼éè¦åæ¸é¶
			if (stockDetail.StockQuantity > 0)
			{
			_logger.LogWarning($"åèµ°ç©ºæçæ¶åç°æ¡ç {lockInfo.CurrentBarcode} è¿æåºå {stockDetail.StockQuantity}ï¼èªå¨æ¸é¶");
			stockDetail.StockQuantity = 0;
			stockDetail.OutboundQuantity = 0;
			}

			// æ è®°ä¸ºå·²æ¸çç¶æ
			stockDetail.Status = (int)StockStatusEmun.å·²æ¸ç;

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

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

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

			if (allStockDetails.Any())
			{
			foreach (var stock in allStockDetails)
			{
			stock.StockQuantity = 0;
			stock.OutboundQuantity = 0;
			stock.Status = (int)StockStatusEmun.å·²æ¸ç;

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


			/// <summary>
			/// æ´æ°è®¢åç¶æ
			/// </summary>
			private async Task UpdateOrderStatusAfterPalletRemoval(string orderNo)
			{
			// æ£æ¥è®¢åæ¯å¦æææçé½å·²å®æ
			var allLocks = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
			.Where(x => x.OrderNo == orderNo)
			.ToListAsync();

			var unfinishedPallets = allLocks
			.GroupBy(x => x.PalletCode)
			.Where(g => g.Any(x => x.Status == (int)OutLockStockStatusEnum.åºåºä¸ \|\|
			x.Status == (int)OutLockStockStatusEnum.ååºä¸))
			.ToList();

			// å¦ææ²¡ææªå®æçæçï¼æ´æ°è®¢åç¶æä¸ºåºåºå®æ
			if (!unfinishedPallets.Any())
			{
			await _outboundOrderService.Db.Updateable<Dt_OutboundOrder>()
			.SetColumns(x => new Dt_OutboundOrder
			{
			OrderStatus = (int)OutOrderStatusEnum.åºåºå®æ,
			})
			.Where(x => x.OrderNo == orderNo)
			.ExecuteCommandAsync();
			}
			}

			/// <summary>
			/// è®°å½ç©ºç®±åèµ°åå²
			/// </summary>
			private async Task RecordEmptyPalletRemoval(string orderNo, string palletCode, List<Dt_OutStockLockInfo> completedLocks)
			{
			var removalRecord = new Dt_EmptyPalletRemoval
			{
			OrderNo = orderNo,
			PalletCode = palletCode,
			RemovalTime = DateTime.Now,
			Operator = App.User.UserName,
			CompletedItemsCount = completedLocks.Count,
			TotalPickedQuantity = completedLocks.Sum(x => x.PickedQty)
			};

			await Db.Insertable(removalRecord).ExecuteCommandAsync();
			}

			#endregion

			private List<SplitResult> CreateSplitResults(Dt_OutStockLockInfo lockInfo, decimal splitQty, decimal remainQty, string newBarcode, string originalBarcode)
			{
			return new List<SplitResult>
			{
			new SplitResult
			{
			materialCode = lockInfo.MaterielCode,
			supplierCode = lockInfo.SupplyCode,
			quantityTotal = splitQty.ToString("F2"),
			batchNumber = newBarcode,
			batch = lockInfo.BatchNo,
			factory = lockInfo.FactoryArea,
			date = DateTime.Now.ToString("yyyy-MM-dd"),
			},
			new SplitResult
			{
			materialCode = lockInfo.MaterielCode,
			supplierCode = lockInfo.SupplyCode,
			quantityTotal = remainQty.ToString("F2"),
			batchNumber = originalBarcode,
			batch = lockInfo.BatchNo,
			factory = lockInfo.FactoryArea,
			date = DateTime.Now.ToString("yyyy-MM-dd"),
			}
			};
			}



			#region æå¨æå

			/// <summary>
			/// æå¨æå
			@@ -554,12 +623,7 @@

			_unitOfWorkManage.CommitTran();

			return WebResponseContent.Instance.OK("æå¨æåæå", new
			{
			NewBarcode = splitResult.NewBarcode,
			OriginalBarcode = originalBarcode,
			SplitQuantity = splitQuantity
			});
			return WebResponseContent.Instance.OK("æå¨æåæå", splitResult);
			}
			catch (Exception ex)
			{
			@@ -617,21 +681,21 @@

			_logger.LogInformation($"æ¾å°åºåä¿¡æ¯ - åºåæ°é: {stockDetail.StockQuantity}, åºåºæ°é: {stockDetail.OutboundQuantity}");

			// éè¦ä¿®å¤ï¼éªè¯æåæ°éä¸è½å¤§äºåºåæ°é
			// éªè¯æåæ°éä¸è½å¤§äºåºåæ°é
			if (stockDetail.StockQuantity < splitQuantity)
			{
			_logger.LogWarning($"æåæ°éå¤§äºåºåæ°é - æåæ°é: {splitQuantity}, åºåæ°é: {stockDetail.StockQuantity}");
			return ValidationResult<(Dt_OutStockLockInfo, Dt_StockInfoDetail)>.Error($"æåæ°éä¸è½å¤§äºåºåæ°éï¼å½ååºåï¼{stockDetail.StockQuantity}");
			}

			// éè¦ä¿®å¤ï¼éªè¯æåæ°éä¸è½å¤§äºéå®ä¿¡æ¯çåéæ°é
			// éªè¯æåæ°éä¸è½å¤§äºéå®ä¿¡æ¯çåéæ°é
			if (lockInfo.AssignQuantity < splitQuantity)
			{
			_logger.LogWarning($"æåæ°éå¤§äºåéæ°é - æåæ°é: {splitQuantity}, åéæ°é: {lockInfo.AssignQuantity}");
			return ValidationResult<(Dt_OutStockLockInfo, Dt_StockInfoDetail)>.Error($"æåæ°éä¸è½å¤§äºåéæ°éï¼å½ååéæ°éï¼{lockInfo.AssignQuantity}");
			}

			// éè¦ä¿®å¤ï¼éªè¯æåæ°éä¸è½å¤§äºéå®ä¿¡æ¯çæªæ£éæ°é
			// éªè¯æåæ°éä¸è½å¤§äºéå®ä¿¡æ¯çæªæ£éæ°é
			decimal remainingToPick = lockInfo.AssignQuantity - lockInfo.PickedQty;
			if (remainingToPick < splitQuantity)
			{
			@@ -639,14 +703,14 @@
			return ValidationResult<(Dt_OutStockLockInfo, Dt_StockInfoDetail)>.Error($"æåæ°éä¸è½å¤§äºæªæ£éæ°éï¼å½åæªæ£éï¼{remainingToPick}");
			}

			// éè¦ä¿®å¤ï¼éªè¯æåååéå®ä¿¡æ¯çåéæ°éä¸ä¼ä¸ºè´æ°
			// éªè¯æåååéå®ä¿¡æ¯çåéæ°éä¸ä¼ä¸ºè´æ°
			if (lockInfo.AssignQuantity - splitQuantity < 0)
			{
			_logger.LogWarning($"æåååéæ°éä¸ºè´æ° - å½ååéæ°é: {lockInfo.AssignQuantity}, æåæ°é: {splitQuantity}");
			return ValidationResult<(Dt_OutStockLockInfo, Dt_StockInfoDetail)>.Error($"æåååéæ°éä¸è½ä¸ºè´æ°");
			}

			// éè¦ä¿®å¤ï¼éªè¯è®¢åæç»çåéæ°éæ¯å¦è¶³å¤
			// éªè¯è®¢åæç»çåéæ°éæ¯å¦è¶³å¤
			// æ³¨æï¼æå¨æåä¸ä¼æ¹åè®¢åæç»çåéæ°éï¼å ä¸ºæ»åéæ°éä¸å
			// åªæ¯ä»ä¸ä¸ªéå®ä¿¡æ¯è½¬ç§»å°å¦ä¸ä¸ªéå®ä¿¡æ¯
			decimal totalLockAssignQuantity = await GetTotalLockAssignQuantity(orderDetail.Id);
			@@ -674,116 +738,232 @@
			}

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

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

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

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

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

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

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

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

			// åå»ºæ°åºåæç»
			var newStockDetail = new Dt_StockInfoDetail
			{
			StockId = stockDetail.StockId,
			MaterielCode = stockDetail.MaterielCode,
			OrderNo = stockDetail.OrderNo,
			BatchNo = stockDetail.BatchNo,
			StockQuantity = splitQuantity,
			OutboundQuantity = 0,
			Barcode = newBarcode,
			Status = (int)StockStatusEmun.åºåºéå®,
			SupplyCode = stockDetail.SupplyCode,
			Unit = stockDetail.Unit,
			BarcodeQty = stockDetail.BarcodeQty,
			BarcodeUnit = stockDetail.BarcodeUnit,
			BusinessType = stockDetail.BusinessType,
			InboundOrderRowNo = stockDetail.InboundOrderRowNo,
			};

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

			// ä¿®æ£ï¼æ´æ°ååºåæç» - ç¡®ä¿æ°æ®ä¸è´æ§
			// ååºååå°æåæ°éï¼ä½åºåºæ°éä¿æä¸åï¼å ä¸ºæ¯æå¨æåï¼ä¸æ¶åå®éåºåºï¼
			stockDetail.StockQuantity -= splitQuantity;

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

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

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

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

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

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

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

			// éè¦ï¼æå¨æåä¸æ¹åè®¢åæç»çæ»åéæ°é
			// éªè¯è®¢åæç»çæ»åéæ°éæ¯å¦ä¿æä¸å
			await ValidateOrderDetailAllocationAfterSplit(lockInfo.OrderDetailId, originalLockAssignQty);

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

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

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

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

			return splitResults;
			}
			catch (Exception ex)
			{
			_logger.LogError($"æå¨æåé»è¾æ§è¡å¤±è´¥ - åæ¡ç : {stockDetail.Barcode}, æåæ°é: {splitQuantity}, Error: {ex.Message}");
			throw;
			}
			}
			/// <summary>
			/// éªè¯æååè®¢åæç»çåéæ°éæ¯å¦ä¿æä¸å
			/// </summary>
			private async Task ValidateOrderDetailAllocationAfterSplit(long orderDetailId, decimal originalTotalAssignQty)
			{
			try
			{
			// è·åè®¢åæç»çææéå®ä¿¡æ¯çæ»åéæ°é
			var allLocks = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
			.Where(x => x.OrderDetailId == orderDetailId)
			.ToListAsync();

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

			_logger.LogInformation($"æåååéæ°ééªè¯ - è®¢åæç»ID: {orderDetailId}");
			_logger.LogInformation($"åå§æ»åéæ°é: {originalTotalAssignQty}, å½åæ»åéæ°é: {totalLockAssignQty}");

			// æå¨æååæ»åéæ°éåºè¯¥ä¿æä¸å
			if (Math.Abs(originalTotalAssignQty - totalLockAssignQty) > 0.01m)
			{
			_logger.LogWarning($"æååæ»åéæ°éåçåå - ææ: {originalTotalAssignQty}, å®é: {totalLockAssignQty}");

			// å¦æååå¾å°ï¼å¯è½æ¯ç²¾åº¦é®é¢ï¼è®°å½ä½ä¸æåºå¼å¸¸
			if (Math.Abs(originalTotalAssignQty - totalLockAssignQty) > 1.0m)
			{
			throw new InvalidOperationException($"æååæ»åéæ°éå¼å¸¸ååï¼ææ: {originalTotalAssignQty}, å®é: {totalLockAssignQty}");
			}
			}
			else
			{
			_logger.LogInformation($"æåååéæ°ééªè¯éè¿ - æ»åéæ°éä¿æä¸å");
			}
			}
			catch (Exception ex)
			{
			_logger.LogError($"éªè¯æåååéæ°éå¤±è´¥ - OrderDetailId: {orderDetailId}, Error: {ex.Message}");
			throw;
			}
			}
			/// <summary>
			/// éªè¯æååæ°æ®ä¸è´æ§
			/// </summary>
			private async Task ValidateDataConsistencyAfterSplit(long orderDetailId, decimal expectedAllocatedQty, decimal expectedLockQty)
			{
			// éæ°è·åè®¢åæç»æ°æ®
			var orderDetail = await _outboundOrderDetailService.Db.Queryable<Dt_OutboundOrderDetail>()
			.FirstAsync(x => x.Id == lockInfo.OrderDetailId);
			.FirstAsync(x => x.Id == orderDetailId);

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

			// éªè¯æåæ°éä¸ä¼å¯¼è´åéæ°éä¸ºè´æ°
			if (lockInfo.AssignQuantity < splitQuantity)
			// è®¡ç®ææéå®ä¿¡æ¯çæ»åéæ°é
			var allLocks = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
			.Where(x => x.OrderDetailId == orderDetailId)
			.ToListAsync();

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

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

			// å¦ææ°æ®ä¸ä¸è´ï¼è®°å½è¦å
			if (Math.Abs(orderDetail.AllocatedQuantity - totalLockAssignQty) > 0.01m)
			{
			throw new InvalidOperationException($"æåæ°éè¶è¿éå®ä¿¡æ¯åéæ°éï¼æåæ°é: {splitQuantity}, åéæ°é: {lockInfo.AssignQuantity}");
			_logger.LogWarning($"æ°æ®ä¸ä¸è´ - è®¢åæç»åéæ°é: {orderDetail.AllocatedQuantity}, éå®ä¿¡æ¯æ»åéæ°é: {totalLockAssignQty}");
			}

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

			// è®°å½æååçåéæ°é
			decimal originalAssignQtyBefore = lockInfo.AssignQuantity;
			decimal originalOrderQtyBefore = lockInfo.OrderQuantity;

			// 1. åå»ºæ°åºåæç»
			var newStockDetail = new Dt_StockInfoDetail
			// éªè¯åéæ°éæ²¡æå¼å¸¸åå
			if (Math.Abs(orderDetail.AllocatedQuantity - expectedAllocatedQty) > 0.01m)
			{
			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}");
			_logger.LogWarning($"åéæ°éå¼å¸¸åå - ææ: {expectedAllocatedQty}, å®é: {orderDetail.AllocatedQuantity}");
			}

			// 2. æ´æ°ååºåæç»
			decimal originalStockQtyBefore = stockDetail.StockQuantity;
			stockDetail.StockQuantity -= splitQuantity;
			await _stockInfoDetailService.Db.Updateable(stockDetail).ExecuteCommandAsync();
			_logger.LogInformation($"æ´æ°ååºåæç» - åºåæ°éä» {originalStockQtyBefore} åå°å° {stockDetail.StockQuantity}");

			// 3. åå»ºæ°éå®ä¿¡æ¯
			var newLockInfo = new Dt_OutStockLockInfo
			if (Math.Abs(orderDetail.LockQuantity - expectedLockQty) > 0.01m)
			{
			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}");

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

			_logger.LogInformation($"æ´æ°åéå®ä¿¡æ¯ - åéæ°éä» {originalAssignQtyBefore} åå°å° {lockInfo.AssignQuantity}");
			_logger.LogInformation($"æ´æ°åéå®ä¿¡æ¯ - è®¢åæ°éä» {originalOrderQtyBefore} åå°å° {lockInfo.OrderQuantity}");

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

			// éè¦ä¿®å¤ï¼æå¨æåä¸ä¼æ¹åè®¢åæç»çåéæ°éï¼å ä¸ºæ»åéæ°éä¸å
			// åªæ¯ä»ä¸ä¸ªéå®ä¿¡æ¯è½¬ç§»å°å¦ä¸ä¸ªéå®ä¿¡æ¯
			_logger.LogInformation($"è®¢åæç»åéæ°éä¿æä¸å - å·²åéæ°é: {orderDetail.AllocatedQuantity}");

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

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

			return new SplitResultDto { NewBarcode = newBarcode };
			_logger.LogWarning($"éå®æ°éå¼å¸¸åå - ææ: {expectedLockQty}, å®é: {orderDetail.LockQuantity}");
			}
			}

			#endregion

			#endregion


			@@ -844,73 +1024,241 @@
			{
			_logger.LogInformation($"å¼å§æ§è¡åæ¶æåé»è¾ - åæ¡ç : {splitRecord.OriginalBarcode}, æ°æ¡ç : {splitRecord.NewBarcode}, æåæ°é: {splitRecord.SplitQty}");

			// æ¢å¤åéå®ä¿¡æ¯
			decimal originalAssignQtyBefore = originalLockInfo.AssignQuantity;
			decimal originalOrderQtyBefore = originalLockInfo.OrderQuantity;

			// éè¦ä¿®å¤ï¼æ¢å¤åéæ°éåè®¢åæ°é
			originalLockInfo.AssignQuantity += splitRecord.SplitQty;
			originalLockInfo.OrderQuantity += splitRecord.SplitQty;

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

			// å¦æåéå®ä¿¡æ¯çç¶ææ¯æ£éå®æï¼éè¦éæ°è®¾ç½®ä¸ºåºåºä¸
			if (originalLockInfo.Status == (int)OutLockStockStatusEnum.æ£éå®æ)
			try
			{
			originalLockInfo.Status = (int)OutLockStockStatusEnum.åºåºä¸;
			_logger.LogInformation($"åéå®ä¿¡æ¯ç¶æä»æ£éå®ææ¢å¤ä¸ºåºåºä¸");
			// æ ¹æ®æåç±»åè°ç¨ä¸åçå¤çæ¹æ³
			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;
			}
			}

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

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

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

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

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

			// è¾¹çæ£æ¥
			if (orderDetail.AllocatedQuantity < 0) orderDetail.AllocatedQuantity = 0;
			if (orderDetail.LockQuantity < 0) orderDetail.LockQuantity = 0;

			await _outboundOrderDetailService.Db.Updateable(orderDetail).ExecuteCommandAsync();
			_logger.LogInformation($"èªå¨æååæ¶æ¢å¤è®¢åæç» - åéæ°é: {originalAllocatedQty} -> {orderDetail.AllocatedQuantity}");

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

			if (originalStock != null)
			{
			decimal originalStockQtyBefore = originalStock.StockQuantity;
			decimal originalStockQty = 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();
			_logger.LogInformation($"èªå¨æååæ¶æ¢å¤ååºå - æ¡ç : {originalStock.Barcode}, æ°é: {originalStockQty} -> {originalStock.StockQuantity}");
			}

			// å é¤æ°éå®ä¿¡æ¯
			_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();

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

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

			_logger.LogInformation($"åæ¶æåé»è¾æ§è¡å®æ");
			// 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)
			{
			// å é¤æ°éå®ä¿¡æ¯
			if (newLockInfo != null)
			{
			_logger.LogInformation($"å é¤æ°éå®ä¿¡æ¯ - æ¡ç : {newLockInfo.CurrentBarcode}, åéæ°é: {newLockInfo.AssignQuantity}");
			await _outStockLockInfoService.Db.Deleteable<Dt_OutStockLockInfo>()
			.Where(x => x.Id == newLockInfo.Id)
			.ExecuteCommandAsync();
			}

			// å é¤æ°åºåæç»
			if (newStockDetail != null)
			{
			_logger.LogInformation($"å é¤æ°åºåæç» - æ¡ç : {newStockDetail.Barcode}, åºåæ°é: {newStockDetail.StockQuantity}");
			await _stockInfoDetailService.Db.Deleteable<Dt_StockInfoDetail>()
			.Where(x => x.Barcode == newStockDetail.Barcode)
			.ExecuteCommandAsync();
			}
			}
			/// <summary>
			/// éªè¯åæ¶æååæ°æ®ä¸è´æ§ - ææ°çæ¬
			/// </summary>
			private async Task ValidateDataConsistencyAfterCancelSplit(long orderDetailId, decimal originalAllocatedQty, decimal originalLockQty, bool isAutoSplit, decimal splitQuantity)
			{
			// éæ°è·åè®¢åæç»æ°æ®
			var orderDetail = await _outboundOrderDetailService.Db.Queryable<Dt_OutboundOrderDetail>()
			.FirstAsync(x => x.Id == orderDetailId);

			if (orderDetail == null)
			return;

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

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

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

			// æ ¹æ®æåç±»åè®¡ç®ææå¼
			decimal expectedAllocatedQty;
			decimal expectedLockQty;

			if (isAutoSplit)
			{
			// èªå¨æååæ¶ï¼åéæ°éåºè¯¥åå°æåæ°é
			expectedAllocatedQty = originalAllocatedQty - splitQuantity;
			expectedLockQty = originalLockQty - splitQuantity;

			_logger.LogInformation($"åæ¶èªå¨æåææå¼ - åéæ°é: {expectedAllocatedQty}, éå®æ°é: {expectedLockQty}");
			}
			else
			{
			// æå¨æååæ¶ï¼åéæ°éåºè¯¥ä¿æä¸å
			expectedAllocatedQty = originalAllocatedQty;
			expectedLockQty = originalLockQty;

			_logger.LogInformation($"åæ¶æå¨æåææå¼ - åéæ°é: {expectedAllocatedQty}, éå®æ°é: {expectedLockQty}");
			}

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

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

			// éªè¯åéæ°é
			if (Math.Abs(orderDetail.AllocatedQuantity - expectedAllocatedQty) > 0.01m)
			{
			_logger.LogWarning($"åæ¶æåååéæ°éå¼å¸¸ - ææ: {expectedAllocatedQty}, å®é: {orderDetail.AllocatedQuantity}");
			}

			// éªè¯éå®æ°é
			if (Math.Abs(orderDetail.LockQuantity - expectedLockQty) > 0.01m)
			{
			_logger.LogWarning($"åæ¶æååéå®æ°éå¼å¸¸ - ææ: {expectedLockQty}, å®é: {orderDetail.LockQuantity}");
			}

			// éªè¯è®¢åæç»åéæ°éä¸éå®ä¿¡æ¯æ»åéæ°éçä¸è´æ§
			if (Math.Abs(orderDetail.AllocatedQuantity - totalLockAssignQty) > 0.01m)
			{
			_logger.LogWarning($"åæ¶æååæ°æ®ä¸ä¸è´ - è®¢åæç»åéæ°é: {orderDetail.AllocatedQuantity}, éå®ä¿¡æ¯æ»åéæ°é: {totalLockAssignQty}");
			}

			// è®°å½è¯¦ç»çä¸è´æ§æ¥å
			_logger.LogInformation($"åæ¶æåæ°æ®ä¸è´æ§æ¥å - " +
			$"è®¢åæç»åéæ°é: {orderDetail.AllocatedQuantity}, " +
			$"è®¢åæç»éå®æ°é: {orderDetail.LockQuantity}, " +
			$"éå®ä¿¡æ¯æ»åéæ°é: {totalLockAssignQty}, " +
			$"æåç±»å: {(isAutoSplit ? "èªå¨" : "æå¨")}, " +
			$"æåæ°é: {splitQuantity}");
			}
			/// <summary>
			/// éªè¯åæ¶æåè¯·æ±
			/// </summary>
			@@ -943,7 +1291,7 @@

			_logger.LogInformation($"æ¾å°æ°éå®ä¿¡æ¯ - ç¶æ: {newLockInfo.Status}, å·²æ£é: {newLockInfo.PickedQty}, åéæ°é: {newLockInfo.AssignQuantity}");

			// éè¦ä¿®å¤ï¼æ£æ¥æ°æ¡ç æ¯å¦å·²è¢«åæ£
			// æ£æ¥æ°æ¡ç æ¯å¦å·²è¢«åæ£
			var newBarcodePickingRecords = await Db.Queryable<Dt_PickingRecord>()
			.Where(x => x.Barcode == newBarcode && x.OrderNo == orderNo && !x.IsCancelled)
			.ToListAsync();
			@@ -956,7 +1304,7 @@
			$"æ°æ¡ç å·²è¢«åæ£ï¼å·²æ£éæ°éï¼{totalPickedQty}ï¼ï¼è¯·ååæ¶åæ£ï¼ç¶åååæ¶æå");
			}

			// éè¦ä¿®å¤ï¼æ£æ¥åæ¡ç æ¯å¦å·²è¢«åæ£
			// æ£æ¥åæ¡ç æ¯å¦å·²è¢«åæ£
			var originalBarcodePickingRecords = await Db.Queryable<Dt_PickingRecord>()
			.Where(x => x.Barcode == splitRecord.OriginalBarcode && x.OrderNo == orderNo && !x.IsCancelled)
			.ToListAsync();
			@@ -1108,7 +1456,7 @@
			return WebResponseContent.Instance.Error("è·åæ¡ç ç¶æå¤±è´¥");
			}
			}
			/// <summary>
			/// <summary>
			/// è·åæä½å»ºè®®
			/// </summary>
			private List<string> GetOperationSuggestions(BarcodeStatusInfoDto statusInfo)
			@@ -1284,7 +1632,7 @@
			NewBarcode = x.NewBarcode,
			SplitQuantity = x.SplitQty,
			Operator = x.Operator,
			IsReverted = x.IsReverted ,
			IsReverted = x.IsReverted,
			IsAutoSplit = x.IsAutoSplit
			}).ToList()
			};
			@@ -1374,61 +1722,2590 @@

			#endregion


			#region åæ¹ååº
			#region ç»ä¸ååºé»è¾
			private async Task<Dt_Task> GetCurrentTask(string orderNo, string palletCode)
			{
			// åå°è¯éè¿è®¢åå·åæçå·æ¥æ¾ä»»å¡
			var task = await _taskRepository.Db.Queryable<Dt_Task>()
			.Where(x => x.OrderNo == orderNo && x.PalletCode == palletCode)
			.FirstAsync();

			if (task == null)
			{
			// å¦ææ¾ä¸å°ï¼åéè¿æçå·æ¥æ¾
			task = await _taskRepository.Db.Queryable<Dt_Task>()
			.Where(x => x.PalletCode == palletCode)
			.FirstAsync();
			}

			return task;
			}
			private async Task<PalletStatusAnalysis> AnalyzePalletStatus(string orderNo, string palletCode, int stockId)
			{
			var result = new PalletStatusAnalysis
			{
			OrderNo = orderNo,
			PalletCode = palletCode,
			StockId = stockId
			};

			// åææªåæ£çåºåºéå®è®°å½
			var remainingLocks = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
			.Where(it => it.OrderNo == orderNo &&
			it.PalletCode == palletCode &&
			it.Status == (int)OutLockStockStatusEnum.åºåºä¸)
			.ToListAsync();

			if (remainingLocks.Any())
			{
			result.HasRemainingLocks = true;
			result.RemainingLocks = remainingLocks;
			result.RemainingLocksReturnQty = remainingLocks.Sum(x => x.AssignQuantity - x.PickedQty);
			_logger.LogInformation($"åç°{remainingLocks.Count}æ¡æªåæ£éå®è®°å½ï¼æ»æ°é: {result.RemainingLocksReturnQty}");
			}

			// åææçä¸çåºåè´§ç©
			var palletStockGoods = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
			.Where(it => it.StockId == stockId &&
			(it.Status == StockStatusEmun.å¥åºç¡®è®¤.ObjToInt() \|\|
			it.Status == StockStatusEmun.å¥åºå®æ.ObjToInt() \|\|
			it.Status == StockStatusEmun.åºåºéå®.ObjToInt()))
			.Where(it => it.StockQuantity > 0)
			.ToListAsync();

			if (palletStockGoods.Any())
			{
			result.HasPalletStockGoods = true;
			result.PalletStockGoods = palletStockGoods;
			result.PalletStockReturnQty = palletStockGoods.Sum(x => x.StockQuantity);
			_logger.LogInformation($"åç°{palletStockGoods.Count}ä¸ªåºåè´§ç©ï¼æ»æ°é: {result.PalletStockReturnQty}");

			// è®°å½è¯¦ç»ç¶æåå¸
			var statusGroups = palletStockGoods.GroupBy(x => x.Status);
			foreach (var group in statusGroups)
			{
			_logger.LogInformation($"åºåç¶æ{group.Key}: {group.Count()}ä¸ªè´§ç©ï¼æ°é: {group.Sum(x => x.StockQuantity)}");
			}
			}

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

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

			_logger.LogInformation($"åç°{splitRecords.Count}æ¡æªæ£éæåè®°å½ï¼æ»æ°é: {result.SplitReturnQty}");
			}

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

			// 5. æ£æ¥æ¯å¦æè¿è¡ä¸çä»»å¡
			result.HasActiveTasks = await _taskRepository.Db.Queryable<Dt_Task>()
			.Where(x => x.OrderNo == orderNo && x.TaskType == TaskTypeEnum.InPick.ObjToInt() &&
			x.PalletCode == palletCode &&
			x.TaskStatus == (int)TaskStatusEnum.New)
			.AnyAsync();

			_logger.LogInformation($"æçç¶æåæå®æ - è®¢å: {orderNo}, æç: {palletCode}, " +
			$"æ»ååºæ°é: {result.TotalReturnQty}, æ¯å¦ç©ºæç: {result.IsEmptyPallet}, " +
			$"æè¿è¡ä¸ä»»å¡: {result.HasActiveTasks}");

			return result;
			}
			private async Task<decimal> CalculateSplitReturnQuantity(List<Dt_SplitPackageRecord> splitRecords, int stockId)
			{
			decimal totalQty = 0;
			var processedBarcodes = new HashSet<string>();

			foreach (var splitRecord in splitRecords)
			{
			if (splitRecord.Status != (int)SplitPackageStatusEnum.å·²æ¤é)
			continue;
			// æ£æ¥åæ¡ç
			if (!processedBarcodes.Contains(splitRecord.OriginalBarcode))
			{
			var originalStock = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
			.Where(it => it.Barcode == splitRecord.OriginalBarcode && it.StockId == stockId &&
			it.Status != StockStatusEmun.åºåºå®æ.ObjToInt())
			.FirstAsync();

			if (originalStock != null && originalStock.StockQuantity > 0)
			{
			totalQty += originalStock.StockQuantity;
			processedBarcodes.Add(splitRecord.OriginalBarcode);
			}
			}

			// æ£æ¥æ°æ¡ç
			if (!processedBarcodes.Contains(splitRecord.NewBarcode))
			{
			var newStock = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
			.Where(it => it.Barcode == splitRecord.NewBarcode && it.StockId == stockId && it.Status != StockStatusEmun.åºåºå®æ.ObjToInt())
			.FirstAsync();

			if (newStock != null && newStock.StockQuantity > 0)
			{
			totalQty += newStock.StockQuantity;
			processedBarcodes.Add(splitRecord.NewBarcode);
			}
			}
			}

			return totalQty;
			}

			/// <summary>
			/// åæ¹ååº - éæ¾æªæ£éçåºå
			/// ç»ä¸ååºæ¹æ³ - å¤çæçä¸ææå©ä½è´§ç©
			/// </summary>
			public async Task<WebResponseContent> BatchReturnStock(string orderNo, string palletCode)
			//public async Task<WebResponseContent> ExecutePalletReturn(string orderNo, string palletCode, string returnReason = "åæ¹ååº")
			//{
			// try
			// {
			// int stockId = 0;
			// Dt_StockInfo stockInfo = null;
			// PalletStatusAnalysis statusAnalysis = null;
			// _unitOfWorkManage.BeginTran();

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

			// // è·ååºåä¿¡æ¯
			// stockInfo = await _stockInfoService.Db.Queryable<Dt_StockInfo>()
			// .FirstAsync(x => x.PalletCode == palletCode);
			// if (stockInfo == null)
			// return WebResponseContent.Instance.Error($"æªæ¾å°æç {palletCode} å¯¹åºçåºåä¿¡æ¯");

			// stockId = stockInfo.Id;

			// var beforeValidationResult = await ValidateReturnData(orderNo, palletCode, stockId, true);
			// if (!beforeValidationResult)
			// {
			// _logger.LogWarning("ååºåæ°æ®éªè¯åç°é®é¢ï¼ä½ç»§ç»æ§è¡ååºæä½");
			// }
			// _logger.LogInformation($"æ¥éª¤4å®æ: ååºåæ°æ®éªè¯{(beforeValidationResult ? "éè¿" : "åç°é®é¢")}");


			// // åææçç¶æ
			// statusAnalysis = await AnalyzePalletStatusForReturn(orderNo, palletCode, stockInfo.Id);
			// _logger.LogInformation($"ãæ¥éª¤6ãæçç¶æåæå®æ");
			// _logger.LogInformation($" - æ¯å¦æååºç©å: {statusAnalysis.HasItemsToReturn}");
			// _logger.LogInformation($" - æ¯å¦ç©ºæç: {statusAnalysis.IsEmptyPallet}");
			// _logger.LogInformation($" - æ»ååºæ°é: {statusAnalysis.TotalReturnQty}");
			// _logger.LogInformation($" - æ¡ç æ°é: {statusAnalysis.AllBarcodes.Count}");

			// if (!statusAnalysis.HasItemsToReturn)
			// {
			// _logger.LogInformation($"ãæ¥éª¤7ãæ ååºç©åï¼å¤çç©ºæç");
			// var result = await HandleEmptyPalletReturn(orderNo, palletCode, stockInfo);
			// if (result.Status)
			// {
			// _unitOfWorkManage.CommitTran();
			// _logger.LogInformation($"ãç©ºæçååºæåãè®¢å: {orderNo}, æç: {palletCode}");
			// }
			// else
			// {
			// _unitOfWorkManage.RollbackTran();
			// _logger.LogError($"ãç©ºæçååºå¤±è´¥ãåå : {result.Message}");
			// }
			// return result;
			// }

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

			// try
			// {
			// // æ§è¡ååºæ°æ®æä½
			// await ExecuteReturnDataOperations(statusAnalysis);
			// }
			// catch (Exception ex)
			// {
			// _logger.LogError($"ååºæ°æ®æä½å¤±è´¥: {ex.Message}");
			// try
			// {
			// await ExecuteSimpleReturnDataOperations(statusAnalysis);
			// _logger.LogInformation($"ç®åååºæ°æ®æä½æå");
			// }
			// catch (Exception simpleEx)
			// {
			// _logger.LogError($"ç®åååºæ°æ®æä½ä¹å¤±è´¥ - {simpleEx.Message}");
			// throw new InvalidOperationException($"ååºæ°æ®æä½å¤±è´¥ï¼ä¸»æ¹æ³: {ex.Message}, ç®åæ¹æ³: {simpleEx.Message}", ex);
			// }
			// }

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

			// _unitOfWorkManage.CommitTran();

			// _logger.LogInformation($"æ¥éª¤10: å¼å§ååºåæ°æ®éªè¯");
			// var afterValidationResult = await ValidateReturnData(orderNo, palletCode, stockId, false);
			// if (!afterValidationResult)
			// {
			// _logger.LogWarning("ååºåæ°æ®éªè¯åç°é®é¢ï¼å»ºè®®æ£æ¥æ°æ®ä¸è´æ§");
			// }
			// _logger.LogInformation($"æ¥éª¤10å®æ: ååºåæ°æ®éªè¯{(afterValidationResult ? "éè¿" : "åç°é®é¢")}");

			// try
			// {
			// await CreateReturnTask(orderNo, palletCode, stockInfo);
			// _logger.LogInformation($"æ¥éª¤11æå: ååºä»»å¡åå»ºæå");
			// }
			// catch (Exception taskEx)
			// {
			// // ä»»å¡åå»ºå¤±è´¥ä¸å½±åååºæ°æ®æä½çæåï¼åªè®°å½éè¯¯
			// _logger.LogError($"æ¥éª¤11è¦å: ååºä»»å¡åå»ºå¤±è´¥ - {taskEx.Message}");
			// _logger.LogError($"ååºæ°æ®æä½å·²æåï¼ä½ä»»å¡åå»ºå¤±è´¥ï¼å¯è½éè¦æå¨å¤ç");
			// }

			// _logger.LogInformation($"ãååºæåãè®¢å: {orderNo}, æç: {palletCode}, ååºæ°é: {statusAnalysis.TotalReturnQty}");

			// return WebResponseContent.Instance.OK($"ååºæä½æåï¼å±ååºæ°éï¼{statusAnalysis.TotalReturnQty}", new
			// {
			// ReturnQuantity = statusAnalysis.TotalReturnQty,
			// ReturnBarcodes = statusAnalysis.AllBarcodes,
			// Reason = returnReason,
			// PalletCode = palletCode,
			// OrderNo = orderNo
			// });
			// }
			// catch (Exception ex)
			// {
			// _unitOfWorkManage.RollbackTran();
			// _logger.LogError($"ãååºå¤±è´¥ãè®¢å: {orderNo}, æç: {palletCode}, éè¯¯ç±»å: {ex.GetType().Name}");
			// _logger.LogError($"ãéè¯¯ä¿¡æ¯ã{ex.Message}");
			// _logger.LogError($"ãå æ ä¿¡æ¯ã{ex.StackTrace}");

			// if (ex.InnerException != null)
			// {
			// _logger.LogError($"ãåé¨éè¯¯ã{ex.InnerException.Message}");
			// }
			// return WebResponseContent.Instance.Error($"ååºæä½å¤±è´¥: {ex.Message}");
			// }
			//}

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

			_unitOfWorkManage.BeginTran();

			// æ¥æ¾æçä¸æªå®æçéå®è®°å½ï¼åªå¤çåºåºä¸çè®°å½ï¼
			var unfinishedLocks = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
			// 1. åºç¡éªè¯
			if (string.IsNullOrEmpty(orderNo) \|\| string.IsNullOrEmpty(palletCode))
			return WebResponseContent.Instance.Error("è®¢åå·åæçç ä¸è½ä¸ºç©º");

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

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

			int stockId = stockInfo.Id;

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

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

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

			_logger.LogInformation($"ãå¼å§ååºãæ»ååºæ°é: {statusAnalysis.TotalReturnQty}, æ¡ç æ°: {statusAnalysis.AllBarcodes.Count}");

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

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

			_unitOfWorkManage.CommitTran();

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

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

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

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

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

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

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

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

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

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

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

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

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

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

			// å¤çå·²åéçéå®è®°å½
			if (statusAnalysis.HasRemainingLocks)
			{
			await HandleAllocatedLocksReturn(statusAnalysis.RemainingLocks);
			}

			// å¤çæªåéçéå®è®°å½
			if (statusAnalysis.HasUnallocatedLocks)
			{
			await HandleUnallocatedLocksReturn(statusAnalysis.UnallocatedLocks);
			}

			// å¤çæªåéçåºåè´§ç©
			if (statusAnalysis.HasPalletStockGoods)
			{
			await HandleUnallocatedStockReturn(statusAnalysis.PalletStockGoods);
			}

			// å¤çæåè®°å½
			if (statusAnalysis.HasSplitRecords)
			{
			await HandleSplitRecordsReturn(statusAnalysis.SplitRecords, statusAnalysis.StockId);
			}
			}

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

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

			var stillOutboundLocked = stockDetails.Where(x =>
			x.Status == (int)StockStatusEmun.åºåºéå® && x.StockQuantity > 0).ToList();

			if (stillOutboundLocked.Any())
			{
			_logger.LogWarning($"ååºåä»æåºåºéå®ç¶æçåºå: {stillOutboundLocked.Count}ä¸ª");
			}

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

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

			if (notReturnedLocks.Any())
			{
			_logger.LogWarning($"ååºåä»ææªååºç¶æçéå®è®°å½: {notReturnedLocks.Count}æ¡");
			}

			// 3. æ°æ®ä¸è´æ§éªè¯
			decimal totalStock = stockDetails.Sum(x => x.StockQuantity);
			_logger.LogInformation($"ååºååºåæ»é: {totalStock}");

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


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

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

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

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

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

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

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

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

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

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

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

			private string GetLockStatusName(int status)
			{
			return status switch
			{
			1 => "åºåºä¸",
			2 => "æ£éå®æ",
			3 => "å·²ååº",
			4 => "å·²åèµ°",
			_ => $"æªç¥({status})"
			};
			}
			/// <summary>
			/// ç®åååºæ°æ®æä½ï¼å½ä¸»æ¹æ³å¤±è´¥æ¶ä½¿ç¨ï¼
			/// </summary>
			private async Task ExecuteSimpleReturnDataOperations(PalletStatusAnalysis statusAnalysis)
			{
			_logger.LogInformation($"ãç®åååºãå¼å§æ§è¡ç®åååºæä½");

			try
			{
			// è·åè¯¥æççæææ¡ç
			var allStockDetails = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
			.Where(x => x.StockId == statusAnalysis.StockId && x.StockQuantity > 0)
			.ToListAsync();

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

			foreach (var stockDetail in allStockDetails)
			{
			// æ¢å¤ææåºåç¶æä¸ºå¥åºå®æ
			if (stockDetail.Status == (int)StockStatusEmun.åºåºéå®)
			{
			stockDetail.Status = (int)StockStatusEmun.å¥åºå®æ;

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

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

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

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

			_logger.LogInformation($"ãç®åååºãå®æ - å¤ç {allStockDetails.Count} ä¸ªæ¡ç , {allLocks.Count} æ¡éå®è®°å½");
			}
			catch (Exception ex)
			{
			_logger.LogError($"ç®åååºå¤±è´¥: {ex.Message}");
			throw;
			}
			}
			/// <summary>
			/// æ§è¡ååºæ°æ®æä½ - ç®åçæ¬
			/// </summary>
			private async Task ExecuteReturnDataOperations(PalletStatusAnalysis statusAnalysis)
			{
			_logger.LogInformation($"å¼å§æ§è¡ååºæ°æ®æä½ - è®¢å: {statusAnalysis.OrderNo}, æç: {statusAnalysis.PalletCode}");

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

			_logger.LogInformation($"ååºæ°æ®æä½å®æ - æ»ååºæ°é: {totalReturnedQty}, å¤çæ¡ç æ°: {processedBarcodes.Count}");
			}
			catch (Exception ex)
			{
			_logger.LogError($"ååºæ°æ®æä½å¤±è´¥ - è®¢å: {statusAnalysis.OrderNo}, æç: {statusAnalysis.PalletCode}, Error: {ex.Message}");
			throw;
			}
			}
			/// <summary>
			/// å¤çåºåååº - ç®åé»è¾
			/// </summary>
			private async Task ProcessStockForReturn(string barcode, int stockId, decimal returnQty)
			{
			try
			{
			var stockDetail = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
			.FirstAsync(x => x.Barcode == barcode && x.StockId == stockId);

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

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

			// ç®åå¤çï¼å¦æåºåæ°éå¤§äº0ï¼æ¢å¤ä¸ºå¥åºå®æç¶æ
			if (stockDetail.StockQuantity > 0)
			{
			stockDetail.Status = (int)StockStatusEmun.å¥åºå®æ;
			}

			// è°æ´åºåºæ°éï¼é¿ååºç°è´æ°ï¼
			if (stockDetail.OutboundQuantity > 0)
			{
			stockDetail.OutboundQuantity = Math.Max(0, stockDetail.OutboundQuantity - returnQty);
			}
			await _stockInfoDetailService.Db.Updateable(stockDetail).ExecuteCommandAsync();

			_logger.LogInformation($"åºåååºå¤ç - æ¡ç : {barcode}, ç¶æ: {originalStatus} -> {stockDetail.Status}, " +
			$"åºå: {originalStockQty} -> {stockDetail.StockQuantity}, " +
			$"åºåº: {originalOutboundQty} -> {stockDetail.OutboundQuantity}");
			}
			catch (Exception ex)
			{
			_logger.LogError($"å¤çåºåååºå¤±è´¥ - æ¡ç : {barcode}, Error: {ex.Message}");
			throw;
			}
			}
			/// <summary>
			/// ä¸ºéå®è®°å½åå°è®¢åæç»çåéæ°é
			/// </summary>
			private async Task ReduceOrderDetailAllocationForLock(long orderDetailId, decimal reduceQty)
			{
			if (orderDetailId <= 0)
			return;

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

			if (orderDetail == null)
			return;

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

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

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

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

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

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

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

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

			/// <summary>
			/// å¤çæªåéçéå®è®°å½ååº
			/// ä¸éè¦åå°è®¢åæç»çåéæ°é
			/// </summary>
			private async Task HandleUnallocatedLocksReturn(List<Dt_OutStockLockInfo> unallocatedLocks)
			{
			_logger.LogInformation($"å¼å§å¤çæªåééå®è®°å½ååº - å± {unallocatedLocks.Count} æ¡è®°å½");

			foreach (var lockInfo in unallocatedLocks)
			{
			// è®¡ç®ååºæ°éï¼æªæ£éçé¨åï¼
			decimal returnQty = lockInfo.AssignQuantity - lockInfo.PickedQty;

			if (returnQty <= 0)
			{
			_logger.LogInformation($"è·³è¿æªåééå®è®°å½ - éå®ID: {lockInfo.Id}, å·²æ£éå®æææ éååº");
			continue;
			}

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

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

			if (stockDetail != null)
			{
			// æ¢å¤åºåæ°é
			decimal originalStockQty = stockDetail.StockQuantity;
			stockDetail.StockQuantity += returnQty;

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

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

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

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

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

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

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

			// æè®¢åæç»åç»å¤ç
			var orderDetailGroups = allocatedLocks.GroupBy(x => x.OrderDetailId);

			foreach (var group in orderDetailGroups)
			{
			var orderDetailId = group.Key;
			var groupLocks = group.ToList();

			_logger.LogInformation($"å¤çè®¢åæç» {orderDetailId} ç {groupLocks.Count} æ¡éå®è®°å½");

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

			if (orderDetail == null)
			{
			_logger.LogWarning($"æªæ¾å°è®¢åæç» - OrderDetailId: {orderDetailId}");
			continue;
			}

			decimal totalReturnQtyForDetail = 0;

			foreach (var lockInfo in groupLocks)
			{
			// è®¡ç®ååºæ°éï¼æªæ£éçé¨åï¼
			decimal returnQty = lockInfo.AssignQuantity - lockInfo.PickedQty;

			if (returnQty <= 0)
			{
			_logger.LogInformation($"è·³è¿éå®è®°å½ - éå®ID: {lockInfo.Id}, å·²æ£éå®æææ éååº");
			continue;
			}

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

			// æ¢å¤åºåç¶æ
			await RestoreStockForLockInfo(lockInfo, returnQty);

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

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

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

			totalReturnQtyForDetail += returnQty;
			}

			// åå°è®¢åæç»çåéæ°é
			if (totalReturnQtyForDetail > 0)
			{
			await ReduceOrderDetailAllocation(orderDetail, totalReturnQtyForDetail);
			}
			}

			_logger.LogInformation($"å·²åééå®è®°å½ååºå¤çå®æ - å±å¤ç {allocatedLocks.Count} æ¡è®°å½");
			}
			/// <summary>
			/// æ¢å¤éå®è®°å½å¯¹åºçåºå
			/// </summary>
			private async Task RestoreStockForLockInfo(Dt_OutStockLockInfo lockInfo, decimal returnQty)
			{
			var stockDetail = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
			.FirstAsync(x => x.Barcode == lockInfo.CurrentBarcode && x.StockId == lockInfo.StockId);

			if (stockDetail != null)
			{
			// è®°å½æ¢å¤åçåºåç¶æ
			decimal originalStockQty = stockDetail.StockQuantity;
			decimal originalOutboundQty = stockDetail.OutboundQuantity;

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

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

			// æ¢å¤åºåç¶æä¸ºå¯ç¨ç¶æ
			if (stockDetail.Status == (int)StockStatusEmun.åºåºéå®)
			{
			stockDetail.Status = (int)StockStatusEmun.å¥åºå®æ;
			_logger.LogInformation($"åºåç¶ææ´æ°ä¸ºå¥åºå®æ - æ¡ç : {stockDetail.Barcode}");
			}

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

			_logger.LogInformation($"æ¢å¤åºåç¶æ - æ¡ç : {stockDetail.Barcode}, " +
			$"åºåæ°é: {originalStockQty} -> {stockDetail.StockQuantity}, " +
			$"åºåºæ°é: {originalOutboundQty} -> {stockDetail.OutboundQuantity}");
			}
			else
			{
			_logger.LogWarning($"æªæ¾å°å¯¹åºçåºåä¿¡æ¯ - æ¡ç : {lockInfo.CurrentBarcode}, StockId: {lockInfo.StockId}");
			}
			}
			/// <summary>
			/// åå»ºååºä»»å¡
			/// </summary>
			private async Task CreateReturnTask(string orderNo, string palletCode, Dt_StockInfo stockInfo)
			{
			// è·åå½åä»»å¡ä¿¡æ¯
			var currentTask = await _taskRepository.Db.Queryable<Dt_Task>()
			.Where(x => x.OrderNo == orderNo && x.PalletCode == palletCode)
			.FirstAsync();

			if (currentTask != null)
			{
			// åéæ°è´§ä½
			var newLocation = _locationInfoService.AssignLocation(stockInfo.LocationType);

			var returnTask = new Dt_Task()
			{
			CurrentAddress = stations[currentTask.TargetAddress],
			Grade = 0,
			PalletCode = palletCode,
			NextAddress = "",
			OrderNo = orderNo,
			Roadway = newLocation.RoadwayNo,
			SourceAddress = stations[currentTask.TargetAddress],
			TargetAddress = newLocation.LocationCode,
			TaskStatus = TaskStatusEnum.New.ObjToInt(),
			TaskType = TaskTypeEnum.InPick.ObjToInt(),
			PalletType = stockInfo.PalletType,
			WarehouseId = currentTask.WarehouseId
			};
			var targetAddress = currentTask.TargetAddress;

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

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

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

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

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

			_logger.LogInformation($"åå»ºååºä»»å¡æå - è®¢å: {orderNo}, æç: {palletCode}");
			}
			}
			/// <summary>
			/// æ´æ°ååºåçè®¢åç¶æ
			/// </summary>
			private async Task UpdateOrderStatusAfterReturn(string orderNo)
			{
			// æ£æ¥è®¢åæ¯å¦è¿ææªå®æçéå®è®°å½
			var activeLocks = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
			.Where(x => x.OrderNo == orderNo &&
			(x.Status == (int)OutLockStockStatusEnum.åºåºä¸ \|\|
			x.Status == (int)OutLockStockStatusEnum.ååºä¸))
			.ToListAsync();

			if (!activeLocks.Any())
			{
			// ææéå®è®°å½é½å·²å®ææå·²ååºï¼æ´æ°è®¢åç¶æ
			await _outboundOrderService.Db.Updateable<Dt_OutboundOrder>()
			.SetColumns(x => new Dt_OutboundOrder
			{
			OrderStatus = (int)OutOrderStatusEnum.åºåºå®æ,
			})
			.Where(x => x.OrderNo == orderNo)
			.ExecuteCommandAsync();

			_logger.LogInformation($"æ´æ°è®¢åç¶æä¸ºåºåºå®æ - è®¢å: {orderNo}");
			}
			}

			/// <summary>
			/// å¤çç©ºæçååº
			/// </summary>
			private async Task<WebResponseContent> HandleEmptyPalletReturn(string orderNo, string palletCode, Dt_StockInfo stockInfo)
			{
			_logger.LogInformation($"å¤çç©ºæçååº - è®¢å: {orderNo}, æç: {palletCode}");

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

			// åå»ºç©ºæçåºåè®°å½
			var emptyStockInfo = new Dt_StockInfo()
			{
			PalletType = PalletTypeEnum.Empty.ObjToInt(),
			StockStatus = StockStatusEmun.ç»çæå.ObjToInt(),
			PalletCode = palletCode,
			LocationType = stockInfo.LocationType
			};
			emptyStockInfo.Details = new List<Dt_StockInfoDetail>();
			_stockInfoService.AddMaterielGroup(emptyStockInfo);

			// åå»ºç©ºæçååºä»»å¡
			await CreateReturnTask(orderNo, palletCode, emptyStockInfo);

			return WebResponseContent.Instance.OK("ç©ºæçååºæå");
			}
			catch (Exception ex)
			{
			_logger.LogError($"ç©ºæçååºå¤±è´¥: {ex.Message}");
			return WebResponseContent.Instance.Error($"ç©ºæçååºå¤±è´¥: {ex.Message}");
			}
			}
			/// <summary>
			/// åææçç¶æç¨äºååº
			/// ç¡®ä¿ä¸ä¼éè¯¯è¯å«éè¦ååºçç©å
			/// </summary>

			/// <summary>
			/// åææçç¶æç¨äºååº - å®æ´çæ¬
			/// ç¡®ä¿ä¸ä¼éè¯¯è¯å«éè¦ååºçç©åï¼é¿åéå¤è®¡ç®
			/// </summary>
			private async Task<PalletStatusAnalysis> AnalyzePalletStatusForReturn(string orderNo, string palletCode, int stockId)
			{
			var result = new PalletStatusAnalysis
			{
			OrderNo = orderNo,
			PalletCode = palletCode,
			StockId = stockId,
			AllBarcodes = new List<string>(),
			RemainingLocks = new List<Dt_OutStockLockInfo>(),
			UnallocatedLocks = new List<Dt_OutStockLockInfo>(),
			PalletStockGoods = new List<Dt_StockInfoDetail>(),
			SplitRecords = new List<Dt_SplitPackageRecord>()
			};

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

			try
			{
			// 1. åæææéå®è®°å½ï¼ç¶æä¸ºåºåºä¸ï¼
			var allUnfinishedLocks = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
			.Where(x => x.OrderNo == orderNo &&
			x.PalletCode == palletCode &&
			x.Status == (int)OutLockStockStatusEnum.åºåºä¸)
			.ToListAsync();

			if (!unfinishedLocks.Any())
			return WebResponseContent.Instance.Error("è¯¥æçæ²¡ææªå®æçéå®è®°å½");

			// æåºåºæ¹æ¬¡åç»å¤ç
			var batchGroups = unfinishedLocks.GroupBy(x => x.OutboundBatchNo); // ä½¿ç¨ OutboundBatchNo

			foreach (var batchGroup in batchGroups)
			if (allUnfinishedLocks.Any())
			{
			var outboundBatchNo = batchGroup.Key;
			var batchLocks = batchGroup.ToList();
			_logger.LogInformation($"æ¾å° {allUnfinishedLocks.Count} æ¡åºåºä¸ç¶æçéå®è®°å½");

			// éæ¾åºååéå®è®°å½
			foreach (var lockInfo in batchLocks)
			// åºåå·²åéåæªåéçéå®è®°å½
			var allocatedLocks = allUnfinishedLocks
			.Where(x => x.IsUnallocated != 1 && x.OrderDetailId > 0)
			.ToList();

			var unallocatedLocks = allUnfinishedLocks
			.Where(x => x.IsUnallocated == 1 \|\| x.OrderDetailId == 0)
			.ToList();

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

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

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

			// æ´æ°æ¹æ¬¡ç¶æ
			await UpdateBatchStatusForReturn(outboundBatchNo, batchLocks);
			// å¤çæªåéçéå®è®°å½ï¼å¦èªå¨æåäº§ççï¼
			if (unallocatedLocks.Any())
			{
			result.HasUnallocatedLocks = true;
			result.UnallocatedLocks = unallocatedLocks;
			result.UnallocatedLocksReturnQty = unallocatedLocks.Sum(x => x.AssignQuantity - x.PickedQty);

			// æ´æ°è®¢åæç»çå·²åéæ°é
			await UpdateOrderDetailAfterReturn(batchLocks);
			foreach (var lockInfo in unallocatedLocks)
			{
			if (!string.IsNullOrEmpty(lockInfo.CurrentBarcode))
			{
			result.AllBarcodes.Add(lockInfo.CurrentBarcode);
			}
			}

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

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

			if (allStockDetails.Any())
			{
			_logger.LogInformation($"æ¾å° {allStockDetails.Count} ä¸ªåºåºéå®ç¶æçåºåè´§ç©");

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

			_logger.LogInformation($"è¿æ»¤åå©ä½ {unlockedStockGoods.Count} ä¸ªæªè¢«éå®çåºåè´§ç©");

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

			if (!hasActiveLock)
			{
			trulyUnallocatedGoods.Add(stock);
			}
			else
			{
			_logger.LogInformation($"æ¡ç {stock.Barcode} ææ´»è·çéå®è®°å½ï¼è·³è¿ä½ä¸ºæªåéåºå");
			}
			}

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

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

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

			// è®°å½æ¯ä¸ªè´§ç©çè¯¦ç»ä¿¡æ¯
			foreach (var stock in trulyUnallocatedGoods)
			{
			_logger.LogInformation($"æªåéåºå - æ¡ç : {stock.Barcode}, ç©æ: {stock.MaterielCode}, æ°é: {stock.StockQuantity}");
			}
			}
			}
			else
			{
			_logger.LogInformation($"æªæ¾å°åºåºéå®ç¶æçåºåè´§ç©");
			}

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

			if (splitRecords.Any())
			{
			result.HasSplitRecords = true;
			result.SplitRecords = splitRecords;

			// è®¡ç®æåè®°å½ç¸å³çååºæ°éï¼é¿åéå¤è®¡ç®ï¼
			var splitBarcodes = new HashSet<string>();
			decimal splitReturnQty = 0;

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

			if (originalStock != null && originalStock.StockQuantity > 0)
			{
			splitReturnQty += originalStock.StockQuantity;

			// æ·»å å°æææ¡ç åè¡¨ï¼å¦ææ²¡æéå¤ï¼
			if (!result.AllBarcodes.Contains(splitRecord.OriginalBarcode))
			{
			result.AllBarcodes.Add(splitRecord.OriginalBarcode);
			}

			splitBarcodes.Add(splitRecord.OriginalBarcode);
			_logger.LogInformation($"æåè®°å½ - åæ¡ç : {splitRecord.OriginalBarcode}, æ°é: {originalStock.StockQuantity}");
			}
			}

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

			if (newStock != null && newStock.StockQuantity > 0)
			{
			splitReturnQty += newStock.StockQuantity;

			// æ·»å å°æææ¡ç åè¡¨ï¼å¦ææ²¡æéå¤ï¼
			if (!result.AllBarcodes.Contains(splitRecord.NewBarcode))
			{
			result.AllBarcodes.Add(splitRecord.NewBarcode);
			}

			splitBarcodes.Add(splitRecord.NewBarcode);
			_logger.LogInformation($"æåè®°å½ - æ°æ¡ç : {splitRecord.NewBarcode}, æ°é: {newStock.StockQuantity}");
			}
			}

			// è®°å½æåä¿¡æ¯
			_logger.LogInformation($"æåè®°å½ - ID: {splitRecord.Id}, åæ¡ç : {splitRecord.OriginalBarcode}, " +
			$"æ°æ¡ç : {splitRecord.NewBarcode}, æåæ°é: {splitRecord.SplitQty}, " +
			$"æ¯å¦èªå¨: {splitRecord.IsAutoSplit}, æ¯å¦æ¤é: {splitRecord.IsReverted}");
			}

			result.SplitReturnQty = splitReturnQty;
			_logger.LogInformation($"åç°{splitRecords.Count}æ¡æåè®°å½ï¼å³è {splitBarcodes.Count} ä¸ªæ¡ç ï¼æ»æ°é: {splitReturnQty}");
			}
			else
			{
			_logger.LogInformation($"æªæ¾å°éè¦ååºçæåè®°å½");
			}

			// 4. è®¡ç®æ»ååºæ°éåç©ºæçç¶æ
			result.TotalReturnQty = result.RemainingLocksReturnQty +
			result.UnallocatedLocksReturnQty +
			result.PalletStockReturnQty +
			result.SplitReturnQty;

			result.HasItemsToReturn = result.TotalReturnQty > 0;
			result.IsEmptyPallet = !result.HasItemsToReturn;

			// å»éæææ¡ç
			result.AllBarcodes = result.AllBarcodes.Distinct().ToList();

			_logger.LogInformation($"æçç¶æåæå®æ - è®¢å: {orderNo}, æç: {palletCode}");
			_logger.LogInformation($"æ±æ»ä¿¡æ¯:");
			_logger.LogInformation($" - å·²åééå®è®°å½: {result.RemainingLocks.Count} æ¡, æ°é: {result.RemainingLocksReturnQty}");
			_logger.LogInformation($" - æªåééå®è®°å½: {result.UnallocatedLocks.Count} æ¡, æ°é: {result.UnallocatedLocksReturnQty}");
			_logger.LogInformation($" - æªåéåºåè´§ç©: {result.PalletStockGoods.Count} ä¸ª, æ°é: {result.PalletStockReturnQty}");
			_logger.LogInformation($" - æåè®°å½: {result.SplitRecords.Count} æ¡, æ°é: {result.SplitReturnQty}");
			_logger.LogInformation($" - æ»ååºæ°é: {result.TotalReturnQty}");
			_logger.LogInformation($" - æ¯å¦ç©ºæç: {result.IsEmptyPallet}");
			_logger.LogInformation($" - æ¶åæ¡ç : {string.Join(", ", result.AllBarcodes)}");

			// 5. é¢å¤çæ°æ®éªè¯
			await ValidateAnalysisResults(result, stockId);

			return result;
			}
			catch (Exception ex)
			{
			_logger.LogError($"æçç¶æåæå¤±è´¥ - è®¢å: {orderNo}, æç: {palletCode}, Error: {ex.Message}");
			throw;
			}
			}

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

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

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

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

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

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

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

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

			/// <summary>
			/// å¤çæªåæ£çéå®è®°å½ååº
			/// ç¡®ä¿ä¸ä¼éè¯¯ç»å®æ¡ç æ°éå°éå®æ°é
			/// </summary>
			private async Task HandleRemainingLocksReturn(List<Dt_OutStockLockInfo> remainingLocks)
			{
			_logger.LogInformation($"å¼å§å¤çæªåæ£éå®è®°å½ååº - å± {remainingLocks.Count} æ¡è®°å½");

			// æè®¢åæç»åç»å¤çï¼ç¡®ä¿è®¢åæç»æ°æ®çä¸è´æ§
			var orderDetailGroups = remainingLocks.GroupBy(x => x.OrderDetailId);

			foreach (var group in orderDetailGroups)
			{
			var orderDetailId = group.Key;
			var groupLocks = group.ToList();

			_logger.LogInformation($"å¤çè®¢åæç» {orderDetailId} ç {groupLocks.Count} æ¡éå®è®°å½");

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

			if (orderDetail == null)
			{
			_logger.LogWarning($"æªæ¾å°è®¢åæç» - OrderDetailId: {orderDetailId}");
			continue;
			}

			decimal totalReturnQtyForDetail = 0;

			foreach (var lockInfo in groupLocks)
			{
			// åªå¤çç¶æä¸ºåºåºä¸çéå®è®°å½
			if (lockInfo.Status != (int)OutLockStockStatusEnum.åºåºä¸)
			{
			_logger.LogInformation($"è·³è¿éåºåºä¸ç¶æçéå®è®°å½ - éå®ID: {lockInfo.Id}, ç¶æ: {lockInfo.Status}");
			continue;
			}

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

			if (returnQty <= 0)
			{
			_logger.LogInformation($"è·³è¿éå®è®°å½ - éå®ID: {lockInfo.Id}, å·²æ£éå®æææ éååº");
			continue;
			}

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

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

			if (stockDetail != null)
			{
			// è®°å½æ¢å¤åçåºåç¶æ
			decimal originalStockQty = stockDetail.StockQuantity;
			decimal originalOutboundQty = stockDetail.OutboundQuantity;

			// åªæ¢å¤å®éçåºåæ°éï¼ä¸åå»ºæ°çæ¡ç æç»å®
			// æ¢å¤åºåæ°éï¼åºåºæ°éåå°ï¼åºåæ°éå¢å
			stockDetail.OutboundQuantity -= returnQty;
			stockDetail.StockQuantity += returnQty;

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

			// æ¢å¤åºåç¶æä¸ºå¯ç¨ç¶æ
			if (stockDetail.Status == (int)StockStatusEmun.åºåºéå®)
			{
			stockDetail.Status = (int)StockStatusEmun.å¥åºå®æ;
			_logger.LogInformation($"åºåç¶ææ´æ°ä¸ºå¥åºå®æ - æ¡ç : {stockDetail.Barcode}");
			}

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

			_logger.LogInformation($"æ¢å¤åºåç¶æ - æ¡ç : {stockDetail.Barcode}, " +
			$"åºåæ°é: {originalStockQty} -> {stockDetail.StockQuantity}, " +
			$"åºåºæ°é: {originalOutboundQty} -> {stockDetail.OutboundQuantity}");
			}
			else
			{
			_logger.LogWarning($"æªæ¾å°å¯¹åºçåºåä¿¡æ¯ - æ¡ç : {lockInfo.CurrentBarcode}, StockId: {lockInfo.StockId}");
			// éè¦ï¼å¦ææ¾ä¸å°åºåä¿¡æ¯ï¼è·³è¿æ¤éå®è®°å½ï¼é¿åæ°æ®ä¸ä¸è´
			continue;
			}

			// æ´æ°éå®è®°å½ç¶æä¸ºå·²ååºï¼ä½ä¸ä¿®æ¹åéæ°é
			// åéæ°éå¨è®¢åæç»å±é¢ç»ä¸å¤ç
			var originalStatus = lockInfo.Status;
			lockInfo.Status = (int)OutLockStockStatusEnum.å·²ååº;
			lockInfo.Operator = App.User.UserName;

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

			_logger.LogInformation($"æ´æ°éå®ç¶æ - éå®ID: {lockInfo.Id}, ç¶æ: {originalStatus} -> {lockInfo.Status}");

			totalReturnQtyForDetail += returnQty;

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

			// åå°è®¢åæç»çåéæ°é
			if (totalReturnQtyForDetail > 0)
			{
			await ReduceOrderDetailAllocation(orderDetail, totalReturnQtyForDetail);
			}
			}

			_logger.LogInformation($"æªåæ£éå®è®°å½ååºå¤çå®æ - å±å¤ç {remainingLocks.Count} æ¡è®°å½");
			}
			/// <summary>
			/// å¤çæªåéçåºåè´§ç©ååº
			/// ç¡®ä¿ä¸ä¼åå»ºæ°çéå®è®°å½
			/// </summary>
			private async Task HandleUnallocatedStockReturn(List<Dt_StockInfoDetail> stockGoods)
			{
			_logger.LogInformation($"å¼å§å¤çæªåéåºåååº - å± {stockGoods.Count} ä¸ªè´§ç©");

			foreach (var stockDetail in stockGoods)
			{
			if (stockDetail.StockQuantity <= 0)
			{
			_logger.LogInformation($"è·³è¿é¶åºåè´§ç© - æ¡ç : {stockDetail.Barcode}");
			continue;
			}

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

			// æ£æ¥æ¯å¦å·²ç»æå¯¹åºçéå®è®°å½
			var existingLock = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
			.Where(x => x.CurrentBarcode == stockDetail.Barcode &&
			x.Status == (int)OutLockStockStatusEnum.åºåºä¸)
			.FirstAsync();

			if (existingLock != null)
			{
			_logger.LogWarning($"åºåæ¡ç {stockDetail.Barcode} å·²æéå®è®°å½ï¼è·³è¿ç´æ¥ååºå¤ç");
			continue;
			}

			// è®°å½æ¢å¤åçç¶æ
			var originalStatus = stockDetail.Status;

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

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

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

			_logger.LogInformation($"æªåéåºåååºå¤çå®æ - å±å¤ç {stockGoods.Count} ä¸ªè´§ç©");
			}
			/// <summary>
			/// åå°è®¢åæç»çåéæ°é
			/// ç¡®ä¿åéæ°éçåå°æ¯åç¡®ç
			/// </summary>
			private async Task ReduceOrderDetailAllocation(Dt_OutboundOrderDetail orderDetail, decimal reduceQty)
			{
			if (orderDetail == null)
			return;

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

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

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

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

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

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

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

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

			// éªè¯æ°æ®ä¸è´æ§
			await ValidateOrderDetailConsistency(orderDetail.Id);
			}
			/// <summary>
			/// éªè¯è®¢åæç»æ°æ®ä¸è´æ§
			/// </summary>
			private async Task ValidateOrderDetailConsistency(long orderDetailId)
			{
			var orderDetail = await _outboundOrderDetailService.Db.Queryable<Dt_OutboundOrderDetail>()
			.FirstAsync(x => x.Id == orderDetailId);

			if (orderDetail == null)
			return;

			// è®¡ç®ææç¸å³éå®è®°å½çæ»åéæ°é
			var relatedLocks = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
			.Where(x => x.OrderDetailId == orderDetailId &&
			x.Status != (int)OutLockStockStatusEnum.å·²ååº)
			.ToListAsync();

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

			// éªè¯è®¢åæç»åéæ°éä¸éå®è®°å½æ»åéæ°éçä¸è´æ§
			if (Math.Abs(orderDetail.AllocatedQuantity - totalLockAssignQty) > 0.01m)
			{
			_logger.LogWarning($"æ°æ®ä¸ä¸è´è¦å - OrderDetailId: {orderDetailId}, " +
			$"è®¢åæç»åéæ°é: {orderDetail.AllocatedQuantity}, " +
			$"éå®è®°å½æ»åéæ°é: {totalLockAssignQty}");
			}
			else
			{
			_logger.LogInformation($"æ°æ®ä¸è´æ§éªè¯éè¿ - OrderDetailId: {orderDetailId}");
			}
			}
			/// <summary>
			/// åæ¹ååº - è°ç¨ç»ä¸ååºæ¹æ³
			/// </summary>
			public async Task<WebResponseContent> BatchReturnStock(string orderNo, string palletCode)
			{
			return await ExecutePalletReturn(orderNo, palletCode, "åæ¹ååº");
			}

			/// <summary>
			/// å©ä½ååº - è°ç¨ç»ä¸ååºæ¹æ³
			/// </summary>
			public async Task<WebResponseContent> ReturnRemaining(string orderNo, string palletCode, string reason)
			{
			return await ExecutePalletReturn(orderNo, palletCode, reason);
			}

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

			_unitOfWorkManage.BeginTran();

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

			// ç»§ç»éªè¯ç©ºç®±åèµ°æ¡ä»¶
			}

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

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

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

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

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

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

			_unitOfWorkManage.CommitTran();

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

			return WebResponseContent.Instance.OK("åèµ°ç©ºç®±æå");
			}
			catch (Exception ex)
			{
			_unitOfWorkManage.RollbackTran();
			_logger.LogError($"åæ¹ååºå¤±è´¥ - OrderNo: {orderNo}, PalletCode: {palletCode}, Error: {ex.Message}");
			return WebResponseContent.Instance.Error($"åæ¹ååºå¤±è´¥ï¼{ex.Message}");
			_logger.LogError($"åèµ°ç©ºç®±å¤±è´¥ - OrderNo: {orderNo}, PalletCode: {palletCode}, Error: {ex.Message}");
			return WebResponseContent.Instance.Error($"åèµ°ç©ºç®±å¤±è´¥ï¼{ex.Message}");
			}
			}
			/// <summary>
			/// æ¶ééè¦ååºçæ¡ç
			/// </summary>
			private async Task<List<string>> CollectReturnBarcodes(PalletStatusAnalysis status)
			{
			var returnBarcodes = new HashSet<string>();

			try
			{
			_logger.LogInformation($"å¼å§æ¶éååºæ¡ç - è®¢å: {status.OrderNo}, æç: {status.PalletCode}");

			// 1. æ¶éæªåæ£éå®è®°å½çæ¡ç
			if (status.HasRemainingLocks)
			{
			foreach (var lockInfo in status.RemainingLocks)
			{
			if (!string.IsNullOrEmpty(lockInfo.CurrentBarcode))
			{
			returnBarcodes.Add(lockInfo.CurrentBarcode);
			_logger.LogInformation($"æ·»å éå®è®°å½æ¡ç : {lockInfo.CurrentBarcode}");
			}
			}
			}

			// 2. æ¶éæçä¸åºåè´§ç©çæ¡ç
			if (status.HasPalletStockGoods)
			{
			foreach (var stockDetail in status.PalletStockGoods)
			{
			if (!string.IsNullOrEmpty(stockDetail.Barcode) && stockDetail.StockQuantity > 0)
			{
			returnBarcodes.Add(stockDetail.Barcode);
			_logger.LogInformation($"æ·»å åºåè´§ç©æ¡ç : {stockDetail.Barcode}, æ°é: {stockDetail.StockQuantity}");
			}
			}
			}

			// 3. æ¶éæåè®°å½ç¸å³çæ¡ç
			if (status.HasSplitRecords)
			{
			foreach (var splitRecord in status.SplitRecords)
			{
			// æ·»å åæ¡ç
			if (!string.IsNullOrEmpty(splitRecord.OriginalBarcode))
			{
			var originalStock = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
			.FirstAsync(x => x.Barcode == splitRecord.OriginalBarcode && x.StockId == status.StockId);

			if (originalStock != null && originalStock.StockQuantity > 0)
			{
			returnBarcodes.Add(splitRecord.OriginalBarcode);
			_logger.LogInformation($"æ·»å æååæ¡ç : {splitRecord.OriginalBarcode}, æ°é: {originalStock.StockQuantity}");
			}
			}

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

			if (newStock != null && newStock.StockQuantity > 0)
			{
			returnBarcodes.Add(splitRecord.NewBarcode);
			_logger.LogInformation($"æ·»å æåæ°æ¡ç : {splitRecord.NewBarcode}, æ°é: {newStock.StockQuantity}");
			}
			}
			}
			}

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

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

			#region ååºæä½æ ¸å¿æ¹æ³

			/// <summary>
			/// æ§è¡ååºæä½ - å¢å¼ºçæ¬
			/// </summary>
			private async Task ExecuteReturnOperations(string orderNo, string palletCode, Dt_StockInfo stockInfo,
			Dt_Task task, PalletStatusAnalysis statusAnalysis)
			{
			_logger.LogInformation($"å¼å§æ§è¡ååºæä½ - è®¢å: {orderNo}, æç: {palletCode}");

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

			//å¤çæçä¸çåºåè´§ç©
			if (statusAnalysis.HasPalletStockGoods)
			{
			_logger.LogInformation($"å¤ç {statusAnalysis.PalletStockGoods.Count} ä¸ªåºåè´§ç©");
			await HandlePalletStockGoodsReturn(statusAnalysis.PalletStockGoods, stockInfo.Id);
			}

			//å¤çæåè®°å½
			if (statusAnalysis.HasSplitRecords)
			{
			_logger.LogInformation($"å¤ç {statusAnalysis.SplitRecords.Count} æ¡æåè®°å½");
			await HandleSplitRecordsReturn(statusAnalysis.SplitRecords, stockInfo.Id);
			}

			_logger.LogInformation($"ååºæä½å®æ - æ»ååºæ°é: {statusAnalysis.TotalReturnQty}");
			}

			/// <summary>
			/// å¤çæªåæ£çéå®è®°å½ååº
			/// </summary>


			/// <summary>
			/// å¤çæçä¸çåºåè´§ç©ååº
			/// </summary>
			private async Task HandlePalletStockGoodsReturn(List<Dt_StockInfoDetail> palletStockGoods, int stockId)
			{
			foreach (var stockDetail in palletStockGoods)
			{
			// åªå¤çåºåºéå®ç¶æçåºå
			if (stockDetail.Status == (int)StockStatusEmun.åºåºéå® && stockDetail.StockQuantity > 0)
			{
			// æ¢å¤åºåç¶æä¸ºå¯ç¨ç¶æ
			stockDetail.Status = (int)StockStatusEmun.å¥åºå®æ;
			await _stockInfoDetailService.Db.Updateable(stockDetail).ExecuteCommandAsync();

			_logger.LogInformation($"æ¢å¤åºåè´§ç© - æ¡ç : {stockDetail.Barcode}, æ°é: {stockDetail.StockQuantity}");
			}
			}
			}

			/// <summary>
			/// å¤çæåè®°å½ååº
			/// </summary>
			private async Task HandleSplitRecordsReturn(List<Dt_SplitPackageRecord> splitRecords, int stockId)
			{
			foreach (var splitRecord in splitRecords)
			{
			// å¤çæ°æ¡ç
			var newLockInfo = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
			.Where(x => x.CurrentBarcode == splitRecord.NewBarcode &&
			x.Status == (int)OutLockStockStatusEnum.åºåºä¸)
			.FirstAsync();

			if (newLockInfo != null)
			{
			await HandleSingleLockReturn(newLockInfo);
			}

			// å¤çåæ¡ç
			var originalLockInfo = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
			.Where(x => x.CurrentBarcode == splitRecord.OriginalBarcode &&
			x.Status == (int)OutLockStockStatusEnum.åºåºä¸)
			.FirstAsync();

			if (originalLockInfo != null)
			{
			await HandleSingleLockReturn(originalLockInfo);
			}

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

			private async Task HandleSingleLockReturn(Dt_OutStockLockInfo lockInfo)
			{
			decimal returnQty = lockInfo.AssignQuantity - lockInfo.PickedQty;

			if (returnQty <= 0)
			{
			_logger.LogInformation($"è·³è¿éå®è®°å½ - éå®ID: {lockInfo.Id}, å·²æ£éå®æææ éååº");
			return;
			}

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

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

			if (stockDetail != null)
			{
			decimal originalStockQty = stockDetail.StockQuantity;
			decimal originalOutboundQty = stockDetail.OutboundQuantity;

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

			if (stockDetail.OutboundQuantity < 0)
			{
			stockDetail.OutboundQuantity = 0;
			}

			stockDetail.Status = (int)StockStatusEmun.å¥åºå®æ;
			await _stockInfoDetailService.Db.Updateable(stockDetail).ExecuteCommandAsync();

			_logger.LogInformation($"æ¢å¤æåç¸å³åºå - æ¡ç : {stockDetail.Barcode}, " +
			$"åºåæ°é: {originalStockQty} -> {stockDetail.StockQuantity}");
			}

			// æ´æ°éå®ç¶æ
			lockInfo.Status = (int)OutLockStockStatusEnum.å·²ååº;
			lockInfo.Operator = App.User.UserName;
			await _outStockLockInfoService.Db.Updateable(lockInfo).ExecuteCommandAsync();

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

			if (orderDetail != null)
			{
			await ReduceOrderDetailAllocation(orderDetail, returnQty);
			}
			}

			_logger.LogInformation($"æåç¸å³éå®è®°å½ååºå®æ - éå®ID: {lockInfo.Id}, ååºæ°é: {returnQty}");
			}
			/// <summary>
			/// éæ¾ææéå®ä»¥ä¾¿éæ°åé
			/// </summary>
			private async Task ReleaseAllLocksForReallocation(string orderNo, string palletCode, PalletStatusAnalysis statusAnalysis)
			{
			// æ´æ°è®¢åæç»çå·²åéæ°é
			if (statusAnalysis.HasRemainingLocks)
			{
			var orderDetailGroups = statusAnalysis.RemainingLocks.GroupBy(x => x.OrderDetailId);

			foreach (var group in orderDetailGroups)
			{
			var orderDetailId = group.Key;
			var returnedQty = group.Sum(x => x.AssignQuantity - x.PickedQty);

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

			if (orderDetail != null)
			{
			orderDetail.AllocatedQuantity -= returnedQty;
			orderDetail.LockQuantity = orderDetail.AllocatedQuantity;

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

			_logger.LogInformation($"æ´æ°è®¢åæç» - OrderDetailId: {orderDetailId}, åå°åéæ°é: {returnedQty}");
			}
			}
			}
			}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

			_unitOfWorkManage.BeginTran();

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

			#region è¾å©æ¹æ³

			/// <summary>
			/// å¤çæ²¡æååºç©åçæåµ
			/// </summary>
			private async Task<WebResponseContent> HandleNoReturnItems(string orderNo, string palletCode, Dt_Task originalTask, int stockId)
			{
			_logger.LogInformation($"æç {palletCode} æ²¡æéè¦ååºçç©å");

			// æ£æ¥æ¯å¦æ¯ç©ºæç
			var statusAnalysis = await AnalyzePalletStatus(orderNo, palletCode, stockId);
			if (statusAnalysis.IsEmptyPallet)
			{
			try
			{
			var locationtype = 0;
			var stockInfo = await _stockInfoService.Db.Queryable<Dt_StockInfo>()
			.Where(x => x.PalletCode == palletCode)
			.FirstAsync();

			if (stockInfo == null)
			{
			var firstLocation = await _locationInfoService.Db.Queryable<Dt_LocationInfo>().FirstAsync(x => x.LocationCode == originalTask.SourceAddress);
			locationtype = firstLocation?.LocationType ?? 1;
			}
			else
			{
			locationtype = stockInfo.LocationType;
			_stockInfoService.DeleteData(stockInfo);
			}

			var targetAddress = originalTask.TargetAddress;

			await CleanupZeroStockData(stockId);


			var emptystockInfo = new Dt_StockInfo() { PalletType = PalletTypeEnum.Empty.ObjToInt(), StockStatus = StockStatusEmun.ç»çæå.ObjToInt(), PalletCode = palletCode, LocationType = locationtype };
			emptystockInfo.Details = new List<Dt_StockInfoDetail>();
			_stockInfoService.AddMaterielGroup(emptystockInfo);
			//ç©ºæçå¦ä½å¤ç è¿æä¸ä¸ªåºåºä»»å¡è¦å¤çã
			originalTask.PalletType = PalletTypeEnum.Empty.ObjToInt();

			await CreateReturnTaskAndHandleESS(orderNo, palletCode, originalTask, TaskTypeEnum.InEmpty, PalletTypeEnum.Empty.ObjToInt());

			}
			catch (Exception ex)
			{
			_logger.LogError($" HandleNoReturnItems å¤±è´¥: {ex.Message}");
			return WebResponseContent.Instance.Error($" ååºç©ºæçå¤±è´¥ï¼");
			}
			return WebResponseContent.Instance.OK("ç©ºæçååºä»»å¡åå»ºæå");
			}
			else
			{
			return WebResponseContent.Instance.Error("æçç¶æå¼å¸¸ï¼æç©åä½æ æ³è®¡ç®ååºæ°é");
			}
			}
			private async Task CleanupZeroStockData(int stockId)
			{
			try
			{
			// 1. å é¤åºåæ°éä¸º0çæç»è®°å½
			var deleteDetailCount = await _stockInfoDetailService.Db.Deleteable<Dt_StockInfoDetail>()
			.Where(x => x.StockId == stockId && x.StockQuantity == 0)
			.ExecuteCommandAsync();

			await _stockInfoService.Db.Deleteable<Dt_StockInfo>()
			.Where(x => x.Id == stockId).ExecuteCommandAsync();

			_logger.LogInformation($"æ¸çé¶åºåæç»è®°å½ - StockId: {stockId}, å é¤è®°å½æ°: {deleteDetailCount}");



			}
			catch (Exception ex)
			{
			_logger.LogWarning($"æ¸çé¶åºåæ°æ®å¤±è´¥ - StockId: {stockId}, Error: {ex.Message}");
			// æ³¨æï¼æ¸çå¤±è´¥ä¸åºè¯¥å½±åä¸»æµç¨
			}
			}
			/// <summary>
			/// æ´æ°è®¢åç¶æï¼ååºåï¼
			/// </summary>
			private async Task UpdateOrderStatusForReturn(string orderNo)
			{
			// æ£æ¥è®¢åæ¯å¦æææçé½å·²å®ææå·²ååº
			var allLocks = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
			.Where(x => x.OrderNo == orderNo)
			.ToListAsync();

			var activeLocks = allLocks.Where(x =>
			x.Status == (int)OutLockStockStatusEnum.åºåºä¸ \|\|
			x.Status == (int)OutLockStockStatusEnum.ååºä¸).ToList();

			// å¦ææ²¡ææ´»è·çéå®è®°å½ï¼æ´æ°è®¢åç¶æ
			if (!activeLocks.Any())
			{
			await _outboundOrderService.Db.Updateable<Dt_OutboundOrder>()
			.SetColumns(x => new Dt_OutboundOrder
			{
			OrderStatus = (int)OutOrderStatusEnum.åºåºå®æ,
			})
			.Where(x => x.OrderNo == orderNo)
			.ExecuteCommandAsync();

			_logger.LogInformation($"æ´æ°è®¢åç¶æä¸ºåºåºå®æ - è®¢å: {orderNo}");
			}
			}

			#endregion




			#region éªè¯æ¹æ³
			private async Task<ValidationResult<(Dt_OutStockLockInfo, Dt_OutboundOrderDetail, Dt_StockInfoDetail, Dt_OutboundBatch)>> ValidatePickingRequest(
			@@ -1447,6 +4324,11 @@
			if (lockInfo == null)
			return ValidationResult<(Dt_OutStockLockInfo, Dt_OutboundOrderDetail, Dt_StockInfoDetail, Dt_OutboundBatch)>.Error("æªæ¾å°ææçéå®ä¿¡æ¯");

			if (lockInfo.IsUnallocated == 1 \|\| lockInfo.OrderDetailId == 0)
			{
			return ValidationResult<(Dt_OutStockLockInfo, Dt_OutboundOrderDetail, Dt_StockInfoDetail, Dt_OutboundBatch)>.Error("è¯¥æ¡ç æ¯æªåééå®è®°å½ï¼ä¸è½ç´æ¥åæ£");
			}

			_logger.LogInformation($"æ¾å°éå®ä¿¡æ¯ - åéæ°é: {lockInfo.AssignQuantity}, å·²æ£é: {lockInfo.PickedQty}");

			// æ£æ¥æ¯å¦å·²ç»åæ£å®æ
			@@ -1462,21 +4344,32 @@

			_logger.LogInformation($"æ¾å°è®¢åæç» - å·²åéæ°é: {orderDetail.AllocatedQuantity}, éå®æ°é: {orderDetail.LockQuantity}");

			// éè¦ä¿®å¤ï¼æ£æ¥è®¢åæç»çå·²åéæ°éæ¯å¦è¶³å¤
			// æ£æ¥è®¢åæç»çå·²åéæ°éæ¯å¦è¶³å¤
			decimal remainingToPick = lockInfo.AssignQuantity - lockInfo.PickedQty;
			if (orderDetail.AllocatedQuantity < remainingToPick)

			// è¿éåºè¯¥æ£æ¥éå®ä¿¡æ¯çåéæ°éï¼èä¸æ¯è®¢åæç»çåéæ°é
			// å ä¸ºæååï¼éå®ä¿¡æ¯çåéæ°éå¯è½å°äºè®¢åæç»çåéæ°é
			if (lockInfo.AssignQuantity < remainingToPick)
			{
			_logger.LogWarning($"è®¢åæç»å·²åéæ°éä¸è¶³ - éè¦æ£é: {remainingToPick}, å¯ç¨åéæ°é: {orderDetail.AllocatedQuantity}");
			_logger.LogWarning($"éå®ä¿¡æ¯åéæ°éä¸è¶³ - éè¦æ£é: {remainingToPick}, éå®ä¿¡æ¯åéæ°é: {lockInfo.AssignQuantity}");
			return ValidationResult<(Dt_OutStockLockInfo, Dt_OutboundOrderDetail, Dt_StockInfoDetail, Dt_OutboundBatch)>.Error(
			$"è®¢åæç»åéæ°éä¸è¶³ï¼éè¦æ£éï¼{remainingToPick}ï¼å¯ç¨åéæ°éï¼{orderDetail.AllocatedQuantity}");
			$"éå®ä¿¡æ¯åéæ°éä¸è¶³ï¼éè¦æ£éï¼{remainingToPick}ï¼éå®ä¿¡æ¯åéæ°éï¼{lockInfo.AssignQuantity}");
			}

			// éè¦ä¿®å¤ï¼æ£æ¥éå®æ°éæ¯å¦è¶³å¤
			// æ£æ¥éå®æ°éæ¯å¦è¶³å¤
			if (orderDetail.LockQuantity < remainingToPick)
			{
			_logger.LogWarning($"è®¢åæç»éå®æ°éä¸è¶³ - éè¦æ£é: {remainingToPick}, å¯ç¨éå®æ°é: {orderDetail.LockQuantity}");
			return ValidationResult<(Dt_OutStockLockInfo, Dt_OutboundOrderDetail, Dt_StockInfoDetail, Dt_OutboundBatch)>.Error(
			$"è®¢åæç»éå®æ°éä¸è¶³ï¼éè¦æ£éï¼{remainingToPick}ï¼å¯ç¨éå®æ°éï¼{orderDetail.LockQuantity}");
			}

			// æ£æ¥è®¢åæç»åéæ°éæ¯å¦ä¸ºè´æ°
			if (orderDetail.AllocatedQuantity < 0)
			{
			_logger.LogError($"è®¢åæç»åéæ°éä¸ºè´æ° - å½åå¼: {orderDetail.AllocatedQuantity}");
			return ValidationResult<(Dt_OutStockLockInfo, Dt_OutboundOrderDetail, Dt_StockInfoDetail, Dt_OutboundBatch)>.Error(
			$"è®¢åæç»åéæ°éå¼å¸¸ï¼è´æ°ï¼ï¼è¯·èç³»ç®¡çåå¤ç");
			}

			var stockDetail = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
			@@ -1491,11 +4384,11 @@
			$"åºåæ°éä¸è¶³ï¼éè¦æ£éï¼{remainingToPick}ï¼å®éåºåï¼{stockDetail.StockQuantity}");

			// éªè¯åºåç¶æ
			if (stockDetail.Status != (int)StockStatusEmun.åºåºéå®)
			{
			return ValidationResult<(Dt_OutStockLockInfo, Dt_OutboundOrderDetail, Dt_StockInfoDetail, Dt_OutboundBatch)>.Error(
			$"åºåç¶æå¼å¸¸ï¼å½åç¶æï¼{stockDetail.Status}ï¼ææç¶æï¼åºåºéå®");
			}
			//if (stockDetail.Status != (int)StockStatusEmun.åºåºéå®)
			//{
			// return ValidationResult<(Dt_OutStockLockInfo, Dt_OutboundOrderDetail, Dt_StockInfoDetail, Dt_OutboundBatch)>.Error(
			// $"åºåç¶æå¼å¸¸ï¼å½åç¶æï¼{stockDetail.Status}ï¼ææç¶æï¼åºåºéå®");
			//}

			// ä½¿ç¨ OutboundBatchNo æ¥æ¾æ¹æ¬¡
			var batch = await _outboundBatchRepository.Db.Queryable<Dt_OutboundBatch>()
			@@ -1510,8 +4403,13 @@
			/// <summary>
			/// æ£æ¥å¹¶æ§è¡èªå¨æåï¼å¦æéè¦ï¼
			/// </summary>
			private async Task<AutoSplitResult> CheckAndAutoSplitIfNeeded(Dt_OutStockLockInfo lockInfo, Dt_StockInfoDetail stockDetail, string palletCode)
			private async Task<List<SplitResult>> CheckAndAutoSplitIfNeeded(Dt_OutStockLockInfo lockInfo, Dt_StockInfoDetail stockDetail, string palletCode)
			{
			if (lockInfo.IsUnallocated == 1 \|\| lockInfo.OrderDetailId == 0)
			{
			_logger.LogInformation($"è·³è¿æªåééå®è®°å½çèªå¨æåæ£æ¥ - éå®ID: {lockInfo.Id}");
			return null;
			}
			// æ£æ¥æ¯å¦éè¦èªå¨æåçæ¡ä»¶ï¼
			// 1. åºåæ°éå¤§äºåéæ°é
			// 2. éå®ä¿¡æ¯ç¶æä¸ºåºåºä¸
			@@ -1529,28 +4427,37 @@
			// æ§è¡èªå¨æå
			var splitResult = await ExecuteAutoSplitLogic(lockInfo, stockDetail, splitQuantity, palletCode);

			return new AutoSplitResult
			{
			NewBarcode = splitResult.NewBarcode,
			SplitQuantity = splitQuantity
			};
			return splitResult;
			}

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

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

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

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

			// éè¦ä¿®å¤ï¼è®°å½æååçåéæ°é
			decimal originalAssignQtyBefore = lockInfo.AssignQuantity;
			decimal originalOrderQtyBefore = lockInfo.OrderQuantity;
			// è®°å½æååçåéæ°é
			decimal originalAssignQty = lockInfo.AssignQuantity;
			decimal remainQty = originalAssignQty; // åéå®ä¿¡æ¯åéæ°éä¿æä¸å

			// 1. åå»ºæ°åºåæç»ï¼å©ä½é¨åï¼
			// åå»ºæ°åºåæç»ï¼å¤ä½é¨åï¼
			var newStockDetail = new Dt_StockInfoDetail
			{
			StockId = stockDetail.StockId,
			@@ -1566,24 +4473,17 @@
			BarcodeQty = stockDetail.BarcodeQty,
			BarcodeUnit = stockDetail.BarcodeUnit,
			BusinessType = stockDetail.BusinessType,
			InboundOrderRowNo = stockDetail.InboundOrderRowNo,
			InboundOrderRowNo = stockDetail.InboundOrderRowNo,
			};

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

			// 2. æ´æ°ååºåæç»
			// éè¦ä¿®å¤ï¼ååºåæ°éè®¾ç½®ä¸ºåéæ°éï¼ä¿æä¸åï¼
			decimal originalStockQtyBefore = stockDetail.StockQuantity;
			// æ³¨æï¼èªå¨æåæ¶ï¼ååºåæ°éä¿æä¸åï¼å ä¸ºæä»¬è¦åæ£çå°±æ¯åéæ°é
			// stockDetail.StockQuantity ä¿æä¸å

			_logger.LogInformation($"ååºåæç»ä¿æä¸å - åºåæ°é: {stockDetail.StockQuantity}");

			// 3. åå»ºæ°éå®ä¿¡æ¯ï¼å©ä½é¨åï¼
			// åå»ºæ°éå®ä¿¡æ¯ï¼å¤ä½é¨åï¼- æ è®°ä¸ºæªåé
			var newLockInfo = new Dt_OutStockLockInfo
			{
			OrderNo = lockInfo.OrderNo,
			OrderDetailId = lockInfo.OrderDetailId,
			OrderDetailId = 0, // éè¦ï¼ä¸ç»å®å°å·ä½è®¢åæç»
			OutboundBatchNo = lockInfo.OutboundBatchNo,
			MaterielCode = lockInfo.MaterielCode,
			MaterielName = lockInfo.MaterielName,
			@@ -1606,25 +4506,83 @@
			lineNo = lockInfo.lineNo,
			WarehouseCode = lockInfo.WarehouseCode,
			BarcodeQty = lockInfo.BarcodeQty,
			BarcodeUnit = lockInfo.BarcodeUnit,
			BarcodeUnit = lockInfo.BarcodeUnit,
			IsUnallocated = 1 // æ è®°ä¸ºæªåé
			};

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

			// 4. éè¦ä¿®å¤ï¼èªå¨æåæ¶ï¼åéå®ä¿¡æ¯çåéæ°éä¿æä¸å
			// å ä¸ºèªå¨æååï¼åæ¡ç ä»ç¶éè¦è¢«åæ£ï¼åéæ°éä¸åºè¯¥æ¹å
			_logger.LogInformation($"åéå®ä¿¡æ¯ä¿æä¸å - åéæ°é: {lockInfo.AssignQuantity}, è®¢åæ°é: {lockInfo.OrderQuantity}");
			// éè¦ï¼èªå¨æåéè¦å¢å è®¢åæç»çåéæ°éåéå®æ°é
			var orderDetail = await _outboundOrderDetailService.Db.Queryable<Dt_OutboundOrderDetail>()
			.FirstAsync(x => x.Id == lockInfo.OrderDetailId);

			// 5. è®°å½æååå²
			await RecordSplitHistory(lockInfo, stockDetail, splitQuantity, newBarcode, true, originalStockQtyBefore);
			if (orderDetail != null)
			{
			decimal originalAllocated = orderDetail.AllocatedQuantity;
			decimal originalLock = orderDetail.LockQuantity;

			orderDetail.AllocatedQuantity += splitQuantity;
			orderDetail.LockQuantity += splitQuantity;

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

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

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

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

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

			return new SplitResultDto { NewBarcode = newBarcode };
			return splitResults;
			}


			/// <summary>
			/// éªè¯èªå¨æååæ°æ®ä¸è´æ§
			/// </summary>
			private async Task ValidateDataConsistencyAfterAutoSplit(long orderDetailId, decimal originalAllocatedQty, decimal originalLockQty, decimal splitQuantity)
			{
			// éæ°è·åè®¢åæç»æ°æ®
			var orderDetail = await _outboundOrderDetailService.Db.Queryable<Dt_OutboundOrderDetail>()
			.FirstAsync(x => x.Id == orderDetailId);

			if (orderDetail == null)
			return;

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

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

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

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

			if (Math.Abs(orderDetail.AllocatedQuantity - expectedAllocatedQty) > 0.01m)
			{
			_logger.LogWarning($"èªå¨æåååéæ°éå¼å¸¸ - ææ: {expectedAllocatedQty}, å®é: {orderDetail.AllocatedQuantity}");
			}

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

			if (Math.Abs(orderDetail.AllocatedQuantity - totalLockAssignQty) > 0.01m)
			{
			_logger.LogWarning($"èªå¨æååæ°æ®ä¸ä¸è´ - è®¢åæç»åéæ°é: {orderDetail.AllocatedQuantity}, éå®ä¿¡æ¯æ»åéæ°é: {totalLockAssignQty}");
			}
			}
			#endregion

			#region æ ¸å¿é»è¾æ¹æ³
			@@ -1635,7 +4593,7 @@
			{
			_logger.LogInformation($"å¼å§æ§è¡åæ£é»è¾ - æ¡ç : {stockDetail.Barcode}, åéæ°é: {lockInfo.AssignQuantity}, å®éæ£é: {actualPickedQty}");

			// éè¦ä¿®å¤ï¼åæ¬¡éªè¯è®¢åæç»çåéæ°éï¼é²æ¢å¹¶åæä½ï¼
			// åæ¬¡éªè¯è®¢åæç»çåéæ°éï¼é²æ¢å¹¶åæä½ï¼
			if (orderDetail.AllocatedQuantity < actualPickedQty)
			{
			throw new InvalidOperationException($"è®¢åæç»åéæ°éä¸è¶³ï¼éè¦æ£é {actualPickedQty}ï¼å¯ç¨åéæ°é {orderDetail.AllocatedQuantity}");
			@@ -1646,7 +4604,7 @@
			throw new InvalidOperationException($"è®¢åæç»éå®æ°éä¸è¶³ï¼éè¦æ£é {actualPickedQty}ï¼å¯ç¨éå®æ°é {orderDetail.LockQuantity}");
			}

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

			@@ -1665,7 +4623,7 @@
			lockInfo.Operator = App.User.UserName;
			await _outStockLockInfoService.Db.Updateable(lockInfo).ExecuteCommandAsync();

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

			@@ -1714,7 +4672,7 @@
			decimal originalPickedQty = lockInfo.PickedQty;
			decimal originalAssignQty = lockInfo.AssignQuantity; // è®°å½åå§åéæ°é

			// éè¦ä¿®å¤ï¼åªæ¢å¤å·²æ£éæ°éï¼ä¸ä¿®æ¹åéæ°é
			// åªæ¢å¤å·²æ£éæ°éï¼ä¸ä¿®æ¹åéæ°é
			lockInfo.PickedQty -= pickingRecord.PickQuantity;

			// ç¡®ä¿å·²æ£éæ°éä¸ä¼ä¸ºè´æ°
			@@ -1783,7 +4741,7 @@
			StockDetail = stockDetail
			};
			}


			#endregion

			#region æ°æ®æ´æ°æ¹æ³
			@@ -1791,16 +4749,25 @@
			private async Task UpdateBatchAndOrderData(Dt_OutboundBatch batch, Dt_OutboundOrderDetail orderDetail, decimal pickedQty, string orderNo)
			{
			_logger.LogInformation($"å¼å§æ´æ°æ¹æ¬¡åè®¢åæ°æ® - æ£éæ°é: {pickedQty}");
			var latestOrderDetail = await _outboundOrderDetailService.Db.Queryable<Dt_OutboundOrderDetail>().FirstAsync(x => x.Id == orderDetail.Id);

			// éè¦ä¿®å¤ï¼éªè¯åéæ°éä¸ä¼åæè´æ°
			if (latestOrderDetail == null)
			throw new InvalidOperationException("æªæ¾å°è®¢åæç»");

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

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

			// 1. æ´æ°æ¹æ¬¡å®ææ°é
			@@ -1816,7 +4783,7 @@
			}
			await _outboundBatchRepository.Db.Updateable(batch).ExecuteCommandAsync();

			// 2. æ´æ°è®¢åæç»
			// æ´æ°è®¢åæç»
			decimal originalOverOutQty = orderDetail.OverOutQuantity;
			decimal originalAllocatedQty = orderDetail.AllocatedQuantity;
			decimal originalLockQty = orderDetail.LockQuantity;
			@@ -1825,14 +4792,15 @@
			orderDetail.AllocatedQuantity -= pickedQty;
			// LockQuantity åæ¥åå°
			orderDetail.LockQuantity = orderDetail.AllocatedQuantity;

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

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

			// 3. æ£æ¥è®¢åç¶æ
			// æ£æ¥è®¢åç¶æ
			await CheckAndUpdateOrderStatus(orderNo);

			_logger.LogInformation($"æ¹æ¬¡åè®¢åæ°æ®æ´æ°å®æ");
			@@ -1842,7 +4810,7 @@
			{
			_logger.LogInformation($"å¼å§æ¢å¤æ¹æ¬¡åè®¢åæ°æ®");

			// 1. æ¢å¤æ¹æ¬¡å®ææ°é
			// æ¢å¤æ¹æ¬¡å®ææ°é
			var batch = await _outboundBatchRepository.Db.Queryable<Dt_OutboundBatch>()
			.FirstAsync(x => x.BatchNo == revertResult.LockInfo.OutboundBatchNo);

			@@ -1850,7 +4818,11 @@
			{
			decimal originalCompletedQty = batch.CompletedQuantity;
			batch.CompletedQuantity -= pickingRecord.PickQuantity;

			if (batch.CompletedQuantity < 0)
			{
			batch.CompletedQuantity = 0;
			_logger.LogWarning($"æ¹æ¬¡å®ææ°éåºç°è´æ°ï¼éç½®ä¸º0");
			}
			_logger.LogInformation($"æ¢å¤æ¹æ¬¡å®ææ°é - ä» {originalCompletedQty} åå°å° {batch.CompletedQuantity}");

			// éæ°è®¡ç®æ¹æ¬¡ç¶æ
			@@ -1868,7 +4840,7 @@
			await _outboundBatchRepository.Db.Updateable(batch).ExecuteCommandAsync();
			}

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

			@@ -1878,9 +4850,13 @@
			decimal originalAllocatedQty = orderDetail.AllocatedQuantity;
			decimal originalLockQty = orderDetail.LockQuantity;

			// éè¦ä¿®å¤ï¼åªæ¢å¤ç¸å³æ°éï¼åéæ°éä¿æä¸å
			// åªæ¢å¤ç¸å³æ°éï¼åéæ°éä¿æä¸å
			orderDetail.OverOutQuantity -= pickingRecord.PickQuantity;
			// æ³¨æï¼AllocatedQuantity å LockQuantity å¨åæ¶åæ£æ¶ä¸åºè¯¥æ¹å
			orderDetail.AllocatedQuantity += pickingRecord.PickQuantity;
			orderDetail.LockQuantity += pickingRecord.PickQuantity;
			if (orderDetail.OverOutQuantity < 0) orderDetail.OverOutQuantity = 0;
			if (orderDetail.AllocatedQuantity < 0) orderDetail.AllocatedQuantity = 0;
			if (orderDetail.LockQuantity < 0) orderDetail.LockQuantity = 0;

			_logger.LogInformation($"æ¢å¤è®¢åæç» - å·²åºåºæ°éä» {originalOverOutQty} åå°å° {orderDetail.OverOutQuantity}");
			_logger.LogInformation($"è®¢åæç»åéæ°éä¿æä¸å: {originalAllocatedQty}");
			@@ -1992,6 +4968,110 @@
			}
			#endregion

			private async Task CreateReturnTaskAndHandleESS(string orderNo, string palletCode, Dt_Task originalTask, TaskTypeEnum taskTypeEnum, int palletType)
			{
			var firstLocation = await _locationInfoService.Db.Queryable<Dt_LocationInfo>()
			.FirstAsync(x => x.LocationCode == originalTask.SourceAddress);

			// åéæ°è´§ä½
			var newLocation = _locationInfoService.AssignLocation(firstLocation.LocationType);

			Dt_Task returnTask = new()
			{
			CurrentAddress = stations[originalTask.TargetAddress],
			Grade = 0,
			PalletCode = palletCode,
			NextAddress = "",
			// OrderNo = originalTask.OrderNo,
			OrderNo = orderNo,
			Roadway = newLocation.RoadwayNo,
			SourceAddress = stations[originalTask.TargetAddress],
			TargetAddress = newLocation.LocationCode,
			TaskStatus = TaskStatusEnum.New.ObjToInt(),
			TaskType = taskTypeEnum.ObjToInt(),
			PalletType = palletType,
			WarehouseId = originalTask.WarehouseId

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

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

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


			// ç» ESS åéæµå¨ä¿¡å·ååå»ºä»»å¡
			await SendESSCommands(palletCode, targetAddress, returnTask);
			}
			/// <summary>
			/// ç»ESSä¸ä»»å¡
			/// </summary>
			/// <param name="palletCode"></param>
			/// <param name="targetAddress"></param>
			/// <param name="returnTask"></param>
			/// <returns></returns>
			/// <exception cref="Exception"></exception>
			private async Task SendESSCommands(string palletCode, string targetAddress, Dt_Task returnTask)
			{
			try
			{
			// 1. åéæµå¨ä¿¡å·
			var moveResult = await _eSSApiService.MoveContainerAsync(new WIDESEA_DTO.Basic.MoveContainerRequest
			{
			slotCode = movestations[targetAddress],
			containerCode = palletCode
			});

			//if (moveResult)
			//{
			// 2. åå»ºååºä»»å¡
			var essTask = new TaskModel()
			{
			taskType = "putaway",
			taskGroupCode = "",
			groupPriority = 0,
			tasks = new List<TasksType>{ new() {
			taskCode = returnTask.TaskNum.ToString(),
			taskPriority = 0,
			taskDescribe = new TaskDescribeType
			{
			containerCode = palletCode,
			containerType = "CT_KUBOT_STANDARD",
			fromLocationCode = stations.GetValueOrDefault(targetAddress) ?? "",
			toStationCode = "",
			toLocationCode = returnTask.TargetAddress,
			deadline = 0,
			storageTag = ""
			}
			} }
			};

			var resultTask = await _eSSApiService.CreateTaskAsync(essTask);
			_logger.LogInformation($"ReturnRemaining åå»ºä»»å¡æå: {resultTask}");
			//}
			}
			catch (Exception ex)
			{
			_logger.LogError($"ReturnRemaining ESSå½ä»¤åéå¤±è´¥: {ex.Message}");
			throw new Exception($"ESSç³»ç»éä¿¡å¤±è´¥: {ex.Message}");
			}
			}


			#region è¾å©æ¹æ³

			private async Task<string> GenerateNewBarcode()
			@@ -2013,10 +5093,11 @@
			SplitQty = splitQty,
			SplitTime = DateTime.Now,
			Status = (int)SplitPackageStatusEnum.å·²æå,
			IsAutoSplit = isAutoSplit ,
			IsAutoSplit = isAutoSplit,
			// SplitType = isAutoSplit ? "èªå¨æå" : "æå¨æå"
			OriginalStockQuantity = originalStockQuantity ?? stockDetail.StockQuantity,
			//RemainingStockQuantity = stockDetail.StockQuantity - splitQty
			TaskNum = lockInfo.TaskNum
			};

			await _splitPackageService.Db.Insertable(splitHistory).ExecuteCommandAsync();
			@@ -2145,12 +5226,5 @@
			}

			#endregion
			}


			// æ¯æç±»
			public class SplitResultDto
			{
			public string NewBarcode { get; set; }
			}
			}