ZhongRui/ALDbanyunxiangmu.git

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

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

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

			#region åæ¹åæ£


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

			_unitOfWorkManage.BeginTran();

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

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

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


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

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

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

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

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


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

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

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

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

			_unitOfWorkManage.CommitTran();

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

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

			if (actualPickedQty <= 0)
			{
			_unitOfWorkManage.RollbackTran();
			return WebResponseContent.Instance.Error("è¯¥æ¡ç å·²æ£éå®æï¼æ ééå¤æ£é");
			}

			_logger.LogInformation($"å¼å§æ£é - æ°é: {actualPickedQty}");

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

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

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

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

			_unitOfWorkManage.CommitTran();

			return WebResponseContent.Instance.OK("åæ£æå", new
			{
			PickedQuantity = normalPickedQty,
			Barcode = barcode,
			MaterialCode = lockInfo.MaterielCode,
			AutoSplitted = false
			});
			return WebResponseContent.Instance.OK("åæ£æå", autoSplitResult);
			}
			catch (Exception ex)
			{
			@@ -318,6 +348,258 @@
			return WebResponseContent.Instance.Error($"åæ£å¤±è´¥ï¼{ex.Message}");
			}
			}


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

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

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

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

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

			// éªè¯ååºåæç»æ°æ®
			decimal expectedOriginalStockQty = lockInfo.AssignQuantity;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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


			/// <summary>
			/// åæ¶åæ£
			/// </summary>
			@@ -366,77 +648,84 @@


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



			/// <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>
			/// æ¸çåºåä¿¡æ¯ - å®æ´ä¿®æ£ç
			/// ç¡®ä¿OutboundQuantityæ£ç¡®æ¸é¶
			/// </summary>
			private async Task CleanupStockInfo(Dt_OutStockLockInfo lockInfo)
			{
			var stockDetail = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
			.FirstAsync(x => x.Barcode == lockInfo.CurrentBarcode && x.StockId == lockInfo.StockId);

			if (stockDetail != null && stockDetail.Status == (int)StockStatusEmun.åºåºå®æ)
			try
			{
			stockDetail.Status = (int)StockStatusEmun.å·²æ¸ç;
			await _stockInfoDetailService.Db.Updateable(stockDetail).ExecuteCommandAsync();
			_logger.LogInformation($"æ¸çåºåä¿¡æ¯ - éå®ID: {lockInfo.Id}, æ¡ç : {lockInfo.CurrentBarcode}");

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

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

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

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

			// æ¸çåºåååºåºæ°é
			stockDetail.StockQuantity = 0;
			stockDetail.OutboundQuantity = 0;
			stockDetail.Status = (int)StockStatusEmun.å·²æ¸ç;

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

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

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

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

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

			stock.StockQuantity = 0;
			stock.OutboundQuantity = 0;
			stock.Status = (int)StockStatusEmun.å·²æ¸ç;

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


			/// <summary>
			/// æ´æ°è®¢åç¶æ
			@@ -472,17 +761,17 @@
			/// </summary>
			private async Task RecordEmptyPalletRemoval(string orderNo, string palletCode, List<Dt_OutStockLockInfo> completedLocks)
			{
			var removalRecord = new Dt_EmptyPalletRemoval
			{
			OrderNo = orderNo,
			PalletCode = palletCode,
			RemovalTime = DateTime.Now,
			Operator = App.User.UserName,
			CompletedItemsCount = completedLocks.Count,
			TotalPickedQuantity = completedLocks.Sum(x => x.PickedQty)
			};
			//var removalRecord = new Dt_EmptyPalletRemoval
			//{
			// OrderNo = orderNo,
			// PalletCode = palletCode,
			// RemovalTime = DateTime.Now,
			// Operator = App.User.UserName,
			// CompletedItemsCount = completedLocks.Count,
			// TotalPickedQuantity = completedLocks.Sum(x => x.PickedQty)
			//};

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

			#endregion
			@@ -513,8 +802,7 @@
			}
			};
			}




			#region æå¨æå

			@@ -597,21 +885,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)
			{
			@@ -619,21 +907,20 @@
			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);
			if (orderDetail.AllocatedQuantity != totalLockAssignQuantity)
			{
			_logger.LogWarning($"è®¢åæç»åéæ°éä¸éå®ä¿¡æ¯ä¸ä¸è´ - è®¢åæç»åéæ°é: {orderDetail.AllocatedQuantity}, éå®ä¿¡æ¯æ»åéæ°é: {totalLockAssignQuantity}");
			// è¿éä¸ç´æ¥è¿åéè¯¯ï¼å ä¸ºæåæä½æ¬èº«ä¸ä¼å¯¼è´ä¸ä¸è´ï¼åªæ¯è®°å½è¦å
			}

			_logger.LogInformation($"æåéªè¯éè¿ - åæ¡ç : {originalBarcode}, æåæ°é: {splitQuantity}");
			@@ -653,129 +940,199 @@
			return lockInfos.Sum(x => x.AssignQuantity);
			}



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

			// éè¦ä¿®å¤ï¼è·åè®¢åæç»å¹¶éªè¯åéæ°é
			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;

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

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

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

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

			// æ´æ°ååºåæç»
			stockDetail.StockQuantity = originalRemainingStockQuantity;

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

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

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

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

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

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

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

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

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

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

			return splitResults;
			}
			catch (Exception ex)
			{
			_logger.LogError($"æå¨æåé»è¾æ§è¡å¤±è´¥ - åæ¡ç : {stockDetail.Barcode}, æåæ°é: {splitQuantity}, 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;
			decimal remainQty = originalAssignQtyBefore - splitQuantity;
			if (remainQty < 0)
			// éªè¯åéæ°éæ²¡æå¼å¸¸åå
			if (Math.Abs(orderDetail.AllocatedQuantity - expectedAllocatedQty) > 0.01m)
			{
			throw new InvalidOperationException($"æååå©ä½æ°éä¸ºè´æ°ï¼ååéæ°é: {originalAssignQtyBefore}, æåæ°é: {splitQuantity}");
			_logger.LogWarning($"åéæ°éå¼å¸¸åå - ææ: {expectedAllocatedQty}, å®é: {orderDetail.AllocatedQuantity}");
			}
			// åå»ºæ°åºåæç»
			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}");

			// æ´æ°ååºåæç»
			decimal originalStockQtyBefore = stockDetail.StockQuantity;
			stockDetail.StockQuantity -= splitQuantity;
			if (stockDetail.StockQuantity < 0)
			if (Math.Abs(orderDetail.LockQuantity - expectedLockQty) > 0.01m)
			{
			stockDetail.StockQuantity = 0;
			_logger.LogWarning($"ååºåæ°éåºç°è´æ°ï¼éç½®ä¸º0");
			_logger.LogWarning($"éå®æ°éå¼å¸¸åå - ææ: {expectedLockQty}, å®é: {orderDetail.LockQuantity}");
			}
			await _stockInfoDetailService.Db.Updateable(stockDetail).ExecuteCommandAsync();
			_logger.LogInformation($"æ´æ°ååºåæç» - åºåæ°éä» {originalStockQtyBefore} åå°å° {stockDetail.StockQuantity}");

			// åå»ºæ°éå®ä¿¡æ¯
			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;

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

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


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

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

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

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

			return splitResults;
			}

			#endregion



			#region åæ¶æå

			@@ -788,18 +1145,18 @@
			{
			_unitOfWorkManage.BeginTran();

			// 1. æ¥æ¾æåè®°å½å¹¶éªè¯
			// æ¥æ¾æåè®°å½å¹¶éªè¯
			var validationResult = await ValidateCancelSplitRequest(orderNo, palletCode, newBarcode);
			if (!validationResult.IsValid)
			return WebResponseContent.Instance.Error(validationResult.ErrorMessage);

			var (splitRecord, newLockInfo, newStockDetail) = validationResult.Data;

			// 2. æ¥æ¾åå§éå®ä¿¡æ¯
			// æ¥æ¾åå§éå®ä¿¡æ¯
			var originalLockInfo = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
			.FirstAsync(x => x.Id == splitRecord.OutStockLockInfoId);

			// 3. æ£æ¥è¯¥æ¡ç æ¯å¦è¢«åæ¬¡æå
			// æ£æ¥è¯¥æ¡ç æ¯å¦è¢«åæ¬¡æå
			var childSplitRecords = await _splitPackageService.Db.Queryable<Dt_SplitPackageRecord>()
			.Where(x => x.OriginalBarcode == newBarcode && !x.IsReverted)
			.ToListAsync();
			@@ -809,7 +1166,7 @@
			return WebResponseContent.Instance.Error("è¯¥æ¡ç å·²è¢«åæ¬¡æåï¼è¯·ååæ¶åç»çæåæä½");
			}

			// 4. æ§è¡åæ¶æåé»è¾
			// æ§è¡åæ¶æåé»è¾
			await ExecuteCancelSplitLogic(splitRecord, originalLockInfo, newLockInfo, newStockDetail);

			_unitOfWorkManage.CommitTran();
			@@ -833,25 +1190,113 @@
			{
			_logger.LogInformation($"å¼å§æ§è¡åæ¶æåé»è¾ - åæ¡ç : {splitRecord.OriginalBarcode}, æ°æ¡ç : {splitRecord.NewBarcode}, æåæ°é: {splitRecord.SplitQty}");

			// æ¢å¤åéå®ä¿¡æ¯
			decimal originalAssignQtyBefore = originalLockInfo.AssignQuantity;
			decimal originalOrderQtyBefore = originalLockInfo.OrderQuantity;
			try
			{
			// æ ¹æ®æåç±»åè°ç¨ä¸åçå¤çæ¹æ³
			if (splitRecord.IsAutoSplit)
			{
			await HandleAutoSplitCancel(splitRecord, originalLockInfo, newLockInfo, newStockDetail);
			}
			else
			{
			await HandleManualSplitCancel(splitRecord, originalLockInfo, newLockInfo, newStockDetail);
			}


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

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

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

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

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

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

			// æ¢å¤è®¢åæç»çåéæ°é
			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}");

			// æ¢å¤ååºå
			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}");
			}

			// å é¤æ°éå®ä¿¡æ¯ååºåæç»
			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}");

			// æ¢å¤åéå®ä¿¡æ¯çåéæ°é
			decimal originalAssignQty = originalLockInfo.AssignQuantity;
			decimal originalOrderQty = 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.æ£éå®æ)
			{
			originalLockInfo.Status = (int)OutLockStockStatusEnum.åºåºä¸;
			_logger.LogInformation($"åéå®ä¿¡æ¯ç¶æä»æ£éå®ææ¢å¤ä¸ºåºåºä¸");
			}

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

			// æ¢å¤ååºåæç»
			var originalStock = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
			@@ -859,50 +1304,128 @@

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

			// å é¤æ°éå®ä¿¡æ¯ååºåæç»
			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}");
			_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($"åæ¶æåé»è¾æ§è¡å®æ");
			// å é¤æ°åºåæç»
			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>
			@@ -935,7 +1458,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();
			@@ -948,7 +1471,7 @@
			$"æ°æ¡ç å·²è¢«åæ£ï¼å·²æ£éæ°éï¼{totalPickedQty}ï¼ï¼è¯·ååæ¶åæ£ï¼ç¶åååæ¶æå");
			}

			// éè¦ä¿®å¤ï¼æ£æ¥åæ¡ç æ¯å¦å·²è¢«åæ£
			// æ£æ¥åæ¡ç æ¯å¦å·²è¢«åæ£
			var originalBarcodePickingRecords = await Db.Queryable<Dt_PickingRecord>()
			.Where(x => x.Barcode == splitRecord.OriginalBarcode && x.OrderNo == orderNo && !x.IsCancelled)
			.ToListAsync();
			@@ -1000,7 +1523,7 @@
			{
			_unitOfWorkManage.BeginTran();

			// 1. æ¥æ¾ææç¸å³çæåè®°å½ï¼å½¢ææåé¾ï¼
			// æ¥æ¾ææç¸å³çæåè®°å½ï¼å½¢ææåé¾ï¼
			var splitChain = await GetSplitPackageChain(orderNo, startBarcode);

			if (!splitChain.Any())
			@@ -1008,11 +1531,11 @@

			_logger.LogInformation($"æ¾å°æåé¾ï¼å± {splitChain.Count} æ¡è®°å½");

			// 2. æ¶éæåé¾ä¸æ¶åçæææ¡ç ï¼åæ¬åæ¡ç åæ°æ¡ç ï¼
			// æ¶éæåé¾ä¸æ¶åçæææ¡ç ï¼åæ¬åæ¡ç åæ°æ¡ç ï¼
			var allBarcodesInChain = new List<string> { startBarcode };
			allBarcodesInChain.AddRange(splitChain.Select(x => x.NewBarcode));

			// 3. æ£æ¥æåé¾ä¸æ¯å¦æå·²è¢«åæ£çæ¡ç
			// æ£æ¥æåé¾ä¸æ¯å¦æå·²è¢«åæ£çæ¡ç
			var pickedBarcodesInfo = await GetPickedBarcodesInfo(orderNo, allBarcodesInChain);

			if (pickedBarcodesInfo.Any())
			@@ -1022,7 +1545,7 @@
			$"ä»¥ä¸æ¡ç å·²è¢«åæ£ï¼è¯·ååæ¶åæ£ï¼{pickedBarcodes}");
			}

			// 4. ææåé¡ºåºååºåæ¶ï¼ä»ææ°çå¼å§åæ¶ï¼
			// ææåé¡ºåºååºåæ¶ï¼ä»ææ°çå¼å§åæ¶ï¼
			var reversedChain = splitChain.OrderByDescending(x => x.SplitTime).ToList();

			foreach (var splitRecord in reversedChain)
			@@ -1043,106 +1566,7 @@
			}
			}

			/// <summary>
			/// è·åæ¡ç çæååæ£éç¶æ
			/// </summary>
			public async Task<WebResponseContent> GetBarcodeSplitAndPickStatus(string orderNo, string barcode)
			{
			try
			{
			// 1. è·åæåä¿¡æ¯
			var splitChain = await GetSplitPackageChain(orderNo, barcode);
			var isOriginalBarcode = !splitChain.Any(x => x.NewBarcode == barcode);

			// 2. è·åæ£éä¿¡æ¯
			var pickingRecords = await Db.Queryable<Dt_PickingRecord>()
			.Where(x => x.Barcode == barcode && x.OrderNo == orderNo && !x.IsCancelled)
			.ToListAsync();

			var totalPickedQty = pickingRecords.Sum(x => x.PickQuantity);

			// 3. è·åéå®ä¿¡æ¯
			var lockInfo = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
			.Where(x => x.CurrentBarcode == barcode && x.OrderNo == orderNo)
			.FirstAsync();

			// 4. è·ååºåä¿¡æ¯
			var stockDetail = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
			.Where(x => x.Barcode == barcode)
			.FirstAsync();

			var statusInfo = new BarcodeStatusInfoDto
			{
			Barcode = barcode,
			OrderNo = orderNo,
			IsOriginalBarcode = isOriginalBarcode,
			SplitChainCount = splitChain.Count,
			HasBeenPicked = pickingRecords.Any(),
			TotalPickedQuantity = totalPickedQty,
			PickRecordCount = pickingRecords.Count,
			LockInfoStatus = lockInfo?.Status ?? 0,
			LockInfoPickedQty = lockInfo?.PickedQty ?? 0,
			LockInfoAssignQty = lockInfo?.AssignQuantity ?? 0,
			StockQuantity = stockDetail?.StockQuantity ?? 0,
			StockStatus = stockDetail?.Status ?? 0,
			CanCancelSplit = !pickingRecords.Any(), // æªè¢«åæ£æè½åæ¶æå
			NeedCancelPickFirst = pickingRecords.Any() // éè¦ååæ¶åæ£
			};

			// 5. è·åæä½å»ºè®®
			statusInfo.OperationSuggestions = GetOperationSuggestions(statusInfo);

			return WebResponseContent.Instance.OK("è·åç¶ææå", statusInfo);
			}
			catch (Exception ex)
			{
			_logger.LogError($"è·åæ¡ç ç¶æå¤±è´¥ - OrderNo: {orderNo}, Barcode: {barcode}, Error: {ex.Message}");
			return WebResponseContent.Instance.Error("è·åæ¡ç ç¶æå¤±è´¥");
			}
			}
			/// <summary>
			/// è·åæä½å»ºè®®
			/// </summary>
			private List<string> GetOperationSuggestions(BarcodeStatusInfoDto statusInfo)
			{
			var suggestions = new List<string>();

			if (statusInfo.HasBeenPicked)
			{
			suggestions.Add($"è¯¥æ¡ç å·²è¢«åæ£ï¼æ°éï¼{statusInfo.TotalPickedQuantity}ï¼ï¼å¦éåæ¶æåï¼è¯·ååæ¶åæ£");

			if (statusInfo.IsOriginalBarcode)
			{
			suggestions.Add("è¿æ¯åæ¡ç ï¼åæ¶åæ£åå°æ¢å¤ä¸ºå¯åæ£ç¶æ");
			}
			else
			{
			suggestions.Add("è¿æ¯æåçæçæ°æ¡ç ï¼åæ¶åæ£åæè½åæ¶æå");
			}
			}
			else
			{
			if (statusInfo.IsOriginalBarcode && statusInfo.SplitChainCount > 0)
			{
			suggestions.Add("è¿æ¯åæ¡ç ï¼å¯ä»¥åæ¶æåé¾");
			}
			else if (!statusInfo.IsOriginalBarcode)
			{
			suggestions.Add("è¿æ¯æåçæçæ°æ¡ç ï¼å¯ä»¥åç¬åæ¶æå");
			}
			}

			if (statusInfo.LockInfoStatus == (int)OutLockStockStatusEnum.æ£éå®æ)
			{
			suggestions.Add("éå®ç¶æï¼æ£éå®æ");
			}
			else if (statusInfo.LockInfoStatus == (int)OutLockStockStatusEnum.åºåºä¸)
			{
			suggestions.Add("éå®ç¶æï¼åºåºä¸");
			}

			return suggestions;
			}

			/// <summary>
			/// è·åå·²è¢«åæ£çæ¡ç ä¿¡æ¯
			/// </summary>
			@@ -1366,7 +1790,904 @@

			#endregion

			#region ç»ä¸ååºé»è¾
			#region ç»ä¸ååºé»è¾

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

			_unitOfWorkManage.BeginTran();

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

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

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

			int stockId = stockInfo.Id;

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

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

			if (!statusAnalysis.HasItemsToReturn)
			{
			try
			{
			_logger.LogInformation($"ãæ ååºç©åãå¤çç©ºæç");
			var result = await HandleEmptyPalletReturn(orderNo, palletCode, stockInfo);
			_unitOfWorkManage.CommitTran();

			// å¨äºå¡æäº¤åå¤çESSå½ä»¤
			if (result.Status && result.Data is ReturnTaskInfo taskInfo)
			{
			await ProcessESSAfterTransaction(palletCode, taskInfo);
			}
			return result;
			}
			catch (Exception ex)
			{
			_unitOfWorkManage.RollbackTran();
			_logger.LogError($"ç©ºç®±ååºExecutePalletReturnå¤±è´¥: {ex.Message}");
			return WebResponseContent.Instance.Error($"ç©ºç®±ååºExecutePalletReturnå¤±è´¥ï¼{ex.Message}");
			}
			}

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

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

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

			// åå»ºååºä»»å¡
			try
			{
			// åå»ºååºä»»å¡ï¼ä½ä¸åéESSå½ä»¤
			returnTaskInfo = await CreateReturnTaskWithoutESS(orderNo, palletCode, stockInfo);

			}
			catch (Exception taskEx)
			{
			_logger.LogError($"ååºä»»å¡CreateReturnTaskWithoutESSåå»ºå¤±è´¥: {taskEx.Message}");
			// ä»»å¡åå»ºå¤±è´¥ä¸å½±åæ°æ®ååº
			}
			_unitOfWorkManage.CommitTran();

			// å¨äºå¡æäº¤åå¤çESSå½ä»¤
			if (returnTaskInfo != null && returnTaskInfo.ShouldSendESS)
			{
			await ProcessESSAfterTransaction(palletCode, returnTaskInfo);
			}
			// ååºåéªè¯
			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($"ExecutePalletReturn ååºå¤±è´¥: {ex.Message}");
			return WebResponseContent.Instance.Error($"ExecutePalletReturn ååºå¤±è´¥ï¼{ex.Message}");
			}
			}

			/// <summary>
			/// äºå¡æäº¤åå¤çESSå½ä»¤ - ç¬ç«æ¹æ³ï¼é¿åäºå¡é
			/// </summary>
			private async Task ProcessESSAfterTransaction(string palletCode, ReturnTaskInfo taskInfo)
			{
			try
			{
			_logger.LogInformation($"å¼å§å¤çESSå½ä»¤ - æç: {palletCode}");

			if (taskInfo == null \|\| !taskInfo.ShouldSendESS \|\| taskInfo.ReturnTask == null)
			{
			_logger.LogWarning($"æ éåéESSå½ä»¤æä»»å¡ä¿¡æ¯ä¸å®æ´");
			return;
			}

			// åéESSå½ä»¤
			await SendESSCommands(palletCode, taskInfo.OriginalTaskTargetAddress, taskInfo.ReturnTask);

			_logger.LogInformation($"ESSå½ä»¤å¤çå®æ - æç: {palletCode}, ä»»å¡å·: {taskInfo.ReturnTask.TaskNum}");
			}
			catch (Exception ex)
			{
			_logger.LogError($"å¤çESSå½ä»¤å¤±è´¥ - æç: {palletCode}, Error: {ex.Message}");
			// è¿éä¸æåºå¼å¸¸ï¼å ä¸ºæ°æ®ååºå·²ç»æåï¼ESSå½ä»¤åéå¤±è´¥å¯ä»¥ç¨åéè¯
			}
			}
			/// <summary>
			/// åå»ºååºä»»å¡ï¼ä¸åéESSå½ä»¤ï¼- ç¨äºäºå¡åå¤ç
			/// </summary>
			private async Task<ReturnTaskInfo> CreateReturnTaskWithoutESS(string orderNo, string palletCode, Dt_StockInfo stockInfo)
			{
			try
			{
			// è·åå½åä»»å¡ä¿¡æ¯
			var currentTask = await _taskRepository.Db.Queryable<Dt_Task>()
			.Where(x => x.OrderNo == orderNo && x.PalletCode == palletCode)
			.FirstAsync();

			if (currentTask == null)
			{
			_logger.LogWarning($"æªæ¾å°å½åä»»å¡ - è®¢å: {orderNo}, æç: {palletCode}");
			return 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
			};

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

			_logger.LogInformation($"åå»ºååºä»»å¡æå: {returnTask.TaskNum}, è®¢å: {orderNo}, æç: {palletCode}");

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

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

			// è¿åä»»å¡ä¿¡æ¯ï¼ä½ä¸åéESSå½ä»¤
			return new ReturnTaskInfo
			{
			ShouldSendESS = true,
			PalletCode = palletCode,
			OriginalTaskTargetAddress = currentTask.TargetAddress,
			ReturnTask = returnTask
			};
			}
			catch (Exception ex)
			{
			_logger.LogError($"åå»ºååºä»»å¡å¤±è´¥ - è®¢å: {orderNo}, æç: {palletCode}, Error: {ex.Message}");
			throw new Exception($"åå»ºååºä»»å¡å¤±è´¥ - è®¢å: {orderNo}, æç: {palletCode}", ex);
			}
			}
			catch (Exception ex)
			{
			_logger.LogError($"åå»ºååºä»»å¡å¤±è´¥ - è®¢å: {orderNo}, æç: {palletCode}, Error: {ex.Message}");
			return null;
			}
			}
			/// <summary>
			/// å¢å¼ºçååºåæ°æ®éªè¯
			/// </summary>
			private async Task<ValidationResult<bool>> ValidateDataBeforeReturn(string orderNo, string palletCode, int stockId)
			{
			var errors = new List<string>();

			try
			{
			// éªè¯åºåæ°æ®
			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}"))}");
			}

			// éªè¯éå®è®°å½
			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($"åç°å·²æ£éæ°éå¤§äºåéæ°éçéå®è®°å½");
			}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


			/// <summary>
			/// åå»ºååºä»»å¡
			/// </summary>
			private async Task 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 currentTask = await GetCurrentTask(orderNo, palletCode);
			if (currentTask == null)
			{
			return WebResponseContent.Instance.Error("æªæ¾å°å½åä»»å¡");
			}
			// åå»ºç©ºæçåºåè®°å½
			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);

			// åå»ºååºä»»å¡ï¼ä¸åéESSå½ä»¤ï¼
			var returnTaskInfo = await CreateEmptyPalletReturnTask(orderNo, palletCode, emptyStockInfo, currentTask);

			return WebResponseContent.Instance.OK("ç©ºæçååºæå", returnTaskInfo);
			}
			catch (Exception ex)
			{
			_logger.LogError($"ç©ºæçååºå¤±è´¥ HandleEmptyPalletReturn: {ex.Message}");
			return WebResponseContent.Instance.Error($"ç©ºæçååºå¤±è´¥ HandleEmptyPalletReturn: {ex.Message}");
			}
			}

			private async Task<Dt_Task> GetCurrentTask(string orderNo, string palletCode)
			{
			// åå°è¯éè¿è®¢åå·åæçå·æ¥æ¾ä»»å¡
			@@ -1384,227 +2705,175 @@

			return task;
			}
			private async Task<PalletStatusAnalysis> AnalyzePalletStatus(string orderNo, string palletCode, int stockId)

			// <summary>
			/// åå»ºç©ºæçååºä»»å¡ï¼ä¸åéESSå½ä»¤ï¼
			/// </summary>
			private async Task<ReturnTaskInfo> CreateEmptyPalletReturnTask(string orderNo, string palletCode, Dt_StockInfo emptyStockInfo, Dt_Task currentTask)
			{
			try
			{
			// åéæ°è´§ä½
			var newLocation = _locationInfoService.AssignLocation(emptyStockInfo.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.InEmpty.ObjToInt(),
			PalletType = PalletTypeEnum.Empty.ObjToInt(),
			WarehouseId = currentTask.WarehouseId
			};

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

			_logger.LogInformation($"åå»ºç©ºæçååºä»»å¡æå: {returnTask.TaskNum}");

			// å é¤åå§åºåºä»»å¡
			var result = _task_HtyService.DeleteAndMoveIntoHty(currentTask, OperateTypeEnum.äººå·¥å é¤);
			await _taskRepository.Db.Deleteable(currentTask).ExecuteCommandAsync();

			if (!result)
			{
			await _taskRepository.Db.Deleteable(currentTask).ExecuteCommandAsync();
			}

			// è¿åä»»å¡ä¿¡æ¯
			return new ReturnTaskInfo
			{
			ShouldSendESS = true,
			PalletCode = palletCode,
			OriginalTaskTargetAddress = currentTask.TargetAddress,
			ReturnTask = returnTask
			};
			}
			catch (Exception ex)
			{
			_logger.LogError($"åå»ºç©ºæçååºä»»å¡å¤±è´¥: {ex.Message}");
			throw;
			}
			}

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

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

			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> ExecutePalletReturn(string orderNo, string palletCode, string returnReason = "åæ¹ååº")
			{
			try
			{
			_unitOfWorkManage.BeginTran();
			// é¦åè·åæçä¸ææçåºåæç»ï¼åºç¡æ°æ®ï¼
			var allStockDetails = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
			.Where(x => x.StockId == stockId && x.StockQuantity > 0)
			.ToListAsync();

			if (string.IsNullOrEmpty(orderNo) \|\| string.IsNullOrEmpty(palletCode))
			return WebResponseContent.Instance.Error("è®¢åå·åæçç ä¸è½ä¸ºç©º");
			_logger.LogInformation($"æ¾å° {allStockDetails.Count} ä¸ªæåºåçæç»è®°å½");

			// è·ååºåä¿¡æ¯
			var stockInfo = await _stockInfoService.Db.Queryable<Dt_StockInfo>().FirstAsync(x => x.PalletCode == palletCode);
			if (stockInfo == null)
			return WebResponseContent.Instance.Error($"æªæ¾å°æç {palletCode} å¯¹åºçåºåä¿¡æ¯");
			// åæææéå®è®°å½ï¼å·²åéåæªåéï¼
			var allLockInfos = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
			.Where(x => x.OrderNo == orderNo && x.PalletCode == palletCode)
			.ToListAsync();

			var task = await GetCurrentTask(orderNo, palletCode);
			if (task == null)
			return WebResponseContent.Instance.Error("æªæ¾å°å¯¹åºçä»»å¡ä¿¡æ¯");
			// åºåå·²åéåæªåééå®è®°å½
			var allocatedLocks = allLockInfos
			.Where(x => x.IsUnallocated != 1 && x.OrderDetailId > 0 &&
			x.Status == (int)OutLockStockStatusEnum.åºåºä¸)
			.ToList();

			// åææçç¶æ
			var statusAnalysis = await AnalyzePalletStatus(orderNo, palletCode, stockInfo.Id);
			if (!statusAnalysis.HasItemsToReturn)
			return await HandleNoReturnItems(orderNo, palletCode, task, stockInfo.Id);
			var unallocatedLocks = allLockInfos
			.Where(x => (x.IsUnallocated == 1 \|\| x.OrderDetailId == 0) &&
			x.Status == (int)OutLockStockStatusEnum.åºåºä¸)
			.ToList();

			// æ£æ¥æ¯å¦æè¿è¡ä¸çä»»å¡
			if (statusAnalysis.HasActiveTasks)
			// å¤çå·²åééå®è®°å½
			if (allocatedLocks.Any())
			{
			return WebResponseContent.Instance.Error($"æç {palletCode} æè¿è¡ä¸çä»»å¡ï¼ä¸è½æ§è¡ååºæä½");
			result.HasRemainingLocks = true;
			result.RemainingLocks = allocatedLocks;

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

			foreach (var lockInfo in allocatedLocks)
			{
			if (!string.IsNullOrEmpty(lockInfo.CurrentBarcode))
			{
			result.AllBarcodes.Add(lockInfo.CurrentBarcode);
			result.ProcessedBarcodes.Add(lockInfo.CurrentBarcode);
			}
			}
			_logger.LogInformation($"åç° {allocatedLocks.Count} æ¡å·²åééå®è®°å½ï¼ååºæ°é: {result.RemainingLocksReturnQty}");
			}

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

			// éæ¾ææéå®ä»¥ä¾¿éæ°åé
			await ReleaseAllLocksForReallocation(orderNo, palletCode, statusAnalysis);

			_unitOfWorkManage.CommitTran();

			// æ¶éææéè¦ååºçæ¡ç
			var returnBarcodes = await CollectReturnBarcodes(statusAnalysis);

			// åå»ºESSååºä»»å¡
			if (returnBarcodes.Any())
			// å¤çæªåééå®è®°å½ï¼èªå¨æåäº§ççï¼
			if (unallocatedLocks.Any())
			{
			_logger.LogInformation($"åå»ºååºAGVä»»å¡ - è®¢å: {orderNo}, æç: {palletCode}, æ¡ç æ°é: {returnBarcodes.Count}, åå : {returnReason}");
			await CreateReturnTaskAndHandleESS(orderNo, palletCode, task, TaskTypeEnum.InPick, stockInfo.PalletType);
			result.HasUnallocatedLocks = true;
			result.UnallocatedLocks = unallocatedLocks;

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

			foreach (var lockInfo in unallocatedLocks)
			{
			if (!string.IsNullOrEmpty(lockInfo.CurrentBarcode) &&
			!result.ProcessedBarcodes.Contains(lockInfo.CurrentBarcode))
			{
			result.AllBarcodes.Add(lockInfo.CurrentBarcode);
			result.ProcessedBarcodes.Add(lockInfo.CurrentBarcode);
			}
			}
			_logger.LogInformation($"åç° {unallocatedLocks.Count} æ¡æªåééå®è®°å½ï¼ååºæ°éï¼ç¶ææ¢å¤ï¼: {result.UnallocatedLocksReturnQty}");
			}

			// æ´æ°è®¢åç¶æï¼ä¸è§¦åMESåä¼ ï¼
			await UpdateOrderStatusForReturn(orderNo);
			// éæ°è®¡ç®æ»ååºæ°é
			// å¯¹äºå·²åééå®ï¼ååºæ°é = æªæ£éæ°é
			// å¯¹äºæªåééå®ï¼æ²¡æå®éçåºåæ°éååï¼åªæ¯ç¶ææ¢å¤
			result.TotalReturnQty = result.RemainingLocksReturnQty; // åªè®¡ç®å·²åééå®çååºæ°é

			return WebResponseContent.Instance.OK($"ååºæä½æåï¼å±ååºæ°éï¼{statusAnalysis.TotalReturnQty}", new
			{
			ReturnQuantity = statusAnalysis.TotalReturnQty,
			ReturnBarcodes = returnBarcodes,
			Reason = returnReason,
			PalletCode = palletCode,
			OrderNo = orderNo
			});
			// è®°å½åºåæ°éï¼ç¨äºéªè¯ï¼
			decimal totalStockOnPallet = allStockDetails.Sum(x => x.StockQuantity);

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

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

			return result;
			}
			catch (Exception ex)
			{
			_unitOfWorkManage.RollbackTran();
			_logger.LogError($"ååºæä½å¤±è´¥ - OrderNo: {orderNo}, PalletCode: {palletCode}, Error: {ex.Message}");
			return WebResponseContent.Instance.Error($"ååºæä½å¤±è´¥: {ex.Message}");
			_logger.LogError($"ååºåæå¤±è´¥ - è®¢å: {orderNo}, æç: {palletCode}, Error: {ex.Message}");
			throw;
			}
			}
			private async Task ExecuteReturnDataOperations(string orderNo, string palletCode, Dt_StockInfo stockInfo,Dt_Task task, PalletStatusAnalysis statusAnalysis)
			{
			_logger.LogInformation($"å¼å§æ§è¡ååºæ°æ®æä½ - è®¢å: {orderNo}, æç: {palletCode}");

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

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

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

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

			/// <summary>
			/// åæ¹ååº - è°ç¨ç»ä¸ååºæ¹æ³
			/// </summary>
			@@ -1613,53 +2882,120 @@
			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();

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

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

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

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

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

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

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

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

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

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

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

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

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

			// æ¸çå·²å®æçéå®è®°å½ï¼æ è®°ä¸ºå·²åèµ°ï¼
			_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}");
			}
			}

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

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

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

			_unitOfWorkManage.CommitTran();

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

			return WebResponseContent.Instance.OK("åèµ°ç©ºç®±æå");
			}
			@@ -1670,356 +3006,19 @@
			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>
			private async Task HandleRemainingLocksReturn(List<Dt_OutStockLockInfo> remainingLocks)
			{
			foreach (var lockInfo in remainingLocks)
			{
			// è®¡ç®ååºæ°éï¼æªæ£éçé¨åï¼
			decimal returnQty = lockInfo.AssignQuantity - lockInfo.PickedQty;

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

			if (stockDetail != null)
			{
			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}, æ°é: {returnQty}, æ°åºå: {stockDetail.StockQuantity}");
			}

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

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

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

			/// <summary>
			/// å¤çåä¸ªéå®è®°å½ååº
			/// </summary>
			private async Task HandleSingleLockReturn(Dt_OutStockLockInfo lockInfo)
			{
			decimal returnQty = lockInfo.AssignQuantity - lockInfo.PickedQty;

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

			if (stockDetail != null)
			{
			stockDetail.StockQuantity += returnQty;
			stockDetail.OutboundQuantity -= returnQty;

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

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

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

			_logger.LogInformation($"å¤çæåç¸å³éå® - æ¡ç : {lockInfo.CurrentBarcode}, ååºæ°é: {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}");
			}
			}
			}
			}

			#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("æçç¶æå¼å¸¸ï¼æç©åä½æ æ³è®¡ç®ååºæ°é");
			}
			}
			#region è¾å©æ¹æ³

			private async Task CleanupZeroStockData(int stockId)
			{
			try
			{
			// 1. å é¤åºåæ°éä¸º0çæç»è®°å½
			// å é¤åºåæ°éä¸º0çæç»è®°å½
			var deleteDetailCount = await _stockInfoDetailService.Db.Deleteable<Dt_StockInfoDetail>()
			.Where(x => x.StockId == stockId && x.StockQuantity == 0 && (x.Status == StockStatusEmun.åºåºå®æ.ObjToInt() \|\| x.Status ==
			StockStatusEmun.å¥åºå®æ.ObjToInt()))
			.ExecuteCommandAsync();
			.Where(x => x.StockId == stockId && x.StockQuantity == 0)
			.ExecuteCommandAsync();

			await _stockInfoService.Db.Deleteable<Dt_StockInfo>()
			.Where(x => x.Id == stockId).ExecuteCommandAsync();
			@@ -2032,42 +3031,11 @@
			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(
			@@ -2086,6 +3054,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}");

			// æ£æ¥æ¯å¦å·²ç»åæ£å®æ
			@@ -2101,21 +3074,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>()
			@@ -2130,11 +3114,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>()
			@@ -2151,6 +3135,12 @@
			/// </summary>
			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. éå®ä¿¡æ¯ç¶æä¸ºåºåºä¸
			@@ -2165,129 +3155,176 @@
			// è®¡ç®æåæ°é = åºåæ°é - åéæ°é
			decimal splitQuantity = stockDetail.StockQuantity - lockInfo.AssignQuantity;

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

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

			return splitResult;
			}

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

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

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

			// åå»ºæ°åºåæç»ï¼å©ä½é¨åï¼
			var newStockDetail = new Dt_StockInfoDetail
			try
			{
			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}");
			// éªè¯æåæ°éåçæ§
			if (splitQuantity <= 0)
			throw new InvalidOperationException($"æåæ°éå¿é¡»å¤§äº0ï¼å½åå¼: {splitQuantity}");

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

			_logger.LogInformation($"ååºåæç»ä¿æä¸å - åºåæ°é: {stockDetail.StockQuantity}");
			// çææ°æ¡ç
			string newBarcode = await GenerateNewBarcode();
			_logger.LogInformation($"çææ°æ¡ç : {newBarcode}");

			// åå»ºæ°éå®ä¿¡æ¯ï¼å©ä½é¨åï¼
			var newLockInfo = new Dt_OutStockLockInfo
			// ãæ ¸å¿ä¿®æ£ãæ´æ°ååºåæç»ï¼åªåå°ç©çåºåï¼ä¸å½±ååºåºæ°é
			decimal originalStockQty = stockDetail.StockQuantity;
			stockDetail.StockQuantity -= splitQuantity; // ä»åºååå°
			// stockDetail.OutboundQuantity ä¿æä¸åï¼

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

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

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

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

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

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

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

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

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

			return splitResults;
			}
			catch (Exception ex)
			{
			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}");

			// èªå¨æåæ¶ï¼åéå®ä¿¡æ¯çåéæ°éä¿æä¸å
			// å ä¸ºèªå¨æååï¼åæ¡ç ä»ç¶éè¦è¢«åæ£ï¼åéæ°éä¸åºè¯¥æ¹å
			_logger.LogInformation($"åéå®ä¿¡æ¯ä¿æä¸å - åéæ°é: {lockInfo.AssignQuantity}, è®¢åæ°é: {lockInfo.OrderQuantity}");

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

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

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

			return splitResults;
			_logger.LogError($"èªå¨æåé»è¾æ§è¡å¤±è´¥ - åæ¡ç : {stockDetail.Barcode}, Error: {ex.Message}");
			throw;
			}
			}


			#endregion

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

			@@ -2335,11 +3351,45 @@
			};
			}

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

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

			decimal outboundIncrease = refreshedStockDetail.OutboundQuantity - stockDetail.OutboundQuantity;

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

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

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

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

			private async Task<RevertPickingResult> RevertPickingData(Dt_PickingRecord pickingRecord)
			{
			_logger.LogInformation($"å¼å§æ¢å¤æ£éæ°æ® - æ£éè®°å½ID: {pickingRecord.Id}, æ¡ç : {pickingRecord.Barcode}, æ£éæ°é: {pickingRecord.PickQuantity}");

			// 1. æ¢å¤éå®ä¿¡æ¯
			// æ¢å¤éå®ä¿¡æ¯
			var lockInfo = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
			.FirstAsync(x => x.Id == pickingRecord.OutStockLockId);

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

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

			// ç¡®ä¿å·²æ£éæ°éä¸ä¼ä¸ºè´æ°
			@@ -2378,7 +3428,7 @@

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

			// 2. æ¢å¤åºåä¿¡æ¯
			// æ¢å¤åºåä¿¡æ¯
			var stockDetail = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
			.FirstAsync(x => x.Barcode == pickingRecord.Barcode);

			@@ -2425,59 +3475,85 @@

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

			// æ£æ¥è®¢åç¶æ
			await CheckAndUpdateOrderStatus(orderNo);
			@@ -2529,9 +3605,9 @@
			decimal originalAllocatedQty = orderDetail.AllocatedQuantity;
			decimal originalLockQty = orderDetail.LockQuantity;

			// éè¦ä¿®å¤ï¼åªæ¢å¤ç¸å³æ°éï¼åéæ°éä¿æä¸å
			// åªæ¢å¤ç¸å³æ°éï¼åéæ°éä¿æä¸å
			orderDetail.OverOutQuantity -= pickingRecord.PickQuantity;
			orderDetail.AllocatedQuantity += pickingRecord.PickQuantity;
			orderDetail.AllocatedQuantity += pickingRecord.PickQuantity;
			orderDetail.LockQuantity += pickingRecord.PickQuantity;
			if (orderDetail.OverOutQuantity < 0) orderDetail.OverOutQuantity = 0;
			if (orderDetail.AllocatedQuantity < 0) orderDetail.AllocatedQuantity = 0;
			@@ -2545,7 +3621,7 @@
			await _outboundOrderDetailService.Db.Updateable(orderDetail).ExecuteCommandAsync();
			}

			// 3. éæ°æ£æ¥è®¢åç¶æ
			// éæ°æ£æ¥è®¢åç¶æ
			await CheckAndUpdateOrderStatus(pickingRecord.OrderNo);

			_logger.LogInformation($"æ¢å¤æ¹æ¬¡åè®¢åæ°æ®å®æ");
			@@ -2566,125 +3642,9 @@
			orderDetail.BatchAllocateStatus = OrderDetailStatusEnum.New.ObjToInt();
			}
			}
			private async Task ReleaseLockAndStock(Dt_OutStockLockInfo lockInfo)
			{
			// æ¢å¤åºåç¶æ - ååºååºååä¸ºå¯ç¨ç¶æ
			var stockDetail = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
			.FirstAsync(x => x.Barcode == lockInfo.CurrentBarcode && x.StockId == lockInfo.StockId);

			if (stockDetail != null)
			{
			// ååºååºåç¶ææ¢å¤ä¸ºå¥åºå®æï¼å¯ç¨ç¶æï¼
			stockDetail.Status = (int)StockStatusEmun.å¥åºå®æ;
			await _stockInfoDetailService.Db.Updateable(stockDetail).ExecuteCommandAsync();
			}

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

			/// <summary>
			/// æ´æ°æ¹æ¬¡ç¶æï¼ååºï¼
			/// </summary>
			private async Task UpdateBatchStatusForReturn(string outboundBatchNo, List<Dt_OutStockLockInfo> returnedLocks)
			{
			var batch = await _outboundBatchRepository.Db.Queryable<Dt_OutboundBatch>()
			.FirstAsync(x => x.BatchNo == outboundBatchNo);

			if (batch != null)
			{
			// è®¡ç®ååºæ°éï¼æªæ£éçé¨åï¼
			var returnedQty = returnedLocks.Sum(x => x.AssignQuantity - x.PickedQty);
			batch.CompletedQuantity -= returnedQty;

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

			batch.Operator = App.User.UserName;
			await _outboundBatchRepository.Db.Updateable(batch).ExecuteCommandAsync();
			}
			}

			/// <summary>
			/// æ´æ°è®¢åæç»ï¼ååºåï¼
			/// </summary>
			private async Task UpdateOrderDetailAfterReturn(List<Dt_OutStockLockInfo> returnedLocks)
			{
			var orderDetailGroups = returnedLocks.GroupBy(x => x.OrderDetailId);

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

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

			if (orderDetail != null)
			{
			orderDetail.AllocatedQuantity -= returnedQty;
			// LockQuantity åæ¥åå°ï¼ä¿æä¸å·²åéæ°éä¸è´
			orderDetail.LockQuantity = orderDetail.AllocatedQuantity;

			await UpdateBatchAllocateStatus(orderDetail);

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

			#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

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

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



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

			/// <summary>
			/// ç»ESSä¸ä»»å¡
			/// </summary>
			@@ -2697,16 +3657,14 @@
			{
			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",
			@@ -2730,7 +3688,7 @@

			var resultTask = await _eSSApiService.CreateTaskAsync(essTask);
			_logger.LogInformation($"ReturnRemaining åå»ºä»»å¡æå: {resultTask}");
			//}

			}
			catch (Exception ex)
			{
			@@ -2738,7 +3696,6 @@
			throw new Exception($"ESSç³»ç»éä¿¡å¤±è´¥: {ex.Message}");
			}
			}


			#region è¾å©æ¹æ³

			@@ -2752,19 +3709,29 @@
			{
			var splitHistory = new Dt_SplitPackageRecord
			{
			OrderNo = lockInfo.OrderNo,
			FactoryArea = lockInfo.FactoryArea,
			TaskNum = lockInfo.TaskNum,
			OutStockLockInfoId = lockInfo.Id,
			StockId = stockDetail.StockId,
			Operator = App.User.UserName,
			IsReverted = false,
			OriginalBarcode = stockDetail.Barcode,
			NewBarcode = newBarcode,
			SplitQty = splitQty,
			// RemainQuantity = remainQty,
			MaterielCode = lockInfo.MaterielCode,
			SplitTime = DateTime.Now,
			OrderNo = lockInfo.OrderNo,
			PalletCode = lockInfo.PalletCode,



			Status = (int)SplitPackageStatusEnum.å·²æå,
			IsAutoSplit = isAutoSplit,
			// SplitType = isAutoSplit ? "èªå¨æå" : "æå¨æå"
			OriginalStockQuantity = originalStockQuantity ?? stockDetail.StockQuantity,
			//RemainingStockQuantity = stockDetail.StockQuantity - splitQty

			};

			await _splitPackageService.Db.Insertable(splitHistory).ExecuteCommandAsync();
			@@ -2827,28 +3794,32 @@
			}
			#endregion


			#region DTOç±»

			/// <summary>
			/// æ¡ç ç¶æä¿¡æ¯DTO
			/// ååºä»»å¡ä¿¡æ¯ç±»
			/// </summary>
			public class BarcodeStatusInfoDto
			public class ReturnTaskInfo
			{
			public string Barcode { get; set; }
			public string OrderNo { get; set; }
			public bool IsOriginalBarcode { get; set; }
			public int SplitChainCount { get; set; }
			public bool HasBeenPicked { get; set; }
			public decimal TotalPickedQuantity { get; set; }
			public int PickRecordCount { get; set; }
			public int LockInfoStatus { get; set; }
			public decimal LockInfoPickedQty { get; set; }
			public decimal LockInfoAssignQty { get; set; }
			public decimal StockQuantity { get; set; }
			public int StockStatus { get; set; }
			public bool CanCancelSplit { get; set; }
			public bool NeedCancelPickFirst { get; set; }
			public List<string> OperationSuggestions { get; set; } = new List<string>();
			/// <summary>
			/// æ¯å¦éè¦åéESSå½ä»¤
			/// </summary>
			public bool ShouldSendESS { get; set; }

			/// <summary>
			/// æçç
			/// </summary>
			public string PalletCode { get; set; }

			/// <summary>
			/// åå§ä»»å¡çç®æ å°å
			/// </summary>
			public string OriginalTaskTargetAddress { get; set; }

			/// <summary>
			/// ååºä»»å¡
			/// </summary>
			public Dt_Task ReturnTask { get; set; }
			}
			public class PickedBarcodeInfo
			{
			@@ -2856,14 +3827,7 @@
			public decimal PickedQty { get; set; }
			public int PickRecordCount { get; set; }
			}
			/// <summary>
			/// èªå¨æåç»æ
			/// </summary>
			public class AutoSplitResult
			{
			public string NewBarcode { get; set; }
			public decimal SplitQuantity { get; set; }
			}


			public class PickingResult
			{
			@@ -2875,11 +3839,6 @@
			{
			public Dt_OutStockLockInfo LockInfo { get; set; }
			public Dt_StockInfoDetail StockDetail { get; set; }
			}

			public class SplitResultDto
			{
			public string NewBarcode { get; set; }
			}

			public class ValidationResult<T>