ZhongRui/ALDbanyunxiangmu.git

			@@ -1,16 +1,22 @@
			ï»¿using Microsoft.Extensions.Logging;
			using SqlSugar;
			using SqlSugar.Extensions;
			using System;
			using System.Collections.Generic;
			using System.Linq;
			using System.Text;
			using System.Threading.Tasks;
			using WIDESEA_BasicService;
			using WIDESEA_Common.CommonEnum;
			using WIDESEA_Common.OrderEnum;
			using WIDESEA_Common.StockEnum;
			using WIDESEA_Common.TaskEnum;
			using WIDESEA_Core;
			using WIDESEA_Core.BaseRepository;
			using WIDESEA_Core.BaseServices;
			using WIDESEA_Core.Enums;
			using WIDESEA_DTO.Basic;
			using WIDESEA_DTO.Outbound;
			using WIDESEA_IAllocateService;
			using WIDESEA_IBasicService;
			using WIDESEA_IOutboundService;
			@@ -18,13 +24,14 @@
			using WIDESEA_Model.Models;
			using WIDESEA_Model.Models.Basic;
			using WIDESEA_Model.Models.Outbound;
			using static WIDESEA_OutboundService.OutboundBatchPickingService;

			namespace WIDESEA_OutboundService
			{
			public class OutboundBatchPickingService : ServiceBase<Dt_PickingRecord, IRepository<Dt_PickingRecord>>
			public class OutboundBatchPickingService : ServiceBase<Dt_PickingRecord, IRepository<Dt_PickingRecord>>, IOutboundBatchPickingService
			{



			private readonly IUnitOfWorkManage _unitOfWorkManage;
			public IRepository<Dt_PickingRecord> Repository => BaseDal;

			@@ -61,7 +68,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) : base(BaseDal)
			IRepository<Dt_Task> taskRepository, IESSApiService eSSApiService, ILogger<OutboundPickingService> logger, IInvokeMESService invokeMESService, IDailySequenceService dailySequenceService, IAllocateService allocateService, IRepository<Dt_OutboundBatch> outboundBatchRepository) : base(BaseDal)
			{
			_unitOfWorkManage = unitOfWorkManage;
			_stockInfoService = stockInfoService;
			@@ -78,193 +85,607 @@
			_invokeMESService = invokeMESService;
			_dailySequenceService = dailySequenceService;
			_allocateService = allocateService;
			_outboundBatchRepository = outboundBatchRepository;
			}

			// <summary>
			/// è·åæççéå®ä¿¡æ¯
			/// </summary>
			public async Task<List<PalletLockInfoDto>> GetPalletLockInfos(string orderNo, string palletCode)
			{
			var lockInfos = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
			.Where(x => x.OrderNo == orderNo && x.PalletCode == palletCode)
			.Select(x => new
			{
			x.Id,
			x.OrderNo,
			x.BatchNo,
			x.MaterielCode,
			x.CurrentBarcode,
			x.AssignQuantity,
			x.PickedQty,
			x.Status,
			x.LocationCode,
			x.PalletCode
			}).ToListAsync();

			var lockInfoDtos = lockInfos.Select(x => new PalletLockInfoDto
			{
			Id = x.Id,
			OrderNo = x.OrderNo,
			BatchNo = x.BatchNo,
			MaterielCode = x.MaterielCode,
			CurrentBarcode = x.CurrentBarcode,
			AssignQuantity = x.AssignQuantity,
			PickedQty = x.PickedQty,
			Status = x.Status,
			LocationCode = x.LocationCode,
			PalletCode = x.PalletCode,
			CanSplit = (x.Status == (int)OutLockStockStatusEnum.åºåºä¸ && x.AssignQuantity - x.PickedQty > 0),
			CanPick = (x.Status == (int)OutLockStockStatusEnum.åºåºä¸ && x.PickedQty < x.AssignQuantity)
			}).ToList();

			return lockInfoDtos;
			}
			#region æ¥è¯¢æ¹æ³

			/// <summary>
			/// è·åæççå·²æ£éåè¡¨
			/// </summary>
			public async Task<List<PalletPickedInfoDto>> GetPalletPickedList(string orderNo, string palletCode)
			{
			var pickedList = await Db.Queryable<Dt_PickingRecord>()
			.Where(x => x.OrderNo == orderNo &&
			x.PalletCode == palletCode &&
			!x.IsCancelled)
			.Select(x => new PalletPickedInfoDto
			{
			Id = x.Id,
			OrderNo = x.OrderNo,
			OrderDetailId = x.OrderDetailId,
			PalletCode = x.PalletCode,
			Barcode = x.Barcode,
			MaterielCode = x.MaterielCode,
			PickedQty = x.PickQuantity,
			PickTime = x.PickTime,
			Operator = x.Operator,
			LocationCode = x.LocationCode
			})
			.ToListAsync();

			return pickedList;
			}

			/// <summary>
			/// è·åæçç¶æ
			/// </summary>
			public async Task<PalletStatusDto> GetPalletStatus(string orderNo, string palletCode)
			{
			// è·åæççéå®ä¿¡æ¯
			var lockInfos = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
			.Where(x => x.OrderNo == orderNo && x.PalletCode == palletCode)
			.ToListAsync();

			if (!lockInfos.Any())
			{
			return new PalletStatusDto
			{
			OrderNo = orderNo,
			PalletCode = palletCode,
			Status = (int)PalletStatusEnum.æ ä»»å¡,
			StatusText = "æ ä»»å¡",
			TotalItems = 0,
			CompletedItems = 0,
			PendingItems = 0
			};
			}

			var totalItems = lockInfos.Count;
			var completedItems = lockInfos.Count(x => x.Status == (int)OutLockStockStatusEnum.æ£éå®æ);
			var pendingItems = lockInfos.Count(x => x.Status == (int)OutLockStockStatusEnum.åºåºä¸);

			var status = PalletStatusEnum.æ£éä¸;
			if (pendingItems == 0 && completedItems > 0)
			{
			status = PalletStatusEnum.å·²å®æ;
			}
			else if (pendingItems > 0 && completedItems == 0)
			{
			status = PalletStatusEnum.æªå¼å§;
			}
			else if (pendingItems > 0 && completedItems > 0)
			{
			status = PalletStatusEnum.æ£éä¸;
			}

			return new PalletStatusDto
			{
			OrderNo = orderNo,
			PalletCode = palletCode,
			Status = (int)status,
			StatusText = GetPalletStatusText(status),
			TotalItems = totalItems,
			CompletedItems = completedItems,
			PendingItems = pendingItems
			};
			}

			/// <summary>
			/// è·åæåä¿¡æ¯
			/// </summary>
			public async Task<SplitPackageInfoDto> GetSplitPackageInfo(string orderNo, string palletCode, string barcode)
			{
			// æ¥æ¾éå®ä¿¡æ¯
			var lockInfo = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
			.Where(x => x.OrderNo == orderNo &&
			x.PalletCode == palletCode &&
			x.CurrentBarcode == barcode
			//&& x.Status == (int)OutLockStockStatusEnum.åºåºä¸
			)
			.FirstAsync();

			if (lockInfo == null)
			throw new Exception("æªæ¾å°ææçéå®ä¿¡æ¯");

			// è®¡ç®å©ä½å¯ææ°é
			var remainQuantity = lockInfo.AssignQuantity - lockInfo.PickedQty;

			return new SplitPackageInfoDto
			{
			OrderNo = orderNo,
			PalletCode = palletCode,
			Barcode = barcode,
			MaterielCode = lockInfo.MaterielCode,
			RemainQuantity = remainQuantity,
			AssignQuantity = lockInfo.AssignQuantity,
			PickedQty = lockInfo.PickedQty
			};
			}

			#endregion

			#region åæ¹åæ£

			/// <summary>
			/// åæ¹åæ£ç¡®è®¤
			/// </summary>
			public async Task<WebResponseContent> ConfirmBatchPicking(string orderNo, string batchNo, string palletCode, string barcode, decimal actualPickedQty)
			public async Task<WebResponseContent> ConfirmBatchPicking(string orderNo, string palletCode, string barcode)
			{
			try
			{
			_unitOfWorkManage.BeginTran();

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

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

			// 2. æ§è¡åæ£é»è¾
			var pickingResult = await ExecuteBatchPickingLogic(lockInfo, orderDetail, stockDetail, actualPickedQty);
			// æ£æ¥æ¯å¦éè¦èªå¨æå
			var autoSplitResult = await CheckAndAutoSplitIfNeeded(lockInfo, stockDetail, palletCode);
			if (autoSplitResult != null)
			{
			// å¦ææ§è¡äºèªå¨æåï¼éæ°è·åææ°çéå®ä¿¡æ¯ååºåä¿¡æ¯
			var refreshedValidation = await ValidatePickingRequest(orderNo, palletCode, barcode);
			if (!refreshedValidation.IsValid)
			{
			_unitOfWorkManage.RollbackTran();
			return WebResponseContent.Instance.Error(refreshedValidation.ErrorMessage);
			}

			// 3. æ´æ°æ¹æ¬¡å®ææ°é
			await UpdateBatchCompletedQuantity(batchNo, actualPickedQty);
			(lockInfo, orderDetail, stockDetail, batch) = refreshedValidation.Data;

			// 4. æ´æ°è®¢åç¸å³æ°æ®
			await UpdateOrderRelatedData(orderDetail.Id, actualPickedQty, orderNo);

			// 5. è®°å½æ£éåå²
			await RecordPickingHistory(pickingResult, orderNo, palletCode, batchNo);
			var actualPickedQty = lockInfo.AssignQuantity;
			var pickingResult = await ExecutePickingLogic(lockInfo, orderDetail, stockDetail, actualPickedQty);

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

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

			_unitOfWorkManage.CommitTran();

			return WebResponseContent.Instance.OK("èªå¨æåå¹¶åæ£æå", autoSplitResult);
			}

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

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

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

			_unitOfWorkManage.CommitTran();

			return WebResponseContent.Instance.OK("åæ¹åæ£æå");
			return WebResponseContent.Instance.OK("åæ£æå", new
			{
			PickedQuantity = normalPickedQty,
			Barcode = barcode,
			MaterialCode = lockInfo.MaterielCode,
			AutoSplitted = false
			});
			}
			catch (Exception ex)
			{
			_unitOfWorkManage.RollbackTran();
			_logger.LogError($"åæ¹åæ£å¤±è´¥ - OrderNo: {orderNo}, BatchNo: {batchNo}, Error: {ex.Message}");
			return WebResponseContent.Instance.Error($"åæ¹åæ£å¤±è´¥ï¼{ex.Message}");
			_logger.LogError($"åæ£å¤±è´¥ - OrderNo: {orderNo}, PalletCode: {palletCode}, Barcode: {barcode}, Error: {ex.Message}");
			return WebResponseContent.Instance.Error($"åæ£å¤±è´¥ï¼{ex.Message}");
			}
			}

			private async Task<ValidationResult<(Dt_OutStockLockInfo, Dt_OutboundOrderDetail, Dt_StockInfoDetail)>> ValidateBatchPickingRequest(
			string orderNo, string batchNo, string palletCode, string barcode, decimal actualPickedQty)
			{
			// æ¥æ¾æ¹æ¬¡éå®ä¿¡æ¯
			var lockInfo = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
			.Where(x => x.OrderNo == orderNo &&
			x.BatchNo == batchNo &&
			x.PalletCode == palletCode &&
			x.CurrentBarcode == barcode &&
			x.Status == (int)OutLockStockStatusEnum.åºåºä¸)
			.FirstAsync();

			if (lockInfo == null)
			return ValidationResult<(Dt_OutStockLockInfo, Dt_OutboundOrderDetail, Dt_StockInfoDetail)>.Error("æªæ¾å°ææçæ¹æ¬¡éå®ä¿¡æ¯");

			if (actualPickedQty <= 0 \|\| actualPickedQty > lockInfo.AssignQuantity - lockInfo.PickedQty)
			return ValidationResult<(Dt_OutStockLockInfo, Dt_OutboundOrderDetail, Dt_StockInfoDetail)>.Error("åæ£æ°éæ æ");

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

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

			return ValidationResult<(Dt_OutStockLockInfo, Dt_OutboundOrderDetail, Dt_StockInfoDetail)>.Success((lockInfo, orderDetail, stockDetail));
			}

			private async Task<PickingResult> ExecuteBatchPickingLogic(
			Dt_OutStockLockInfo lockInfo, Dt_OutboundOrderDetail orderDetail,
			Dt_StockInfoDetail stockDetail, decimal actualPickedQty)
			{
			// æ´æ°éå®ä¿¡æ¯
			lockInfo.PickedQty += actualPickedQty;
			if (lockInfo.PickedQty >= lockInfo.AssignQuantity)
			{
			lockInfo.Status = (int)OutLockStockStatusEnum.æ£éå®æ;
			}
			await _outStockLockInfoService.Db.Updateable(lockInfo).ExecuteCommandAsync();

			// æ´æ°åºå
			stockDetail.StockQuantity -= actualPickedQty;
			stockDetail.OutboundQuantity += actualPickedQty;

			if (stockDetail.StockQuantity <= 0)
			{
			stockDetail.Status = (int)StockStatusEmun.åºåºå®æ;
			}
			await _stockInfoDetailService.Db.Updateable(stockDetail).ExecuteCommandAsync();

			return new PickingResult
			{
			FinalLockInfo = lockInfo,
			ActualPickedQty = actualPickedQty
			};
			}

			private async Task UpdateBatchCompletedQuantity(string batchNo, decimal pickedQty)
			{
			await _outboundBatchRepository.Db.Updateable<Dt_OutboundBatch>()
			.SetColumns(x => x.CompletedQuantity == x.CompletedQuantity + pickedQty)
			.Where(x => x.BatchNo == batchNo)
			.ExecuteCommandAsync();

			// æ£æ¥æ¹æ¬¡æ¯å¦å®æ
			var batch = await _outboundBatchRepository.Db.Queryable<Dt_OutboundBatch>()
			.FirstAsync(x => x.BatchNo == batchNo);

			if (batch.CompletedQuantity >= batch.BatchQuantity)
			{
			batch.BatchStatus = (int)BatchStatusEnum.å·²å®æ;
			await _outboundBatchRepository.Db.Updateable(batch).ExecuteCommandAsync();
			}
			}

			#endregion

			#region æå¨æå

			/// <summary>
			/// æå¨æå
			/// åæ¶åæ£
			/// </summary>
			public async Task<WebResponseContent> ManualSplitPackage(string orderNo, string batchNo, string originalBarcode, decimal splitQuantity)
			public async Task<WebResponseContent> CancelPicking(string orderNo, string palletCode, string barcode)
			{
			try
			{
			_unitOfWorkManage.BeginTran();

			// 1. éªè¯æåè¯·æ±
			var validationResult = await ValidateManualSplitRequest(orderNo, batchNo, originalBarcode, splitQuantity);
			// æ¥æ¾åæ£è®°å½
			var pickingRecord = await Db.Queryable<Dt_PickingRecord>()
			.Where(x => x.OrderNo == orderNo &&
			x.PalletCode == palletCode &&
			x.Barcode == barcode &&
			!x.IsCancelled)
			.OrderByDescending(x => x.PickTime)
			.FirstAsync();

			if (pickingRecord == null)
			return WebResponseContent.Instance.Error("æªæ¾å°åæ£è®°å½");

			// æ¢å¤éå®ä¿¡æ¯ååºå
			var revertResult = await RevertPickingData(pickingRecord);

			// æ´æ°æ¹æ¬¡åè®¢åæ°æ®
			await RevertBatchAndOrderData(pickingRecord, revertResult);

			// æ è®°åæ£è®°å½ä¸ºå·²åæ¶
			pickingRecord.IsCancelled = true;
			pickingRecord.CancelTime = DateTime.Now;
			pickingRecord.CancelOperator = App.User.UserName;
			await Db.Updateable(pickingRecord).ExecuteCommandAsync();

			_unitOfWorkManage.CommitTran();

			return WebResponseContent.Instance.OK("åæ¶åæ£æå");
			}
			catch (Exception ex)
			{
			_unitOfWorkManage.RollbackTran();
			_logger.LogError($"åæ¶åæ£å¤±è´¥ - OrderNo: {orderNo}, PalletCode: {palletCode}, Error: {ex.Message}");
			return WebResponseContent.Instance.Error($"åæ¶åæ£å¤±è´¥ï¼{ex.Message}");
			}
			}
			#endregion


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



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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

			#endregion

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



			#region æå¨æå

			/// <summary>
			/// æå¨æå
			/// </summary>
			public async Task<WebResponseContent> ManualSplitPackage(string orderNo, string palletCode, string originalBarcode, decimal splitQuantity)
			{
			try
			{
			_unitOfWorkManage.BeginTran();

			// éªè¯æåè¯·æ±
			var validationResult = await ValidateSplitRequest(orderNo, palletCode, originalBarcode, splitQuantity);
			if (!validationResult.IsValid)
			return WebResponseContent.Instance.Error(validationResult.ErrorMessage);

			var (lockInfo, stockDetail) = validationResult.Data;

			// 2. æ§è¡æåé»è¾
			var splitResult = await ExecuteManualSplit(lockInfo, stockDetail, splitQuantity, batchNo);
			// æ§è¡æåé»è¾
			var splitResult = await ExecuteManualSplitLogic(lockInfo, stockDetail, splitQuantity, palletCode);

			_unitOfWorkManage.CommitTran();

			return WebResponseContent.Instance.OK("æå¨æåæå", new { NewBarcode = splitResult.NewBarcode });
			return WebResponseContent.Instance.OK("æå¨æåæå", splitResult);
			}
			catch (Exception ex)
			{
			_unitOfWorkManage.RollbackTran();
			_logger.LogError($"æå¨æåå¤±è´¥ - OrderNo: {orderNo}, BatchNo: {batchNo}, Barcode: {originalBarcode}, Error: {ex.Message}");
			_logger.LogError($"æå¨æåå¤±è´¥ - OrderNo: {orderNo}, Barcode: {originalBarcode}, Error: {ex.Message}");
			return WebResponseContent.Instance.Error($"æå¨æåå¤±è´¥ï¼{ex.Message}");
			}
			}

			private async Task<ValidationResult<(Dt_OutStockLockInfo, Dt_StockInfoDetail)>> ValidateManualSplitRequest(
			string orderNo, string batchNo, string originalBarcode, decimal splitQuantity)
			/// <summary>
			/// éªè¯æåè¯·æ± - å¢å¼ºåéæ°éæ§å¶
			/// </summary>
			private async Task<ValidationResult<(Dt_OutStockLockInfo, Dt_StockInfoDetail)>> ValidateSplitRequest(
			string orderNo, string palletCode, string originalBarcode, decimal splitQuantity)
			{
			_logger.LogInformation($"å¼å§éªè¯æåè¯·æ± - è®¢å: {orderNo}, æç: {palletCode}, åæ¡ç : {originalBarcode}, æåæ°é: {splitQuantity}");

			// æ¥æ¾éå®ä¿¡æ¯
			var lockInfo = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
			.Where(x => x.OrderNo == orderNo &&
			x.BatchNo == batchNo &&
			x.PalletCode == palletCode &&
			x.CurrentBarcode == originalBarcode &&
			x.Status == (int)OutLockStockStatusEnum.åºåºä¸)
			.FirstAsync();

			if (lockInfo == null)
			{
			_logger.LogWarning($"æªæ¾å°ææçéå®ä¿¡æ¯ - è®¢å: {orderNo}, æç: {palletCode}, æ¡ç : {originalBarcode}");
			return ValidationResult<(Dt_OutStockLockInfo, Dt_StockInfoDetail)>.Error("æªæ¾å°ææçéå®ä¿¡æ¯");
			}

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

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

			if (orderDetail == null)
			{
			_logger.LogWarning($"æªæ¾å°è®¢åæç» - OrderDetailId: {lockInfo.OrderDetailId}");
			return ValidationResult<(Dt_OutStockLockInfo, Dt_StockInfoDetail)>.Error("æªæ¾å°è®¢åæç»");
			}

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

			// è·ååºåä¿¡æ¯
			var stockDetail = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
			.FirstAsync(x => x.Barcode == originalBarcode && x.StockId == lockInfo.StockId);

			if (stockDetail.StockQuantity < splitQuantity)
			return ValidationResult<(Dt_OutStockLockInfo, Dt_StockInfoDetail)>.Error("æåæ°éä¸è½å¤§äºåºåæ°é");
			if (stockDetail == null)
			{
			_logger.LogWarning($"æªæ¾å°åºåä¿¡æ¯ - æ¡ç : {originalBarcode}, StockId: {lockInfo.StockId}");
			return ValidationResult<(Dt_OutStockLockInfo, Dt_StockInfoDetail)>.Error("æªæ¾å°å¯¹åºçåºåä¿¡æ¯");
			}

			if (lockInfo.AssignQuantity - lockInfo.PickedQty < splitQuantity)
			return ValidationResult<(Dt_OutStockLockInfo, Dt_StockInfoDetail)>.Error("æåæ°éä¸è½å¤§äºæªæ£éæ°é");
			_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)
			{
			_logger.LogWarning($"æåæ°éå¤§äºæªæ£éæ°é - æåæ°é: {splitQuantity}, æªæ£éæ°é: {remainingToPick}");
			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}");

			return ValidationResult<(Dt_OutStockLockInfo, Dt_StockInfoDetail)>.Success((lockInfo, stockDetail));
			}

			private async Task<SplitResultDto> ExecuteManualSplit(Dt_OutStockLockInfo lockInfo, Dt_StockInfoDetail stockDetail,
			decimal splitQuantity, string batchNo)
			/// <summary>
			/// è·åè®¢åæç»çææéå®ä¿¡æ¯çæ»åéæ°é
			/// </summary>
			private async Task<decimal> GetTotalLockAssignQuantity(long orderDetailId)
			{
			var lockInfos = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
			.Where(x => x.OrderDetailId == orderDetailId)
			.ToListAsync();

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

			// éè¦ä¿®å¤ï¼è·åè®¢åæç»å¹¶éªè¯åéæ°é
			var orderDetail = await _outboundOrderDetailService.Db.Queryable<Dt_OutboundOrderDetail>()
			.FirstAsync(x => x.Id == lockInfo.OrderDetailId);

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

			// éªè¯æåæ°éä¸ä¼å¯¼è´åéæ°éä¸ºè´æ°
			if (lockInfo.AssignQuantity < splitQuantity)
			{
			throw new InvalidOperationException($"æåæ°éè¶è¿éå®ä¿¡æ¯åéæ°éï¼æåæ°é: {splitQuantity}, åéæ°é: {lockInfo.AssignQuantity}");
			}

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

			// åå»ºæ°åºåæç»
			// è®°å½æååçåéæ°é
			decimal originalAssignQtyBefore = lockInfo.AssignQuantity;
			decimal originalOrderQtyBefore = lockInfo.OrderQuantity;
			decimal remainQty = originalAssignQtyBefore - splitQuantity;
			if (remainQty < 0)
			{
			throw new InvalidOperationException($"æååå©ä½æ°éä¸ºè´æ°ï¼ååéæ°é: {originalAssignQtyBefore}, æåæ°é: {splitQuantity}");
			}
			// åå»ºæ°åºåæç»
			var newStockDetail = new Dt_StockInfoDetail
			{
			StockId = stockDetail.StockId,
			@@ -276,100 +697,120 @@
			Barcode = newBarcode,
			Status = (int)StockStatusEmun.åºåºéå®,
			SupplyCode = stockDetail.SupplyCode,
			Unit = stockDetail.Unit
			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)
			{
			stockDetail.StockQuantity = 0;
			_logger.LogWarning($"ååºåæ°éåºç°è´æ°ï¼éç½®ä¸º0");
			}
			await _stockInfoDetailService.Db.Updateable(stockDetail).ExecuteCommandAsync();
			_logger.LogInformation($"æ´æ°ååºåæç» - åºåæ°éä» {originalStockQtyBefore} åå°å° {stockDetail.StockQuantity}");

			// åå»ºæ°éå®ä¿¡æ¯
			// åå»ºæ°éå®ä¿¡æ¯
			var newLockInfo = new Dt_OutStockLockInfo
			{
			OrderNo = lockInfo.OrderNo,
			OrderDetailId = lockInfo.OrderDetailId,
			BatchNo = batchNo,
			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,
			Operator = App.User.UserName,
			IsSplitted = 1,
			ParentLockId = lockInfo.Id,
			Operator = App.User.UserName,
			FactoryArea = lockInfo.FactoryArea,
			lineNo = lockInfo.lineNo,
			WarehouseCode = lockInfo.WarehouseCode,
			BarcodeQty = lockInfo.BarcodeQty,
			BarcodeUnit = lockInfo.BarcodeUnit,
			};
			await _outStockLockInfoService.Db.Insertable(newLockInfo).ExecuteCommandAsync();

			// æ´æ°åéå®ä¿¡æ¯
			lockInfo.AssignQuantity -= splitQuantity;
			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();

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

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

			return new SplitResultDto { NewBarcode = newBarcode };
			// è®°å½æååå²
			await RecordSplitHistory(lockInfo, stockDetail, splitQuantity, newBarcode, false);

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

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

			return splitResults;
			}


			#endregion

			#region åæ¶æå


			#region åæ¶æå

			/// <summary>
			/// åæ¶æå
			/// åæ¶æå
			/// </summary>
			public async Task<WebResponseContent> CancelSplitPackage(string orderNo, string batchNo, string newBarcode)
			public async Task<WebResponseContent> CancelSplitPackage(string orderNo, string palletCode, string newBarcode)
			{
			try
			{
			_unitOfWorkManage.BeginTran();

			// æ¥æ¾æåè®°å½åæ°éå®ä¿¡æ¯
			var splitRecord = await _splitPackageService.Db.Queryable<Dt_SplitPackageRecord>()
			.Where(x => x.NewBarcode == newBarcode && x.OrderNo == orderNo && !x.IsReverted)
			.FirstAsync();
			// 1. æ¥æ¾æåè®°å½å¹¶éªè¯
			var validationResult = await ValidateCancelSplitRequest(orderNo, palletCode, newBarcode);
			if (!validationResult.IsValid)
			return WebResponseContent.Instance.Error(validationResult.ErrorMessage);

			if (splitRecord == null)
			return WebResponseContent.Instance.Error("æªæ¾å°æåè®°å½");
			var (splitRecord, newLockInfo, newStockDetail) = validationResult.Data;

			var newLockInfo = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
			.Where(x => x.CurrentBarcode == newBarcode && x.BatchNo == batchNo)
			.FirstAsync();

			if (newLockInfo == null)
			return WebResponseContent.Instance.Error("æªæ¾å°æ°éå®ä¿¡æ¯");

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

			originalStock.StockQuantity += splitRecord.SplitQty;
			await _stockInfoDetailService.Db.Updateable(originalStock).ExecuteCommandAsync();

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

			originalLockInfo.AssignQuantity += splitRecord.SplitQty;
			await _outStockLockInfoService.Db.Updateable(originalLockInfo).ExecuteCommandAsync();
			// 3. æ£æ¥è¯¥æ¡ç æ¯å¦è¢«åæ¬¡æå
			var childSplitRecords = await _splitPackageService.Db.Queryable<Dt_SplitPackageRecord>()
			.Where(x => x.OriginalBarcode == newBarcode && !x.IsReverted)
			.ToListAsync();

			// å é¤æ°åºåæç»
			await _stockInfoDetailService.Db.Deleteable<Dt_StockInfoDetail>()
			.Where(x => x.Barcode == newBarcode)
			.ExecuteCommandAsync();
			if (childSplitRecords.Any())
			{
			return WebResponseContent.Instance.Error("è¯¥æ¡ç å·²è¢«åæ¬¡æåï¼è¯·ååæ¶åç»çæåæä½");
			}

			// å é¤æ°éå®ä¿¡æ¯
			await _outStockLockInfoService.Db.Deleteable<Dt_OutStockLockInfo>()
			.Where(x => x.Id == newLockInfo.Id)
			.ExecuteCommandAsync();

			// æ è®°æåè®°å½ä¸ºå·²æ¤é
			splitRecord.IsReverted = true;
			splitRecord.RevertTime = DateTime.Now;
			splitRecord.Operator = App.User.UserName;
			await _splitPackageService.Db.Updateable(splitRecord).ExecuteCommandAsync();
			// 4. æ§è¡åæ¶æåé»è¾
			await ExecuteCancelSplitLogic(splitRecord, originalLockInfo, newLockInfo, newStockDetail);

			_unitOfWorkManage.CommitTran();

			@@ -378,87 +819,1808 @@
			catch (Exception ex)
			{
			_unitOfWorkManage.RollbackTran();
			_logger.LogError($"åæ¶æåå¤±è´¥ - OrderNo: {orderNo}, BatchNo: {batchNo}, Barcode: {newBarcode}, Error: {ex.Message}");
			_logger.LogError($"åæ¶æåå¤±è´¥ - OrderNo: {orderNo}, PalletCode: {palletCode}, Barcode: {newBarcode}, Error: {ex.Message}");
			return WebResponseContent.Instance.Error($"åæ¶æåå¤±è´¥ï¼{ex.Message}");
			}
			}

			#endregion
			/// <summary>
			/// æ§è¡åæ¶æåé»è¾
			/// </summary>
			private async Task ExecuteCancelSplitLogic(Dt_SplitPackageRecord splitRecord,
			Dt_OutStockLockInfo originalLockInfo, Dt_OutStockLockInfo newLockInfo,
			Dt_StockInfoDetail newStockDetail)
			{
			_logger.LogInformation($"å¼å§æ§è¡åæ¶æåé»è¾ - åæ¡ç : {splitRecord.OriginalBarcode}, æ°æ¡ç : {splitRecord.NewBarcode}, æåæ°é: {splitRecord.SplitQty}");

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


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

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

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

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

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

			if (originalStock != null)
			{
			decimal originalStockQtyBefore = originalStock.StockQuantity;
			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();
			}

			if (newLockInfo != null)
			{
			// å é¤æ°éå®ä¿¡æ¯
			_logger.LogInformation($"å é¤æ°éå®ä¿¡æ¯ - æ¡ç : {newLockInfo?.CurrentBarcode}, åéæ°é: {newLockInfo?.AssignQuantity}");
			await _outStockLockInfoService.Db.Deleteable<Dt_OutStockLockInfo>()
			.Where(x => x.Id == newLockInfo.Id)
			.ExecuteCommandAsync();

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

			// æ è®°æåè®°å½ä¸ºå·²æ¤é
			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($"åæ¶æåé»è¾æ§è¡å®æ");
			}

			/// <summary>
			/// åæ¹ååº - éæ¾æªæ£éçåºå
			/// éªè¯åæ¶æåè¯·æ±
			/// </summary>
			public async Task<WebResponseContent> BatchReturnStock(string orderNo, string batchNo)
			private async Task<ValidationResult<(Dt_SplitPackageRecord, Dt_OutStockLockInfo, Dt_StockInfoDetail)>> ValidateCancelSplitRequest(
			string orderNo, string palletCode, string newBarcode)
			{
			_logger.LogInformation($"å¼å§éªè¯åæ¶æåè¯·æ± - è®¢å: {orderNo}, æç: {palletCode}, æ¡ç : {newBarcode}");

			// æ¥æ¾æåè®°å½
			var splitRecord = await _splitPackageService.Db.Queryable<Dt_SplitPackageRecord>()
			.Where(x => x.NewBarcode == newBarcode &&
			x.OrderNo == orderNo &&
			!x.IsReverted)
			.FirstAsync();

			if (splitRecord == null)
			return ValidationResult<(Dt_SplitPackageRecord, Dt_OutStockLockInfo, Dt_StockInfoDetail)>.Error("æªæ¾å°æåè®°å½");

			_logger.LogInformation($"æ¾å°æåè®°å½ - åæ¡ç : {splitRecord.OriginalBarcode}, æ°æ¡ç : {splitRecord.NewBarcode}, æåæ°é: {splitRecord.SplitQty}");

			// æ¥æ¾æ°éå®ä¿¡æ¯
			var newLockInfo = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
			.Where(x => x.CurrentBarcode == newBarcode &&
			x.PalletCode == palletCode &&
			x.OrderNo == orderNo)
			.FirstAsync();

			if (newLockInfo == null)
			return ValidationResult<(Dt_SplitPackageRecord, Dt_OutStockLockInfo, Dt_StockInfoDetail)>.Error("æªæ¾å°æ°éå®ä¿¡æ¯");

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

			if (newBarcodePickingRecords.Any())
			{
			var totalPickedQty = newBarcodePickingRecords.Sum(x => x.PickQuantity);
			_logger.LogWarning($"æ°æ¡ç {newBarcode} å·²è¢«åæ£ï¼æ»æ£éæ°é: {totalPickedQty}");
			return ValidationResult<(Dt_SplitPackageRecord, Dt_OutStockLockInfo, Dt_StockInfoDetail)>.Error(
			$"æ°æ¡ç å·²è¢«åæ£ï¼å·²æ£éæ°éï¼{totalPickedQty}ï¼ï¼è¯·ååæ¶åæ£ï¼ç¶åååæ¶æå");
			}

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

			if (originalBarcodePickingRecords.Any())
			{
			var totalPickedQty = originalBarcodePickingRecords.Sum(x => x.PickQuantity);
			_logger.LogWarning($"åæ¡ç {splitRecord.OriginalBarcode} å·²è¢«åæ£ï¼æ»æ£éæ°é: {totalPickedQty}");
			return ValidationResult<(Dt_SplitPackageRecord, Dt_OutStockLockInfo, Dt_StockInfoDetail)>.Error(
			$"åæ¡ç å·²è¢«åæ£ï¼å·²æ£éæ°éï¼{totalPickedQty}ï¼ï¼è¯·ååæ¶åæ£ï¼ç¶åååæ¶æå");
			}

			_logger.LogInformation($"æ°æ§æ¡ç åæªè¢«åæ£ï¼å¯ä»¥åæ¶æå");

			// æ£æ¥æ°æ¡ç æ¯å¦è¢«åæ¬¡æå
			var childSplitRecords = await _splitPackageService.Db.Queryable<Dt_SplitPackageRecord>()
			.Where(x => x.OriginalBarcode == newBarcode && !x.IsReverted)
			.ToListAsync();

			if (childSplitRecords.Any())
			{
			var childBarcodes = string.Join(", ", childSplitRecords.Select(x => x.NewBarcode));
			_logger.LogWarning($"æ¡ç {newBarcode} å·²è¢«åæ¬¡æåï¼çæçæ°æ¡ç : {childBarcodes}");
			return ValidationResult<(Dt_SplitPackageRecord, Dt_OutStockLockInfo, Dt_StockInfoDetail)>.Error(
			$"è¯¥æ¡ç å·²è¢«åæ¬¡æåï¼çæçæ°æ¡ç ï¼{childBarcodes}ï¼è¯·ååæ¶åç»æå");
			}

			var newStockDetail = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
			.FirstAsync(x => x.Barcode == newBarcode);

			if (newStockDetail == null)
			return ValidationResult<(Dt_SplitPackageRecord, Dt_OutStockLockInfo, Dt_StockInfoDetail)>.Error("æªæ¾å°æ°åºåæç»");

			_logger.LogInformation($"åæ¶æåéªè¯éè¿ - æ¡ç : {newBarcode}");

			return ValidationResult<(Dt_SplitPackageRecord, Dt_OutStockLockInfo, Dt_StockInfoDetail)>.Success((splitRecord, newLockInfo, newStockDetail));
			}

			#endregion

			#region æ¹éåæ¶æåé¾

			/// <summary>
			/// æ¹éåæ¶æåé¾ - åæ¶æä¸ªæ¡ç åå¶ææåç»æå
			/// </summary>
			public async Task<WebResponseContent> CancelSplitPackageChain(string orderNo, string palletCode, string startBarcode)
			{
			try
			{
			_unitOfWorkManage.BeginTran();

			// 1. æ¥æ¾æ¹æ¬¡æªå®æçéå®è®°å½
			var unfinishedLocks = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
			.Where(x => x.OrderNo == orderNo &&
			x.BatchNo == batchNo &&
			x.Status == (int)OutLockStockStatusEnum.åºåºä¸)
			.ToListAsync();
			// 1. æ¥æ¾ææç¸å³çæåè®°å½ï¼å½¢ææåé¾ï¼
			var splitChain = await GetSplitPackageChain(orderNo, startBarcode);

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

			// 2. éæ¾åºååéå®è®°å½
			foreach (var lockInfo in unfinishedLocks)
			_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())
			{
			await ReleaseLockAndStock(lockInfo);
			var pickedBarcodes = string.Join(", ", pickedBarcodesInfo.Select(x => $"{x.Barcode}(å·²æ£é{x.PickedQty})"));
			return WebResponseContent.Instance.Error(
			$"ä»¥ä¸æ¡ç å·²è¢«åæ£ï¼è¯·ååæ¶åæ£ï¼{pickedBarcodes}");
			}

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

			// 4. æ´æ°è®¢åæç»çå·²åéæ°é
			await UpdateOrderDetailAfterReturn(unfinishedLocks);
			foreach (var splitRecord in reversedChain)
			{
			_logger.LogInformation($"åæ¶æåè®°å½ - åæ¡ç : {splitRecord.OriginalBarcode}, æ°æ¡ç : {splitRecord.NewBarcode}");
			await CancelSingleSplitPackage(splitRecord, palletCode);
			}

			_unitOfWorkManage.CommitTran();

			return WebResponseContent.Instance.OK("åæ¹ååºæå");
			return WebResponseContent.Instance.OK($"æååæ¶æåé¾ï¼å±{reversedChain.Count}æ¬¡æåæä½");
			}
			catch (Exception ex)
			{
			_unitOfWorkManage.RollbackTran();
			_logger.LogError($"åæ¹ååºå¤±è´¥ - OrderNo: {orderNo}, BatchNo: {batchNo}, Error: {ex.Message}");
			return WebResponseContent.Instance.Error($"åæ¹ååºå¤±è´¥ï¼{ex.Message}");
			_logger.LogError($"åæ¶æåé¾å¤±è´¥ - OrderNo: {orderNo}, StartBarcode: {startBarcode}, Error: {ex.Message}");
			return WebResponseContent.Instance.Error($"åæ¶æåé¾å¤±è´¥ï¼{ex.Message}");
			}
			}

			/// <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>
			private async Task<List<PickedBarcodeInfo>> GetPickedBarcodesInfo(string orderNo, List<string> barcodes)
			{
			var pickedBarcodes = new List<PickedBarcodeInfo>();

			foreach (var barcode in barcodes)
			{
			var pickingRecords = await Db.Queryable<Dt_PickingRecord>()
			.Where(x => x.Barcode == barcode && x.OrderNo == orderNo && !x.IsCancelled)
			.ToListAsync();

			if (pickingRecords.Any())
			{
			var totalPickedQty = pickingRecords.Sum(x => x.PickQuantity);
			pickedBarcodes.Add(new PickedBarcodeInfo
			{
			Barcode = barcode,
			PickedQty = totalPickedQty,
			PickRecordCount = pickingRecords.Count
			});
			}
			}

			return pickedBarcodes;
			}
			/// <summary>
			/// è·åæåé¾ - æ¥æ¾æä¸ªæ¡ç çæææåè®°å½ï¼åæ¬åç»æåï¼
			/// </summary>
			public async Task<List<Dt_SplitPackageRecord>> GetSplitPackageChain(string orderNo, string startBarcode)
			{
			var allSplitRecords = new List<Dt_SplitPackageRecord>();
			var visitedBarcodes = new HashSet<string>(); // é²æ¢å¾ªç¯å¼ç¨

			// ä½¿ç¨éåè¿è¡å¹¿åº¦ä¼åæç´¢
			var queue = new Queue<string>();
			queue.Enqueue(startBarcode);
			visitedBarcodes.Add(startBarcode);

			while (queue.Count > 0)
			{
			var currentBarcode = queue.Dequeue();

			// æ¥æ¾ä»¥å½åæ¡ç ä¸ºåæ¡ç çæææåè®°å½
			var splitRecords = await _splitPackageService.Db.Queryable<Dt_SplitPackageRecord>()
			.Where(x => x.OriginalBarcode == currentBarcode &&
			x.OrderNo == orderNo &&
			!x.IsReverted)
			.ToListAsync();

			foreach (var record in splitRecords)
			{
			// é¿åéå¤å¤ç
			if (!visitedBarcodes.Contains(record.NewBarcode))
			{
			allSplitRecords.Add(record);
			queue.Enqueue(record.NewBarcode);
			visitedBarcodes.Add(record.NewBarcode);
			}
			}
			}

			return allSplitRecords;
			}

			/// <summary>
			/// åæ¶åä¸ªæåè®°å½
			/// </summary>
			private async Task CancelSingleSplitPackage(Dt_SplitPackageRecord splitRecord, string palletCode)
			{
			_logger.LogInformation($"å¼å§åæ¶åä¸ªæåè®°å½ - åæ¡ç : {splitRecord.OriginalBarcode}, æ°æ¡ç : {splitRecord.NewBarcode}");

			// åæ¬¡éªè¯åæ£ç¶æï¼é²æ¢å¹¶åæä½ï¼
			var newBarcodePickingRecords = await Db.Queryable<Dt_PickingRecord>()
			.Where(x => x.Barcode == splitRecord.NewBarcode && !x.IsCancelled)
			.ToListAsync();

			if (newBarcodePickingRecords.Any())
			{
			throw new InvalidOperationException($"æ°æ¡ç {splitRecord.NewBarcode} å¨éªè¯åè¢«åæ£ï¼æ æ³åæ¶æå");
			}

			var originalBarcodePickingRecords = await Db.Queryable<Dt_PickingRecord>()
			.Where(x => x.Barcode == splitRecord.OriginalBarcode && !x.IsCancelled)
			.ToListAsync();

			if (originalBarcodePickingRecords.Any())
			{
			throw new InvalidOperationException($"åæ¡ç {splitRecord.OriginalBarcode} å¨éªè¯åè¢«åæ£ï¼æ æ³åæ¶æå");
			}

			// æ¥æ¾ç¸å³æ°æ®
			var newLockInfo = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
			.Where(x => x.CurrentBarcode == splitRecord.NewBarcode &&
			x.PalletCode == palletCode)
			.FirstAsync();

			var newStockDetail = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
			.FirstAsync(x => x.Barcode == splitRecord.NewBarcode);

			var originalLockInfo = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
			.FirstAsync(x => x.Id == splitRecord.OutStockLockInfoId);

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

			_logger.LogInformation($"åæ¶åä¸ªæåè®°å½å®æ - åæ¡ç : {splitRecord.OriginalBarcode}, æ°æ¡ç : {splitRecord.NewBarcode}");
			}
			#endregion

			#region æåä¿¡æ¯æ¥è¯¢å¢å¼º

			/// <summary>
			/// è·åæåé¾ä¿¡æ¯
			/// </summary>
			public async Task<WebResponseContent> GetSplitPackageChainInfo(string orderNo, string barcode)
			{
			try
			{
			var splitChain = await GetSplitPackageChain(orderNo, barcode);

			var chainInfo = new SplitPackageChainInfoDto
			{
			OriginalBarcode = barcode,
			TotalSplitTimes = splitChain.Count,
			SplitChain = splitChain.Select(x => new SplitChainItemDto
			{
			SplitTime = x.SplitTime,
			OriginalBarcode = x.OriginalBarcode,
			NewBarcode = x.NewBarcode,
			SplitQuantity = x.SplitQty,
			Operator = x.Operator,
			IsReverted = x.IsReverted,
			IsAutoSplit = x.IsAutoSplit
			}).ToList()
			};

			return WebResponseContent.Instance.OK("è·åæå", chainInfo);
			}
			catch (Exception ex)
			{
			_logger.LogError($"è·åæåé¾ä¿¡æ¯å¤±è´¥ - OrderNo: {orderNo}, Barcode: {barcode}, Error: {ex.Message}");
			return WebResponseContent.Instance.Error("è·åæåé¾ä¿¡æ¯å¤±è´¥");
			}
			}


			/// <summary>
			/// æ¥æ¾æ ¹æ¡ç
			/// </summary>
			public async Task<string> FindRootBarcode(string orderNo, string startBarcode)
			{
			var currentBarcode = startBarcode;
			var visited = new HashSet<string>();

			while (!string.IsNullOrEmpty(currentBarcode) && !visited.Contains(currentBarcode))
			{
			visited.Add(currentBarcode);

			// æ¥æ¾å½åæ¡ç æ¯å¦æ¯ç±å¶ä»æ¡ç æåèæ¥
			var parentRecord = await _splitPackageService.Db.Queryable<Dt_SplitPackageRecord>()
			.Where(x => x.NewBarcode == currentBarcode &&
			x.OrderNo == orderNo &&
			!x.IsReverted)
			.FirstAsync();

			if (parentRecord == null)
			{
			// æ²¡æç¶çº§æåè®°å½ï¼è¯´æè¿æ¯æ ¹æ¡ç
			return currentBarcode;
			}

			currentBarcode = parentRecord.OriginalBarcode;
			}

			// å¦æåºç°å¾ªç¯å¼ç¨ï¼è¿åèµ·å§æ¡ç
			return startBarcode;
			}
			#endregion

			#region æ´æ°æ¹æ¬¡ç¶ææ£æ¥

			/// <summary>
			/// æ£æ¥å¹¶æ´æ°æ¹æ¬¡ç¶æ
			/// </summary>
			private async Task CheckAndUpdateBatchStatus(string batchNo)
			{
			var batch = await _outboundBatchRepository.Db.Queryable<Dt_OutboundBatch>()
			.FirstAsync(x => x.BatchNo == batchNo);

			if (batch != null)
			{
			// éæ°è®¡ç®æ¹æ¬¡å®ææ°é
			var batchLocks = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
			.Where(x => x.BatchNo == batchNo)
			.ToListAsync();

			var completedQuantity = batchLocks.Where(x => x.Status == (int)OutLockStockStatusEnum.æ£éå®æ)
			.Sum(x => x.PickedQty);

			batch.CompletedQuantity = completedQuantity;

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

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

			#endregion

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

			return totalQty;
			}

			/// <summary>
			/// ç»ä¸ååºæ¹æ³ - å¤çæçä¸ææå©ä½è´§ç©
			/// </summary>
			public async Task<WebResponseContent> ExecutePalletReturn(string orderNo, string palletCode, string returnReason = "åæ¹ååº")
			{
			try
			{
			_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} å¯¹åºçåºåä¿¡æ¯");

			var task = await GetCurrentTask(orderNo, palletCode);
			if (task == null)
			return WebResponseContent.Instance.Error("æªæ¾å°å¯¹åºçä»»å¡ä¿¡æ¯");

			// åææçç¶æ
			var statusAnalysis = await AnalyzePalletStatus(orderNo, palletCode, stockInfo.Id);
			if (!statusAnalysis.HasItemsToReturn)
			return await HandleNoReturnItems(orderNo, palletCode, task, stockInfo.Id);

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

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

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

			_unitOfWorkManage.CommitTran();

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

			// åå»ºESSååºä»»å¡
			if (returnBarcodes.Any())
			{
			_logger.LogInformation($"åå»ºååºAGVä»»å¡ - è®¢å: {orderNo}, æç: {palletCode}, æ¡ç æ°é: {returnBarcodes.Count}, åå : {returnReason}");
			await CreateReturnTaskAndHandleESS(orderNo, palletCode, task, TaskTypeEnum.InPick, stockInfo.PalletType);
			}

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

			return WebResponseContent.Instance.OK($"ååºæä½æåï¼å±ååºæ°éï¼{statusAnalysis.TotalReturnQty}", new
			{
			ReturnQuantity = statusAnalysis.TotalReturnQty,
			ReturnBarcodes = returnBarcodes,
			Reason = returnReason,
			PalletCode = palletCode,
			OrderNo = orderNo
			});
			}
			catch (Exception ex)
			{
			_unitOfWorkManage.RollbackTran();
			_logger.LogError($"ååºæä½å¤±è´¥ - OrderNo: {orderNo}, PalletCode: {palletCode}, Error: {ex.Message}");
			return WebResponseContent.Instance.Error($"ååºæä½å¤±è´¥: {ex.Message}");
			}
			}
			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>
			public async Task<WebResponseContent> BatchReturnStock(string orderNo, string palletCode)
			{
			return await ExecutePalletReturn(orderNo, palletCode, "åæ¹ååº");
			}

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

			/// <summary>
			/// åèµ°ç©ºç®± - åæ§è¡ååºåæ¸ç - å¢å¼ºçæ¬
			/// </summary>
			public async Task<WebResponseContent> RemoveEmptyPallet(string orderNo, string palletCode)
			{
			try
			{
			_unitOfWorkManage.BeginTran();

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

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

			var completedLocks = validationResult.Data;

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

			// 3. æ¸çå¯¹åºçåºåè®°å½ç¶æ
			foreach (var lockInfo in completedLocks)
			{
			await CleanupStockInfo(lockInfo);
			}

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

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

			_unitOfWorkManage.CommitTran();

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

			return WebResponseContent.Instance.OK("åèµ°ç©ºç®±æå");
			}
			catch (Exception ex)
			{
			_unitOfWorkManage.RollbackTran();
			_logger.LogError($"åèµ°ç©ºç®±å¤±è´¥ - OrderNo: {orderNo}, PalletCode: {palletCode}, Error: {ex.Message}");
			return WebResponseContent.Instance.Error($"åèµ°ç©ºç®±å¤±è´¥ï¼{ex.Message}");
			}
			}
			/// <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("æçç¶æå¼å¸¸ï¼æç©åä½æ æ³è®¡ç®ååºæ°é");
			}
			}
			private async Task CleanupZeroStockData(int stockId)
			{
			try
			{
			// 1. å é¤åºåæ°éä¸º0çæç»è®°å½
			var deleteDetailCount = await _stockInfoDetailService.Db.Deleteable<Dt_StockInfoDetail>()
			.Where(x => x.StockId == stockId && x.StockQuantity == 0 && (x.Status == StockStatusEmun.åºåºå®æ.ObjToInt() \|\| x.Status ==
			StockStatusEmun.å¥åºå®æ.ObjToInt()))
			.ExecuteCommandAsync();

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

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



			}
			catch (Exception ex)
			{
			_logger.LogWarning($"æ¸çé¶åºåæ°æ®å¤±è´¥ - StockId: {stockId}, Error: {ex.Message}");
			// æ³¨æï¼æ¸çå¤±è´¥ä¸åºè¯¥å½±åä¸»æµç¨
			}
			}
			/// <summary>
			/// æ´æ°è®¢åç¶æï¼ååºåï¼
			/// </summary>
			private async Task 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(
			string orderNo, string palletCode, string barcode)
			{
			_logger.LogInformation($"å¼å§éªè¯åæ£è¯·æ± - è®¢å: {orderNo}, æç: {palletCode}, æ¡ç : {barcode}");

			// æ¥æ¾éå®ä¿¡æ¯
			var lockInfo = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
			.Where(x => x.OrderNo == orderNo &&
			x.PalletCode == palletCode &&
			x.CurrentBarcode == barcode &&
			x.Status == (int)OutLockStockStatusEnum.åºåºä¸)
			.FirstAsync();

			if (lockInfo == null)
			return ValidationResult<(Dt_OutStockLockInfo, Dt_OutboundOrderDetail, Dt_StockInfoDetail, Dt_OutboundBatch)>.Error("æªæ¾å°ææçéå®ä¿¡æ¯");

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

			// æ£æ¥æ¯å¦å·²ç»åæ£å®æ
			if (lockInfo.PickedQty >= lockInfo.AssignQuantity)
			return ValidationResult<(Dt_OutStockLockInfo, Dt_OutboundOrderDetail, Dt_StockInfoDetail, Dt_OutboundBatch)>.Error("è¯¥æ¡ç å·²åæ£å®æ");

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

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

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

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

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

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

			if (stockDetail == null)
			return ValidationResult<(Dt_OutStockLockInfo, Dt_OutboundOrderDetail, Dt_StockInfoDetail, Dt_OutboundBatch)>.Error("æªæ¾å°å¯¹åºçåºåä¿¡æ¯");

			// éªè¯åºåæ°é
			if (stockDetail.StockQuantity < remainingToPick)
			return ValidationResult<(Dt_OutStockLockInfo, Dt_OutboundOrderDetail, Dt_StockInfoDetail, Dt_OutboundBatch)>.Error(
			$"åºåæ°éä¸è¶³ï¼éè¦æ£éï¼{remainingToPick}ï¼å®éåºåï¼{stockDetail.StockQuantity}");

			// éªè¯åºåç¶æ
			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>()
			.FirstAsync(x => x.BatchNo == lockInfo.OutboundBatchNo);

			_logger.LogInformation($"åæ£éªè¯éè¿ - æ¡ç : {barcode}, å©ä½éæ£é: {remainingToPick}, å¯ç¨åºå: {stockDetail.StockQuantity}");

			return ValidationResult<(Dt_OutStockLockInfo, Dt_OutboundOrderDetail, Dt_StockInfoDetail, Dt_OutboundBatch)>.Success((lockInfo, orderDetail, stockDetail, batch));
			}


			/// <summary>
			/// æ£æ¥å¹¶æ§è¡èªå¨æåï¼å¦æéè¦ï¼
			/// </summary>
			private async Task<List<SplitResult>> CheckAndAutoSplitIfNeeded(Dt_OutStockLockInfo lockInfo, Dt_StockInfoDetail stockDetail, string palletCode)
			{
			// æ£æ¥æ¯å¦éè¦èªå¨æåçæ¡ä»¶ï¼
			// 1. åºåæ°éå¤§äºåéæ°é
			// 2. éå®ä¿¡æ¯ç¶æä¸ºåºåºä¸
			// 3. æªæ£éæ°éçäºåéæ°éï¼è¡¨ç¤ºè¿æªå¼å§æ£éï¼
			bool needAutoSplit = stockDetail.StockQuantity > lockInfo.AssignQuantity &&
			lockInfo.Status == (int)OutLockStockStatusEnum.åºåºä¸ &&
			lockInfo.PickedQty == 0;

			if (!needAutoSplit)
			return null;

			// è®¡ç®æåæ°é = åºåæ°é - åéæ°é
			decimal splitQuantity = stockDetail.StockQuantity - lockInfo.AssignQuantity;

			// æ§è¡èªå¨æå
			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)
			{
			_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
			{
			StockId = stockDetail.StockId,
			MaterielCode = stockDetail.MaterielCode,
			OrderNo = stockDetail.OrderNo,
			BatchNo = stockDetail.BatchNo,
			StockQuantity = splitQuantity,
			OutboundQuantity = 0,
			Barcode = newBarcode,
			Status = (int)StockStatusEmun.åºåºéå®,
			SupplyCode = stockDetail.SupplyCode,
			Unit = stockDetail.Unit,
			BarcodeQty = stockDetail.BarcodeQty,
			BarcodeUnit = stockDetail.BarcodeUnit,
			BusinessType = stockDetail.BusinessType,
			InboundOrderRowNo = stockDetail.InboundOrderRowNo,
			};
			await _stockInfoDetailService.Db.Insertable(newStockDetail).ExecuteCommandAsync();
			_logger.LogInformation($"åå»ºæ°åºåæç» - æ¡ç : {newBarcode}, åºåæ°é: {splitQuantity}");

			// æ´æ°ååºåæç»
			// éè¦ä¿®å¤ï¼èªå¨æåæ¶ï¼ååºåæ°éä¿æä¸åï¼å ä¸ºæä»¬è¦åæ£çå°±æ¯åéæ°é
			// stockDetail.StockQuantity ä¿æä¸å

			_logger.LogInformation($"ååºåæç»ä¿æä¸å - åºåæ°é: {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}");

			// èªå¨æåæ¶ï¼åéå®ä¿¡æ¯çåéæ°éä¿æä¸å
			// å ä¸ºèªå¨æååï¼åæ¡ç ä»ç¶éè¦è¢«åæ£ï¼åéæ°éä¸åºè¯¥æ¹å
			_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;
			}


			#endregion

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

			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)
			{
			throw new InvalidOperationException($"è®¢åæç»åéæ°éä¸è¶³ï¼éè¦æ£é {actualPickedQty}ï¼å¯ç¨åéæ°é {orderDetail.AllocatedQuantity}");
			}

			if (orderDetail.LockQuantity < actualPickedQty)
			{
			throw new InvalidOperationException($"è®¢åæç»éå®æ°éä¸è¶³ï¼éè¦æ£é {actualPickedQty}ï¼å¯ç¨éå®æ°é {orderDetail.LockQuantity}");
			}

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

			// åç¡®å¤ææ£éå®æç¶æ
			if (Math.Abs(lockInfo.PickedQty - lockInfo.AssignQuantity) < 0.001m)
			{
			lockInfo.Status = (int)OutLockStockStatusEnum.æ£éå®æ;
			_logger.LogInformation($"éå®ä¿¡æ¯ç¶ææ´æ°ä¸ºæ£éå®æ");
			}
			else if (lockInfo.PickedQty > 0)
			{
			lockInfo.Status = (int)OutLockStockStatusEnum.åºåºä¸;
			_logger.LogInformation($"éå®ä¿¡æ¯ç¶æä¿æä¸ºåºåºä¸ï¼é¨åæ£éï¼");
			}

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

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

			return new PickingResult
			{
			FinalLockInfo = lockInfo,
			ActualPickedQty = actualPickedQty
			};
			}

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

			if (lockInfo == null)
			{
			throw new InvalidOperationException($"æªæ¾å°å¯¹åºçéå®ä¿¡æ¯ï¼ID: {pickingRecord.OutStockLockId}");
			}

			decimal originalPickedQty = lockInfo.PickedQty;
			decimal originalAssignQty = lockInfo.AssignQuantity; // è®°å½åå§åéæ°é

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

			// ç¡®ä¿å·²æ£éæ°éä¸ä¼ä¸ºè´æ°
			if (lockInfo.PickedQty < 0)
			{
			_logger.LogWarning($"å·²æ£éæ°éåºç°è´æ°ï¼éç½®ä¸º0ãåå¼: {lockInfo.PickedQty + pickingRecord.PickQuantity}, æ¢å¤æ°é: {pickingRecord.PickQuantity}");
			lockInfo.PickedQty = 0;
			}

			_logger.LogInformation($"æ¢å¤éå®ä¿¡æ¯ - å·²æ£éæ°éä» {originalPickedQty} åå°å° {lockInfo.PickedQty}");
			_logger.LogInformation($"éå®ä¿¡æ¯åéæ°éä¿æä¸å: {originalAssignQty}");

			// æ¢å¤éå®ç¶æ
			if (lockInfo.PickedQty <= 0)
			{
			lockInfo.Status = (int)OutLockStockStatusEnum.åºåºä¸;
			_logger.LogInformation($"éå®ä¿¡æ¯ç¶ææ¢å¤ä¸ºåºåºä¸");
			}
			else if (lockInfo.PickedQty < lockInfo.AssignQuantity)
			{
			lockInfo.Status = (int)OutLockStockStatusEnum.åºåºä¸; // é¨åæ£éç¶æ
			_logger.LogInformation($"éå®ä¿¡æ¯ç¶ææ¢å¤ä¸ºåºåºä¸ï¼é¨åæ£éï¼");
			}

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

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

			if (stockDetail == null)
			{
			throw new InvalidOperationException($"æªæ¾å°å¯¹åºçåºåä¿¡æ¯ï¼æ¡ç : {pickingRecord.Barcode}");
			}

			decimal originalStockQty = stockDetail.StockQuantity;
			decimal originalOutboundQty = stockDetail.OutboundQuantity;

			stockDetail.StockQuantity += pickingRecord.PickQuantity;
			stockDetail.OutboundQuantity -= pickingRecord.PickQuantity;

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

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

			// æ¢å¤åºåç¶æ
			if (stockDetail.StockQuantity > 0)
			{
			stockDetail.Status = (int)StockStatusEmun.åºåºéå®;
			_logger.LogInformation($"åºåç¶ææ¢å¤ä¸ºåºåºéå®");
			}

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

			_logger.LogInformation($"æ¢å¤æ£éæ°æ®å®æ - æ¡ç : {pickingRecord.Barcode}");

			return new RevertPickingResult
			{
			LockInfo = lockInfo,
			StockDetail = stockDetail
			};
			}

			#endregion

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

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

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

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

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

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

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

			_logger.LogInformation($"æ¹æ¬¡åè®¢åæ°æ®æ´æ°å®æ");
			}

			private async Task RevertBatchAndOrderData(Dt_PickingRecord pickingRecord, RevertPickingResult revertResult)
			{
			_logger.LogInformation($"å¼å§æ¢å¤æ¹æ¬¡åè®¢åæ°æ®");

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

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

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

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

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

			if (orderDetail != null)
			{
			decimal originalOverOutQty = orderDetail.OverOutQuantity;
			decimal originalAllocatedQty = orderDetail.AllocatedQuantity;
			decimal originalLockQty = orderDetail.LockQuantity;

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

			_logger.LogInformation($"æ¢å¤è®¢åæç» - å·²åºåºæ°éä» {originalOverOutQty} åå°å° {orderDetail.OverOutQuantity}");
			_logger.LogInformation($"è®¢åæç»åéæ°éä¿æä¸å: {originalAllocatedQty}");
			_logger.LogInformation($"è®¢åæç»éå®æ°éä¿æä¸å: {originalLockQty}");

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

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

			_logger.LogInformation($"æ¢å¤æ¹æ¬¡åè®¢åæ°æ®å®æ");
			}

			private async Task UpdateBatchAllocateStatus(Dt_OutboundOrderDetail orderDetail)
			{
			if (orderDetail.AllocatedQuantity >= orderDetail.NeedOutQuantity)
			{
			orderDetail.BatchAllocateStatus = OrderDetailStatusEnum.AssignOver.ObjToInt();
			}
			else if (orderDetail.AllocatedQuantity > 0)
			{
			orderDetail.BatchAllocateStatus = OrderDetailStatusEnum.AssignOverPartial.ObjToInt();
			}
			else
			{
			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.Status = (int)OutLockStockStatusEnum.å·²ååº;
			lockInfo.Operator = App.User.UserName;
			await _outStockLockInfoService.Db.Updateable(lockInfo).ExecuteCommandAsync();
			}

			private async Task UpdateBatchStatusForReturn(string batchNo)
			/// <summary>
			/// æ´æ°æ¹æ¬¡ç¶æï¼ååºï¼
			/// </summary>
			private async Task UpdateBatchStatusForReturn(string outboundBatchNo, List<Dt_OutStockLockInfo> returnedLocks)
			{
			await _outboundBatchRepository.Db.Updateable<Dt_OutboundBatch>()
			.SetColumns(x => new Dt_OutboundBatch
			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)
			{
			BatchStatus = (int)BatchStatusEnum.å·²ååº,
			Operator = App.User.UserName
			})
			.Where(x => x.BatchNo == batchNo)
			.ExecuteCommandAsync();
			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);
			@@ -468,24 +2630,125 @@
			var orderDetailId = group.Key;
			var returnedQty = group.Sum(x => x.AssignQuantity - x.PickedQty);

			await _outboundOrderDetailService.Db.Updateable<Dt_OutboundOrderDetail>()
			.SetColumns(x => x.AllocatedQuantity == x.AllocatedQuantity - returnedQty)
			.Where(x => x.Id == orderDetailId)
			.ExecuteCommandAsync();
			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>
			/// <param name="palletCode"></param>
			/// <param name="targetAddress"></param>
			/// <param name="returnTask"></param>
			/// <returns></returns>
			/// <exception cref="Exception"></exception>
			private async Task SendESSCommands(string palletCode, string targetAddress, Dt_Task returnTask)
			{
			try
			{
			// 1. åéæµå¨ä¿¡å·
			var moveResult = await _eSSApiService.MoveContainerAsync(new WIDESEA_DTO.Basic.MoveContainerRequest
			{
			slotCode = movestations[targetAddress],
			containerCode = palletCode
			});

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

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

			#endregion

			#region è¾å©æ¹æ³

			private async Task<string> GenerateNewBarcode()
			{
			var seq = await _dailySequenceService.GetNextSequenceAsync();
			return "WSLOT" + DateTime.Now.ToString("yyyyMMdd") + seq.ToString()?.PadLeft(5, '0');
			return "WSLOT" + DateTime.Now.ToString("yyyyMMdd") + seq.ToString().PadLeft(5, '0');
			}

			private async Task RecordSplitHistory(Dt_OutStockLockInfo lockInfo, Dt_StockInfoDetail stockDetail,decimal splitQty, string newBarcode)
			private async Task RecordSplitHistory(Dt_OutStockLockInfo lockInfo, Dt_StockInfoDetail stockDetail, decimal splitQty, string newBarcode, bool isAutoSplit, decimal? originalStockQuantity = null)
			{
			var splitHistory = new Dt_SplitPackageRecord
			{
			@@ -497,18 +2760,23 @@
			NewBarcode = newBarcode,
			SplitQty = splitQty,
			SplitTime = DateTime.Now,
			Status = (int)SplitPackageStatusEnum.å·²æå
			Status = (int)SplitPackageStatusEnum.å·²æå,
			IsAutoSplit = isAutoSplit,
			// SplitType = isAutoSplit ? "èªå¨æå" : "æå¨æå"
			OriginalStockQuantity = originalStockQuantity ?? stockDetail.StockQuantity,
			//RemainingStockQuantity = stockDetail.StockQuantity - splitQty
			TaskNum = lockInfo.TaskNum
			};

			await _splitPackageService.Db.Insertable(splitHistory).ExecuteCommandAsync();
			}

			private async Task RecordPickingHistory(PickingResult result, string orderNo, string palletCode, string batchNo)
			private async Task RecordPickingHistory(PickingResult result, string orderNo, string palletCode)
			{
			var pickingRecord = new Dt_PickingRecord
			{
			OrderNo = orderNo,
			// BatchNo = batchNo,
			// BatchNo = result.FinalLockInfo.BatchNo,
			OrderDetailId = result.FinalLockInfo.OrderDetailId,
			PalletCode = palletCode,
			Barcode = result.FinalLockInfo.CurrentBarcode,
			@@ -516,56 +2784,115 @@
			PickQuantity = result.ActualPickedQty,
			PickTime = DateTime.Now,
			Operator = App.User.UserName,
			OutStockLockId = result.FinalLockInfo.Id
			OutStockLockId = result.FinalLockInfo.Id,

			BarcodeUnit = result.FinalLockInfo.BarcodeUnit,
			BarcodeQty = result.FinalLockInfo.BarcodeQty,
			BatchNo = result.FinalLockInfo.BatchNo,
			lineNo = result.FinalLockInfo.lineNo,
			SupplyCode = result.FinalLockInfo.SupplyCode,
			WarehouseCode = result.FinalLockInfo.WarehouseCode,
			// IsCancelled = false
			};

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

			private async Task UpdateOrderRelatedData(int orderDetailId, decimal pickedQty, string orderNo)
			{
			// æ´æ°è®¢åæç»çå·²åºåºæ°é
			await _outboundOrderDetailService.Db.Updateable<Dt_OutboundOrderDetail>()
			.SetColumns(x => new Dt_OutboundOrderDetail
			{
			OverOutQuantity = x.OverOutQuantity + pickedQty,
			AllocatedQuantity = x.AllocatedQuantity - pickedQty
			})
			.Where(x => x.Id == orderDetailId)
			.ExecuteCommandAsync();

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

			private async Task CheckAndUpdateOrderStatus(string orderNo)
			{
			var orderDetails = await _outboundOrderDetailService.Db.Queryable<Dt_OutboundOrderDetail>()
			.LeftJoin<Dt_OutboundOrder>((o, item) => o.OrderId == item.Id)
			.Where((o, item) => item.OrderNo == orderNo)
			.Select((o, item) => o)
			.ToListAsync();


			.LeftJoin<Dt_OutboundOrder>((detail, order) => detail.OrderId == order.Id)
			.Where((detail, order) => order.OrderNo == orderNo)
			.Select((detail, order) => detail)
			.ToListAsync();

			bool allCompleted = orderDetails.All(x => x.OverOutQuantity >= x.NeedOutQuantity);

			if (allCompleted)
			var orderStatus = allCompleted ? (int)OutOrderStatusEnum.åºåºå®æ : (int)OutOrderStatusEnum.åºåºä¸;

			await _outboundOrderService.Db.Updateable<Dt_OutboundOrder>()
			.SetColumns(x => x.OrderStatus == orderStatus)
			.Where(x => x.OrderNo == orderNo)
			.ExecuteCommandAsync();
			}
			private string GetPalletStatusText(PalletStatusEnum status)
			{
			return status switch
			{
			await _outboundOrderService.Db.Updateable<Dt_OutboundOrder>()
			.SetColumns(x => new Dt_OutboundOrder { OrderStatus = (int)OutOrderStatusEnum.åºåºå®æ })
			.Where(x => x.OrderNo == orderNo)
			.ExecuteCommandAsync();
			}
			PalletStatusEnum.æªå¼å§ => "æªå¼å§",
			PalletStatusEnum.æ£éä¸ => "æ£éä¸",
			PalletStatusEnum.å·²å®æ => "å·²å®æ",
			PalletStatusEnum.æ ä»»å¡ => "æ ä»»å¡",
			_ => "æªç¥"
			};
			}
			#endregion


			#region DTOç±»
			/// <summary>
			/// æ¡ç ç¶æä¿¡æ¯DTO
			/// </summary>
			public class BarcodeStatusInfoDto
			{
			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>();
			}
			public class PickedBarcodeInfo
			{
			public string Barcode { get; set; }
			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
			{
			public Dt_OutStockLockInfo FinalLockInfo { get; set; }
			public decimal ActualPickedQty { get; set; }
			}

			public class RevertPickingResult
			{
			public Dt_OutStockLockInfo LockInfo { get; set; }
			public Dt_StockInfoDetail StockDetail { get; set; }
			}

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

			public class ValidationResult<T>
			{
			public bool IsValid { get; set; }
			public string ErrorMessage { get; set; }
			public T Data { get; set; }

			public static ValidationResult<T> Success(T data) => new ValidationResult<T> { IsValid = true, Data = data };
			public static ValidationResult<T> Error(string message) => new ValidationResult<T> { IsValid = false, ErrorMessage = message };
			}

			#endregion
			}


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