ZhongRui/ALDbanyunxiangmu.git

			@@ -8,7 +8,9 @@
			using System.Collections.Generic;
			using System.Linq;
			using System.Text;
			using System.Text.Json;
			using System.Threading.Tasks;
			using WIDESEA_Common.CommonEnum;
			using WIDESEA_Common.LocationEnum;
			using WIDESEA_Common.OrderEnum;
			using WIDESEA_Common.StockEnum;
			@@ -16,11 +18,15 @@
			using WIDESEA_Core;
			using WIDESEA_Core.BaseRepository;
			using WIDESEA_Core.BaseServices;
			using WIDESEA_Core.Enums;
			using WIDESEA_Core.Helper;
			using WIDESEA_DTO.Allocate;
			using WIDESEA_DTO.Basic;
			using WIDESEA_DTO.Inbound;
			using WIDESEA_DTO.Outbound;
			using WIDESEA_IAllocateService;
			using WIDESEA_IBasicService;
			using WIDESEA_IInboundService;
			using WIDESEA_IOutboundService;
			using WIDESEA_IStockService;
			using WIDESEA_Model.Models;
			@@ -47,6 +53,10 @@
			private readonly IESSApiService _eSSApiService;
			private readonly IInvokeMESService _invokeMESService;
			private readonly IDailySequenceService _dailySequenceService;
			private readonly IAllocateService _allocateService;
			private readonly IRepository<Dt_InboundOrder> _inboundOrderRepository;
			private readonly IInboundOrderDetailService _inboundOrderDetailService;


			private readonly ILogger<OutboundPickingService> _logger;

			@@ -67,7 +77,7 @@
			public OutboundPickingService(IRepository<Dt_PickingRecord> BaseDal, IUnitOfWorkManage unitOfWorkManage, IStockInfoService stockInfoService, IStockService stockService,
			IOutStockLockInfoService outStockLockInfoService, IStockInfoDetailService stockInfoDetailService, ILocationInfoService locationInfoService,
			IOutboundOrderDetailService outboundOrderDetailService, ISplitPackageService splitPackageService, IOutboundOrderService outboundOrderService,
			IRepository<Dt_Task> taskRepository, IESSApiService eSSApiService, ILogger<OutboundPickingService> logger, IInvokeMESService invokeMESService, IDailySequenceService dailySequenceService) : base(BaseDal)
			IRepository<Dt_Task> taskRepository, IESSApiService eSSApiService, ILogger<OutboundPickingService> logger, IInvokeMESService invokeMESService, IDailySequenceService dailySequenceService, IAllocateService allocateService, IRepository<Dt_InboundOrder> inboundOrderRepository,IInboundOrderDetailService inboundOrderDetailService) : base(BaseDal)
			{
			_unitOfWorkManage = unitOfWorkManage;
			_stockInfoService = stockInfoService;
			@@ -83,1651 +93,13 @@
			_logger = logger;
			_invokeMESService = invokeMESService;
			_dailySequenceService = dailySequenceService;
			_allocateService = allocateService;
			_inboundOrderRepository = inboundOrderRepository;
			_inboundOrderDetailService = inboundOrderDetailService;
			}


			#region æ¥è¯¢åºåºè¯¦æåè¡¨
			public async Task<List<OutStockLockListResp>> GetOutStockLockListAsync(string orderNo)
			{
			var locks = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
			.Where(t => t.OrderNo == orderNo)
			.ToListAsync();

			return locks.Select(t => new OutStockLockListResp
			{
			Id = t.Id,
			// TaskNum = t.TaskNum,
			PalletCode = t.PalletCode,
			CurrentBarcode = t.CurrentBarcode,
			AssignQuantity = t.AssignQuantity,
			PickedQty = t.PickedQty,
			Status = t.Status,
			// IsSplitted = t.IsSplitted
			}).ToList();
			}
			#endregion
			public async Task<WebResponseContent> ValidateBarcode(string barcode)
			{
			try
			{
			if (string.IsNullOrEmpty(barcode))
			{
			return WebResponseContent.Instance.Error("æ¡ç ä¸è½ä¸ºç©º");
			}

			// æ ¹æ®æ¡ç æ¥è¯¢åºåæç»
			var stockDetail = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
			.Includes(x => x.StockInfo)
			.Where(x => x.Barcode == barcode)
			.FirstAsync();

			if (stockDetail == null)
			{
			return WebResponseContent.Instance.Error("æ¡ç ä¸åå¨");
			}



			var result = new
			{
			Barcode = barcode,
			MaterielCode = stockDetail.MaterielCode,

			BatchNo = stockDetail.BatchNo,
			AvailableQuantity = stockDetail.StockQuantity - stockDetail.OutboundQuantity,
			LocationCode = stockDetail.StockInfo?.LocationCode,
			PalletCode = stockDetail.StockInfo?.PalletCode
			};

			return WebResponseContent.Instance.OK(null, result);
			}
			catch (Exception ex)
			{
			return WebResponseContent.Instance.Error($"æ¡ç éªè¯å¤±è´¥: {ex.Message}");
			}
			}

			// æ£æ¥å¹¶æ´æ°è®¢åç¶æ
			private async Task CheckAndUpdateOrderStatus(string orderNo)
			{

			var orderDetails = _stockInfoDetailService.Db.Queryable<Dt_OutboundOrderDetail>()
			.LeftJoin<Dt_OutboundOrder>((o, item) => o.OrderId == item.Id) // å³èæ¡ä»¶ï¼ç¶è¡¨ Id = åè¡¨ OrderId
			.Where((o, item) => item.OrderNo == orderNo) // è¿æ»¤ç¶è¡¨ OrderNo
			.Select((o, item) => o) // åªè¿ååè¡¨æ°æ®
			.ToList();

			//var orderDetails = await _stockInfoDetailService.Db.Queryable<Dt_OutboundOrderDetail>()
			// .Where(x => x.OrderId == orderNo.ObjToInt())
			// .ToListAsync();

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

			if (allCompleted)
			{
			try
			{
			await _outboundOrderService.Db.Updateable<Dt_OutboundOrder>()
			.SetColumns(x => x.OrderStatus == 2) // å·²å®æ
			.Where(x => x.OrderNo == orderNo)
			.ExecuteCommandAsync();

			var outboundOrder = _stockInfoService.Db.Queryable<Dt_OutboundOrder>().First(x => x.OrderNo == orderNo);


			if (outboundOrder != null && outboundOrder.OrderStatus == OutOrderStatusEnum.åºåºå®æ.ObjToInt())
			{

			if (outboundOrder.OrderType == OutOrderTypeEnum.Allocate.ObjToInt().ObjToInt())//è°æ¨åºåº
			{

			}
			else if (outboundOrder.OrderType == OutOrderTypeEnum.ReCheck.ObjToInt()) //éæ£åºåº
			{

			}
			else
			{
			var feedmodel = new FeedbackOutboundRequestModel
			{
			reqCode = Guid.NewGuid().ToString(),
			reqTime = DateTime.Now.ToString(),
			business_type = outboundOrder.BusinessType,
			factoryArea = outboundOrder.FactoryArea,
			operationType = 1,
			Operator = outboundOrder.Operator,
			orderNo = outboundOrder.UpperOrderNo,
			status = outboundOrder.OrderStatus,
			details = new List<FeedbackOutboundDetailsModel>()

			};
			var lists = _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>().Where(x => x.OrderNo == orderNo && x.Status == (int)OutLockStockStatusEnum.æ£éå®æ).ToList();

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

			var result = await _invokeMESService.FeedbackOutbound(feedmodel);
			if (result != null && result.code == 200)
			{
			await _outboundOrderDetailService.Db.Updateable<Dt_OutboundOrderDetail>().SetColumns(x => x.ReturnToMESStatus == 1) // å·²å®æ
			.Where(x => x.OrderId == outboundOrder.Id).ExecuteCommandAsync();
			await _outboundOrderService.Db.Updateable<Dt_OutboundOrder>() .SetColumns(x => x.ReturnToMESStatus == 1) // å·²å®æ
			.Where(x => x.OrderNo == orderNo) .ExecuteCommandAsync();
			}
			}

			}
			}
			catch (Exception ex)
			{
			_logger.LogError(" OutboundPickingService FeedbackOutbound : " + ex.Message);
			}

			}
			}

			public async Task<WebResponseContent> ConfirmPicking(string orderNo, string palletCode, string barcode)
			{
			try
			{
			_unitOfWorkManage.BeginTran();

			// 1. éªè¯è¾å¥åæ°
			if (string.IsNullOrEmpty(orderNo) \|\| string.IsNullOrEmpty(palletCode) \|\| string.IsNullOrEmpty(barcode))
			{
			throw new Exception("è®¢åå·ãæçç åæ¡ç ä¸è½ä¸ºç©º");
			}

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

			if (lockInfo == null)
			{
			lockInfo = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
			.Where(it => it.CurrentBarcode == barcode &&
			it.Status == (int)OutLockStockStatusEnum.åºåºä¸ &&
			it.AssignQuantity > it.PickedQty)
			.FirstAsync();

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

			if (completedLockInfo != null)
			throw new Exception($"æ¡ç {barcode}å·²ç»å®æåæ£ï¼ä¸è½éå¤åæ£");
			else
			throw new Exception($"æ¡ç {barcode}ä¸å±äºæç{palletCode}æä¸åå¨å¾åæ£è®°å½");
			}
			}

			if (lockInfo.PalletCode != palletCode)
			throw new Exception($"æ¡ç {barcode}ä¸å±äºæç{palletCode}");

			// æ£æ¥æ£éåå²ï¼é²æ¢éå¤åæ£
			var existingPicking = await Db.Queryable<Dt_PickingRecord>()
			.Where(x => x.Barcode == barcode &&
			x.OrderNo == orderNo &&
			x.PalletCode == palletCode &&
			x.OutStockLockId == lockInfo.Id)
			.FirstAsync();

			if (existingPicking != null)
			{
			throw new Exception($"æ¡ç {barcode}å·²ç»åæ£è¿ï¼ä¸è½éå¤åæ£");
			}

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

			if (orderDetail == null)
			throw new Exception($"æªæ¾å°è®¢åæç»ï¼ID: {lockInfo.OrderDetailId}");

			// å³é®ä¿®å¤ï¼æ£æ¥ç´¯è®¡æ£éæ°éæ¯å¦ä¼è¶è¿è®¢åæ°é
			decimal actualQty = lockInfo.AssignQuantity - lockInfo.PickedQty;
			decimal remainingOrderQty = orderDetail.NeedOutQuantity - orderDetail.OverOutQuantity;

			if (actualQty > remainingOrderQty)
			{
			// å¦æåéæ°éå¤§äºå©ä½è®¢åæ°éï¼è°æ´å®éæ£éæ°é
			actualQty = remainingOrderQty;

			if (actualQty <= 0)
			{
			throw new Exception($"è®¢å{orderNo}çéæ±æ°éå·²æ»¡è¶³ï¼æ æ³ç»§ç»åæ£");
			}

			_logger.LogWarning($"è°æ´åæ£æ°éï¼ååé{lockInfo.AssignQuantity - lockInfo.PickedQty}ï¼è°æ´ä¸º{actualQty}ï¼è®¢åéæ±{orderDetail.NeedOutQuantity}ï¼å·²åºåº{orderDetail.OverOutQuantity}");
			}

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

			if (stockDetail == null)
			return WebResponseContent.Instance.Error("æ æçæ¡ç æç©æç¼ç ");

			decimal stockQuantity = stockDetail.StockQuantity;

			List<SplitResult> splitResults = new List<SplitResult>();
			Dt_OutStockLockInfo finalLockInfo = lockInfo;
			var finalBarcode = barcode;
			var finalStockId = stockDetail.Id;
			decimal actualPickedQty = actualQty;

			if (actualQty < stockQuantity)
			{
			// æåµ1: åéæ°éå°äºåºåæ°éï¼éè¦èªå¨æå
			decimal remainingStockQty = stockQuantity - actualQty;

			// æ´æ°åæ¡ç åºåä¸ºå©ä½æ°é
			stockDetail.StockQuantity = remainingStockQty;
			stockDetail.OutboundQuantity = remainingStockQty;
			await _stockInfoDetailService.Db.Updateable(stockDetail).ExecuteCommandAsync();

			// çææ°æ¡ç ç¨äºè®°å½æ£éæ°é
			var seq = await _dailySequenceService.GetNextSequenceAsync();
			string newBarcode = "WSLOT" + DateTime.Now.ToString("yyyyMMdd") + seq.ToString()?.PadLeft(5, '0');

			// ä¸ºæ°æ¡ç åå»ºåºåºéå®ä¿¡æ¯
			var newLockInfo = new Dt_OutStockLockInfo
			{
			OrderNo = lockInfo.OrderNo,
			OrderDetailId = lockInfo.OrderDetailId,
			BatchNo = lockInfo.BatchNo,
			MaterielCode = lockInfo.MaterielCode,
			MaterielName = lockInfo.MaterielName,
			StockId = lockInfo.StockId,
			OrderQuantity = actualQty,
			OriginalQuantity = actualQty,
			AssignQuantity = actualQty,
			PickedQty = actualQty,
			LocationCode = lockInfo.LocationCode,
			PalletCode = lockInfo.PalletCode,
			TaskNum = lockInfo.TaskNum,
			Status = (int)OutLockStockStatusEnum.æ£éå®æ,
			Unit = lockInfo.Unit,
			SupplyCode = lockInfo.SupplyCode,
			OrderType = lockInfo.OrderType,
			CurrentBarcode = newBarcode,
			OriginalLockQuantity = actualQty,
			IsSplitted = 1,
			ParentLockId = lockInfo.Id
			};

			var newLockId = await _outStockLockInfoService.Db.Insertable(newLockInfo).ExecuteReturnIdentityAsync();
			newLockInfo.Id = newLockId;

			// è®°å½æååå²
			var splitHistory = new Dt_SplitPackageRecord
			{
			FactoryArea = lockInfo.FactoryArea,
			TaskNum = lockInfo.TaskNum,
			OutStockLockInfoId = lockInfo.Id,
			StockId = stockDetail.StockId,
			Operator = App.User.UserName,
			IsReverted = false,
			OriginalBarcode = barcode,
			NewBarcode = newBarcode,
			SplitQty = actualQty,
			RemainQuantity = remainingStockQty,
			MaterielCode = lockInfo.MaterielCode,
			SplitTime = DateTime.Now,
			OrderNo = lockInfo.OrderNo,
			PalletCode = lockInfo.PalletCode,
			Status = (int)SplitPackageStatusEnum.å·²æ£é
			};
			await _splitPackageService.Db.Insertable(splitHistory).ExecuteCommandAsync();

			// æ´æ°åéå®ä¿¡æ¯ä¸ºå©ä½åºåæ°é
			lockInfo.AssignQuantity = remainingStockQty;
			lockInfo.PickedQty = 0;
			await _outStockLockInfoService.Db.Updateable(lockInfo).ExecuteCommandAsync();

			splitResults.Add(new SplitResult
			{
			materialCode = lockInfo.MaterielCode,
			supplierCode = lockInfo.SupplyCode,
			quantityTotal = actualQty.ToString("F2"),
			batchNumber = newBarcode,
			batch = lockInfo.BatchNo,
			factory = lockInfo.FactoryArea,
			date = DateTime.Now.ToString("yyyy-MM-dd"),
			});

			splitResults.Add(new SplitResult
			{
			materialCode = lockInfo.MaterielCode,
			supplierCode = lockInfo.SupplyCode,
			quantityTotal = remainingStockQty.ToString("F2"),
			batchNumber = barcode,
			batch = lockInfo.BatchNo,
			factory = lockInfo.FactoryArea,
			date = DateTime.Now.ToString("yyyy-MM-dd"),
			});

			finalLockInfo = newLockInfo;
			finalBarcode = newBarcode;
			}
			else if (actualQty == stockQuantity)
			{
			// æåµ2: åéæ°éçäºåºåæ°éï¼æ´ååºåº
			stockDetail.StockQuantity = 0;
			stockDetail.OutboundQuantity = 0;
			await _stockInfoDetailService.Db.Updateable(stockDetail).ExecuteCommandAsync();

			lockInfo.PickedQty += actualQty;
			lockInfo.Status = (int)OutLockStockStatusEnum.æ£éå®æ;
			await _outStockLockInfoService.Db.Updateable(lockInfo).ExecuteCommandAsync();
			}
			else
			{
			// æåµ3: åéæ°éå¤§äºåºåæ°éï¼åºåæ´ååºåº
			decimal stockOutQty = stockQuantity;
			stockDetail.StockQuantity = 0;
			stockDetail.OutboundQuantity = 0;
			await _stockInfoDetailService.Db.Updateable(stockDetail).ExecuteCommandAsync();

			decimal remainingAssignQty = actualQty - stockQuantity;
			lockInfo.PickedQty += stockOutQty;
			lockInfo.AssignQuantity = remainingAssignQty;
			await _outStockLockInfoService.Db.Updateable(lockInfo).ExecuteCommandAsync();

			var relatedSplitRecords = await _splitPackageService.Db.Queryable<Dt_SplitPackageRecord>()
			.Where(it => it.OriginalBarcode == barcode \|\| it.NewBarcode == barcode)
			.Where(it => !it.IsReverted)
			.ToListAsync();

			foreach (var record in relatedSplitRecords)
			{
			record.Status = (int)SplitPackageStatusEnum.å·²æ£é;
			await _splitPackageService.Db.Updateable(record).ExecuteCommandAsync();
			}

			actualPickedQty = stockOutQty;
			}

			// å³é®ä¿®å¤ï¼åæ¬¡æ£æ¥è®¢åæ°ééå¶
			decimal newOverOutQuantity = orderDetail.OverOutQuantity + actualPickedQty;
			decimal newPickedQty = orderDetail.PickedQty + actualPickedQty;

			if (newOverOutQuantity > orderDetail.NeedOutQuantity)
			{
			throw new Exception($"åæ£åå°å¯¼è´å·²åºåºæ°é({newOverOutQuantity})è¶è¿è®¢åéæ±æ°é({orderDetail.NeedOutQuantity})");
			}

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

			await CheckAndUpdateOrderStatus(orderNo);

			// æ¥è¯¢ä»»å¡è¡¨
			var task = _taskRepository.QueryData(x => x.OrderNo == orderNo && x.PalletCode == palletCode).FirstOrDefault();

			if (finalLockInfo.Id <= 0)
			{
			throw new Exception($"éå®ä¿¡æ¯IDæ æ: {finalLockInfo.Id}ï¼æ æ³è®°å½æ£éåå²");
			}

			// è®°å½æ£éåå²
			var pickingHistory = new Dt_PickingRecord
			{
			FactoryArea = finalLockInfo.FactoryArea,
			TaskNo = task?.TaskNum ?? 0,
			LocationCode = task?.SourceAddress ?? "",
			StockId = finalStockId,
			OrderNo = orderNo,
			OrderDetailId = finalLockInfo.OrderDetailId,
			PalletCode = palletCode,
			Barcode = finalBarcode,
			MaterielCode = finalLockInfo.MaterielCode,
			PickQuantity = actualPickedQty,
			PickTime = DateTime.Now,
			Operator = App.User.UserName,
			OutStockLockId = finalLockInfo.Id
			};
			await Db.Insertable(pickingHistory).ExecuteCommandAsync();

			_unitOfWorkManage.CommitTran();

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

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

			}
			catch (Exception ex)
			{
			_unitOfWorkManage.RollbackTran();
			_logger.LogError($"ConfirmPickingå¤±è´¥ - OrderNo: {orderNo}, PalletCode: {palletCode}, Barcode: {barcode}, Error: {ex.Message}");
			return WebResponseContent.Instance.Error($"æ£éç¡®è®¤å¤±è´¥ï¼{ex.Message}");
			}
			}

			public async Task<WebResponseContent> CancelPicking(string orderNo, string palletCode, string barcode)
			{
			try
			{
			_unitOfWorkManage.BeginTran();

			// æ¥æ¾æ£éè®°å½
			var pickingRecord = await Db.Queryable<Dt_PickingRecord>()
			.Where(it => it.OrderNo == orderNo &&
			it.PalletCode == palletCode &&
			it.Barcode == barcode)
			.OrderByDescending(it => it.PickTime)
			.FirstAsync();

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

			// æ¥æ¾åºåºéå®ä¿¡æ¯
			var lockInfo = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
			.Where(it => it.Id == pickingRecord.OutStockLockId)
			.FirstAsync();

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

			// æ£æ¥æ¯å¦å¯ä»¥åæ¶
			if (lockInfo.Status != (int)OutLockStockStatusEnum.æ£éå®æ)
			return WebResponseContent.Instance.Error("å½åç¶æä¸åè®¸åæ¶åæ£");

			decimal cancelQty = pickingRecord.PickQuantity;

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

			if (orderDetail == null)
			throw new Exception($"æªæ¾å°è®¢åæç»ï¼ID: {pickingRecord.OrderDetailId}");

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

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

			// å¤çåæ¶é»è¾
			if (lockInfo.IsSplitted == 1 && lockInfo.ParentLockId.HasValue)
			{
			await HandleSplitBarcodeCancel(lockInfo, pickingRecord, cancelQty);
			}
			else
			{
			await HandleNormalBarcodeCancel(lockInfo, pickingRecord, cancelQty);
			}

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

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

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

			_unitOfWorkManage.CommitTran();
			return WebResponseContent.Instance.OK($"åæ¶åæ£æåï¼æ¢å¤æ°éï¼{cancelQty}");
			}
			catch (Exception ex)
			{
			_unitOfWorkManage.RollbackTran();
			_logger.LogError($"CancelPickingå¤±è´¥ - OrderNo: {orderNo}, PalletCode: {palletCode}, Barcode: {barcode}, Error: {ex.Message}");
			return WebResponseContent.Instance.Error($"åæ¶åæ£å¤±è´¥ï¼{ex.Message}");
			}
			}

			private async Task HandleSplitBarcodeCancel(Dt_OutStockLockInfo lockInfo, Dt_PickingRecord pickingRecord, decimal cancelQty)
			{
			// æ¥æ¾ç¶éå®ä¿¡æ¯
			var parentLockInfo = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
			.Where(x => x.Id == lockInfo.ParentLockId.Value)
			.FirstAsync();

			if (parentLockInfo == null)
			{
			throw new Exception("æªæ¾å°ç¶éå®ä¿¡æ¯ï¼æ æ³åæ¶æååæ£");
			}

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

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

			if (stockDetail != null)
			{
			stockDetail.StockQuantity += cancelQty;
			stockDetail.OutboundQuantity += cancelQty;
			await _stockInfoDetailService.Db.Updateable(stockDetail).ExecuteCommandAsync();
			}

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

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

			private async Task HandleNormalBarcodeCancel(Dt_OutStockLockInfo lockInfo, Dt_PickingRecord pickingRecord, decimal cancelQty)
			{
			// æ¢å¤éå®ä¿¡æ¯
			lockInfo.PickedQty -= cancelQty;
			if (lockInfo.PickedQty < 0) lockInfo.PickedQty = 0;

			lockInfo.Status = (int)OutLockStockStatusEnum.åºåºä¸;
			await _outStockLockInfoService.Db.Updateable(lockInfo).ExecuteCommandAsync();

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

			if (stockDetail != null)
			{
			stockDetail.StockQuantity += cancelQty;
			stockDetail.OutboundQuantity += cancelQty;
			await _stockInfoDetailService.Db.Updateable(stockDetail).ExecuteCommandAsync();
			}
			}

			public async Task<WebResponseContent> ReturnRemaining(string orderNo, string palletCode, string reason)
			{
			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 returnAnalysis = await AnalyzeReturnItems(orderNo, palletCode, stockInfo.Id);

			if (!returnAnalysis.HasItemsToReturn)
			{
			return await HandleNoReturnItems(orderNo, palletCode);
			}

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

			//åå»ºååºä»»å¡å¹¶å¤çESS
			await CreateReturnTaskAndHandleESS(orderNo, palletCode, task, returnAnalysis);

			_unitOfWorkManage.CommitTran();

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

			return WebResponseContent.Instance.OK($"ååºæä½æåï¼å±ååºæ°éï¼{returnAnalysis.TotalReturnQty}");

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

			#region è®¢åç¶æ

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

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

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

			if (outboundOrder == null) return;

			// åªæå½ç¶æç¡®å®åçååæ¶ææ´æ°
			int newStatus = allCompleted ? (int)OutOrderStatusEnum.åºåºå®æ : (int)OutOrderStatusEnum.åºåºä¸;

			if (outboundOrder.OrderStatus != newStatus)
			{
			await _outboundOrderService.Db.Updateable<Dt_OutboundOrder>()
			.SetColumns(x => x.OrderStatus == newStatus)
			.Where(x => x.OrderNo == orderNo)
			.ExecuteCommandAsync();

			_logger.LogInformation($"ååºæä½æ´æ°è®¢åç¶æ - OrderNo: {orderNo}, æ°ç¶æ: {newStatus}");
			}
			}
			catch (Exception ex)
			{
			_logger.LogError($"UpdateOrderStatusForReturnå¤±è´¥ - OrderNo: {orderNo}, Error: {ex.Message}");

			}
			}

			#endregion

			#region Private Methods

			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<ReturnAnalysisResult> AnalyzeReturnItems(string orderNo, string palletCode, int stockId)
			{
			var result = new ReturnAnalysisResult();

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

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

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

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

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

			return result;
			}

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

			foreach (var splitRecord in splitRecords)
			{
			// æ£æ¥åæ¡ç
			if (!processedBarcodes.Contains(splitRecord.OriginalBarcode))
			{
			var originalStock = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
			.Where(it => it.Barcode == splitRecord.OriginalBarcode && it.StockId == stockId)
			.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)
			.FirstAsync();

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

			return totalQty;
			}

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

			if (allPicked)
			{
			return WebResponseContent.Instance.OK("ææè´§ç©å·²æ£éå®æï¼æçä¸ºç©º");
			}
			else
			{
			return WebResponseContent.Instance.Error("æ²¡æéè¦ååºçå©ä½è´§ç©");
			}
			}

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

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

			// æåµ2ï¼å¤çæçä¸å¶ä»åºåè´§ç©
			if (analysis.HasPalletStockGoods)
			{
			await HandlePalletStockGoodsReturn(analysis.PalletStockGoods);
			}

			// æåµ3ï¼å¤çæåè®°å½
			if (analysis.HasSplitRecords)
			{
			await HandleSplitRecordsReturn(analysis.SplitRecords, orderNo, palletCode);
			}

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

			private async Task HandleRemainingLocksReturn(List<Dt_OutStockLockInfo> remainingLocks, int stockId)
			{
			var lockIds = remainingLocks.Select(x => x.Id).ToList();

			// æ´æ°åºåºéå®è®°å½ç¶æä¸ºååºä¸
			await _outStockLockInfoService.Db.Updateable<Dt_OutStockLockInfo>()
			.SetColumns(it => new Dt_OutStockLockInfo
			{
			Status = (int)OutLockStockStatusEnum.ååºä¸
			})
			.Where(it => lockIds.Contains(it.Id))
			.ExecuteCommandAsync();

			// å¤çåºåè®°å½
			foreach (var lockInfo in remainingLocks)
			{
			decimal returnQty = lockInfo.AssignQuantity - lockInfo.PickedQty;

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

			if (stockDetail != null)
			{
			// æ¢å¤åºåç¶æ
			stockDetail.OutboundQuantity = Math.Max(0, stockDetail.OutboundQuantity - returnQty);
			stockDetail.Status = StockStatusEmun.å¥åºå®æ.ObjToInt();
			await _stockInfoDetailService.Db.Updateable(stockDetail).ExecuteCommandAsync();
			}
			else
			{
			// åå»ºæ°çåºåè®°å½ï¼æåäº§ççæ°æ¡ç ï¼
			var newStockDetail = new Dt_StockInfoDetail
			{
			StockId = lockInfo.StockId,
			MaterielCode = lockInfo.MaterielCode,
			MaterielName = lockInfo.MaterielName,
			OrderNo = lockInfo.OrderNo,
			BatchNo = lockInfo.BatchNo,
			StockQuantity = returnQty,
			OutboundQuantity = 0,
			Barcode = lockInfo.CurrentBarcode,
			InboundOrderRowNo = "",
			Status = StockStatusEmun.å¥åºå®æ.ObjToInt(),
			SupplyCode = lockInfo.SupplyCode,
			WarehouseCode = lockInfo.WarehouseCode,
			Unit = lockInfo.Unit
			};
			await _stockInfoDetailService.Db.Insertable(newStockDetail).ExecuteCommandAsync();
			}
			}
			}

			private async Task UpdateOrderDetailsOnReturn(List<Dt_OutStockLockInfo> remainingLocks)
			{
			// æè®¢åæç»åç»
			var orderDetailGroups = remainingLocks.GroupBy(x => x.OrderDetailId);

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

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

			if (orderDetail != null)
			{
			// è°æ´å·²æ£éæ°éåå·²åºåºæ°é
			decimal newPickedQty = Math.Max(0, orderDetail.PickedQty - totalReturnQty);
			decimal newOverOutQuantity = Math.Max(0, orderDetail.OverOutQuantity - totalReturnQty);

			await _outboundOrderDetailService.Db.Updateable<Dt_OutboundOrderDetail>()
			.SetColumns(it => new Dt_OutboundOrderDetail
			{
			PickedQty = newPickedQty,
			OverOutQuantity = newOverOutQuantity
			})
			.Where(it => it.Id == orderDetailId)
			.ExecuteCommandAsync();
			}
			}
			}

			private async Task HandlePalletStockGoodsReturn(List<Dt_StockInfoDetail> palletStockGoods)
			{
			foreach (var stockGood in palletStockGoods)
			{
			// æ¢å¤åºåç¶æ
			stockGood.OutboundQuantity = 0;
			stockGood.Status = StockStatusEmun.å¥åºå®æ.ObjToInt();
			await _stockInfoDetailService.Db.Updateable(stockGood).ExecuteCommandAsync();
			}
			}

			private async Task HandleSplitRecordsReturn(List<Dt_SplitPackageRecord> splitRecords, string orderNo, string palletCode)
			{
			// æ´æ°æåè®°å½ç¶æ
			await _splitPackageService.Db.Updateable<Dt_SplitPackageRecord>()
			.SetColumns(x => new Dt_SplitPackageRecord
			{
			Status = (int)SplitPackageStatusEnum.å·²ååº
			})
			.Where(x => x.OrderNo == orderNo && x.PalletCode == palletCode && !x.IsReverted)
			.ExecuteCommandAsync();
			}

			private async Task UpdateStockInfoStatus(Dt_StockInfo stockInfo)
			{
			// æ´æ°åºåä¸»è¡¨ç¶æ
			stockInfo.StockStatus = StockStatusEmun.å¥åºå®æ.ObjToInt();
			await _stockInfoService.Db.Updateable(stockInfo).ExecuteCommandAsync();
			}

			private async Task CreateReturnTaskAndHandleESS(string orderNo, string palletCode, Dt_Task originalTask, ReturnAnalysisResult analysis)
			{
			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,
			Roadway = newLocation.RoadwayNo,
			SourceAddress = stations[originalTask.TargetAddress],
			TargetAddress = newLocation.LocationCode,
			TaskStatus = TaskStatusEnum.New.ObjToInt(),
			TaskType = TaskTypeEnum.InPick.ObjToInt(),
			PalletType = originalTask.PalletType,
			WarehouseId = originalTask.WarehouseId,

			};

			// ä¿åååºä»»å¡
			await _taskRepository.Db.Insertable(returnTask).ExecuteCommandAsync();

			// å é¤åå§åºåºä»»å¡
			_taskRepository.Db.Deleteable(originalTask);

			// ç» ESS åéæµå¨ä¿¡å·ååå»ºä»»å¡
			await SendESSCommands(palletCode, originalTask, returnTask);
			}
			private async Task SendESSCommands(string palletCode, Dt_Task originalTask, Dt_Task returnTask)
			{
			try
			{
			// 1. åéæµå¨ä¿¡å·
			var moveResult = await _eSSApiService.MoveContainerAsync(new WIDESEA_DTO.Basic.MoveContainerRequest
			{
			slotCode = movestations[originalTask.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(originalTask.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



			/// <summary>
			/// ååºæä½
			/// </summary>

			//public async Task<WebResponseContent> ReturnRemaining(string orderNo, string palletCode, string reason)
			//{
			// try
			// {
			// _unitOfWorkManage.BeginTran();

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

			// var stockinfo = _stockInfoService.Db.Queryable<Dt_StockInfo>().First(x => x.PalletCode == palletCode);

			// var tasks = new List<Dt_Task>();

			// // æ¥è¯¢ä»»å¡è¡¨
			// var task = remainingLocks.Any()
			// ? _taskRepository.QueryData(x => x.TaskNum == remainingLocks.First().TaskNum).FirstOrDefault()
			// : _taskRepository.QueryData(x => x.PalletCode == palletCode).FirstOrDefault();

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

			// // æ£æ¥æçä¸æ¯å¦æå¶ä»éåºåºè´§ç©ï¼åºåè´§ç©ï¼
			// var palletStockGoods = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
			// .Where(it => it.StockId == stockinfo.Id &&
			// (it.Status == StockStatusEmun.å¥åºç¡®è®¤.ObjToInt() \|\|
			// it.Status == StockStatusEmun.å¥åºå®æ.ObjToInt() \|\|
			// it.Status == StockStatusEmun.åºåºéå®.ObjToInt()))
			// .Where(it => it.OutboundQuantity == 0 \|\| it.OutboundQuantity < it.StockQuantity) // æªå®å¨åºåºç
			// .ToListAsync();

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

			// // è®¡ç®éè¦ååºçæåæ¡ç
			// var splitBarcodesToReturn = new List<string>();
			// foreach (var splitRecord in splitRecords)
			// {
			// // æ£æ¥åæ¡ç æ¯å¦è¿æåºåéè¦ååº
			// var originalStock = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
			// .Where(it => it.Barcode == splitRecord.OriginalBarcode && it.StockId == stockinfo.Id)
			// .FirstAsync();

			// if (originalStock != null && originalStock.StockQuantity > 0)
			// {
			// splitBarcodesToReturn.Add(splitRecord.OriginalBarcode);
			// }

			// // æ£æ¥æ°æ¡ç æ¯å¦è¿æåºåéè¦ååº
			// var newStock = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
			// .Where(it => it.Barcode == splitRecord.NewBarcode && it.StockId == stockinfo.Id)
			// .FirstAsync();

			// if (newStock != null && newStock.StockQuantity > 0)
			// {
			// splitBarcodesToReturn.Add(splitRecord.NewBarcode);
			// }
			// }

			// // å¦ææ²¡æéè¦ååºçè´§ç©ï¼æ¢æ æªåæ£åºåºè´§ç©ï¼ä¹æ å¶ä»åºåè´§ç©ï¼ä¹æ æåå©ä½è´§ç©ï¼
			// if (!remainingLocks.Any() && !palletStockGoods.Any() && !splitBarcodesToReturn.Any())
			// {
			// // æ£æ¥æ¯å¦ææè´§ç©é½å·²æ£éå®æ
			// var allPicked = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
			// .Where(it => it.OrderNo == orderNo && it.PalletCode == palletCode)
			// .AnyAsync(it => it.Status == (int)OutLockStockStatusEnum.æ£éå®æ);

			// if (allPicked)
			// {
			// return WebResponseContent.Instance.OK("ææè´§ç©å·²æ£éå®æï¼æçä¸ºç©º");
			// }
			// else
			// {
			// return WebResponseContent.Instance.Error("æ²¡æéè¦ååºçå©ä½è´§ç©");
			// }
			// }

			// var firstlocation = _locationInfoService.Db.Queryable<Dt_LocationInfo>().First(x => x.LocationCode == task.SourceAddress);
			// decimal totalReturnQty = 0;

			// // æåµ1ï¼å¤çæªåæ£çåºåºéå®è®°å½
			// if (remainingLocks.Any(x => x.PalletCode == palletCode))
			// {
			// var palletLocks = remainingLocks.Where(x => x.PalletCode == palletCode).ToList();
			// totalReturnQty = palletLocks.Sum(x => x.AssignQuantity - x.PickedQty);

			// if (totalReturnQty > 0)
			// {
			// // åéæ°è´§ä½
			// var newLocation = _locationInfoService.AssignLocation(firstlocation.LocationType);

			// // æ´æ°åºåºéå®è®°å½ç¶æ
			// var lockIds = palletLocks.Select(x => x.Id).ToList();
			// await _outStockLockInfoService.Db.Updateable<Dt_OutStockLockInfo>()
			// .SetColumns(it => new Dt_OutStockLockInfo { Status = (int)OutLockStockStatusEnum.ååºä¸ })
			// .Where(it => lockIds.Contains(it.Id))
			// .ExecuteCommandAsync();



			// // å¤çåºåè®°å½
			// foreach (var lockInfo in palletLocks)
			// {
			// decimal returnQty = lockInfo.AssignQuantity - lockInfo.PickedQty;

			// // æ£æ¥åºåè®°å½æ¯å¦åå¨
			// var existingStock = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
			// .Where(it => it.Barcode == lockInfo.CurrentBarcode && it.StockId == lockInfo.StockId)
			// .FirstAsync();

			// if (existingStock != null)
			// {
			// // åºåè®°å½åå¨ï¼æ¢å¤éå®æ°é
			// existingStock.OutboundQuantity = 0;

			// await _stockInfoDetailService.Db.Updateable(existingStock).ExecuteCommandAsync();
			// }
			// else
			// {
			// // åºåè®°å½ä¸åå¨ï¼å¯è½æ¯æåäº§ççæ°æ¡ç ï¼ï¼åå»ºæ°çåºåè®°å½
			// var newStockDetail = new Dt_StockInfoDetail
			// {
			// StockId = lockInfo.StockId,
			// MaterielCode = lockInfo.MaterielCode,
			// MaterielName = lockInfo.MaterielName,
			// OrderNo = lockInfo.OrderNo,
			// BatchNo = lockInfo.BatchNo,
			// StockQuantity = returnQty,
			// OutboundQuantity = 0,
			// Barcode = lockInfo.CurrentBarcode,
			// InboundOrderRowNo = "",
			// Status = StockStatusEmun.å¥åºå®æ.ObjToInt(),
			// SupplyCode = lockInfo.SupplyCode,
			// WarehouseCode = lockInfo.WarehouseCode,
			// Unit = lockInfo.Unit
			// };
			// await _stockInfoDetailService.Db.Insertable(newStockDetail).ExecuteCommandAsync();
			// }
			// }

			// // åå»ºååºä»»å¡
			// CreateReturnTask(tasks, task, palletCode, newLocation);
			// }
			// }

			// // æåµ2ï¼å¤çæåå©ä½çåºåè´§ç©
			// if (splitBarcodesToReturn.Any())
			// {
			// decimal splitReturnQty = 0;

			// foreach (var barcode in splitBarcodesToReturn)
			// {
			// var stockDetail = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
			// .Where(it => it.Barcode == barcode && it.StockId == stockinfo.Id)
			// .FirstAsync();

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

			// // æ¢å¤åºåç¶æä¸ºå¥åºå®æ
			// stockDetail.OutboundQuantity = 0;

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

			// totalReturnQty += splitReturnQty;

			// // å¦ææ²¡æåå»ºä»»å¡ï¼åå»ºååºä»»å¡
			// if (!tasks.Any())
			// {
			// var newLocation = _locationInfoService.AssignLocation(firstlocation.LocationType);
			// CreateReturnTask(tasks, task, palletCode, newLocation);
			// }
			// }

			// // æåµ3ï¼åºåºè´§ç©å·²åæ£å®ï¼ä½æçä¸è¿æå¶ä»åºåè´§ç©éè¦ååº
			// if (palletStockGoods.Any() && !remainingLocks.Any(x => x.PalletCode == palletCode))
			// {
			// decimal otherReturnQty = palletStockGoods.Sum(x => x.StockQuantity - x.OutboundQuantity);
			// totalReturnQty += otherReturnQty;
			// // æ´æ°è¿äºåºåè´§ç©çç¶æ
			// foreach (var stockGood in palletStockGoods)
			// {
			// stockGood.OutboundQuantity = 0;

			// await _stockInfoDetailService.Db.Updateable(stockGood).ExecuteCommandAsync();
			// }
			// // å¦ææ²¡æåå»ºä»»å¡ï¼åå»ºååºä»»å¡
			// if (!tasks.Any())
			// {
			// var newLocation = _locationInfoService.AssignLocation(firstlocation.LocationType);
			// CreateReturnTask(tasks, task, palletCode, newLocation);
			// }


			// }

			// var allSplitRecords = await _splitPackageService.Db.Queryable<Dt_SplitPackageRecord>()
			// .Where(it => it.OrderNo == orderNo && it.PalletCode == palletCode && !it.IsReverted)
			// .ToListAsync();

			// foreach (var record in allSplitRecords)
			// {
			// record.Status = (int)SplitPackageStatusEnum.å·²ååº;
			// await _splitPackageService.Db.Updateable(record).ExecuteCommandAsync();
			// }
			// // ä¿åä»»å¡ ç»ESSä¸åä»»å¡
			// if (tasks.Any())
			// {
			// try
			// {
			// await _taskRepository.Db.Insertable(tasks).ExecuteCommandAsync();
			// var targetAddress = task.TargetAddress;
			// _taskRepository.DeleteData(task);

			// // ç» ESS æµå¨ä¿¡å·ååå»ºä»»å¡
			// try
			// {
			// var result = await _eSSApiService.MoveContainerAsync(new WIDESEA_DTO.Basic.MoveContainerRequest
			// {
			// slotCode = movestations[targetAddress],
			// containerCode = palletCode
			// });

			// if (result)
			// {
			// TaskModel esstask = new TaskModel()
			// {
			// taskType = "putaway",
			// taskGroupCode = "",
			// groupPriority = 0,
			// tasks = new List<TasksType>
			// {
			// new()
			// {
			// taskCode = tasks.First().TaskNum.ToString(),
			// taskPriority = 0,
			// taskDescribe = new TaskDescribeType {
			// containerCode = palletCode,
			// containerType = "CT_KUBOT_STANDARD",
			// fromLocationCode = stations.GetValueOrDefault(targetAddress) ?? "",
			// toStationCode = "",
			// toLocationCode = tasks.First().TargetAddress,
			// deadline = 0, storageTag = ""
			// }
			// }
			// }
			// };

			// var resulttask = await _eSSApiService.CreateTaskAsync(esstask);
			// _logger.LogInformation("ReturnRemaining åå»ºä»»å¡è¿å: " + resulttask);
			// }
			// }
			// catch (Exception ex)
			// {
			// _logger.LogInformation("ReturnRemaining åå»ºä»»å¡è¿å catch err: " + ex.Message);
			// }

			// _unitOfWorkManage.CommitTran();
			// return WebResponseContent.Instance.OK($"ååºæä½æåï¼å±ååºæ°éï¼{totalReturnQty}");
			// }
			// catch (Exception ex)
			// {
			// _unitOfWorkManage.RollbackTran();
			// return WebResponseContent.Instance.Error($"åå»ºååºä»»å¡å¤±è´¥: {ex.Message}");
			// }
			// }

			// _unitOfWorkManage.RollbackTran();
			// return WebResponseContent.Instance.Error("æªåå»ºä»»ä½ååºä»»å¡");
			// }
			// catch (Exception ex)
			// {
			// _unitOfWorkManage.RollbackTran();
			// return WebResponseContent.Instance.Error($"ååºæä½å¤±è´¥: {ex.Message}");
			// }
			//}


			/// <summary>
			/// åå»ºååºä»»å¡
			/// </summary>
			private void CreateReturnTask(List<Dt_Task> tasks, Dt_Task originalTask, string palletCode, Dt_LocationInfo newLocation)
			{
			Dt_Task newTask = new()
			{
			CurrentAddress = stations[originalTask.TargetAddress],
			Grade = 0,
			PalletCode = palletCode,
			NextAddress = "",
			OrderNo = originalTask.OrderNo,
			Roadway = newLocation.RoadwayNo,
			SourceAddress = stations[originalTask.TargetAddress],
			TargetAddress = newLocation.LocationCode,
			TaskStatus = TaskStatusEnum.New.ObjToInt(),
			TaskType = TaskTypeEnum.InPick.ObjToInt(),
			PalletType = originalTask.PalletType,
			WarehouseId = originalTask.WarehouseId,

			};
			tasks.Add(newTask);
			}

			/// <summary>
			/// æ£æ¥æçæ¯å¦éè¦ååºçè¾å©æ¹æ³
			/// </summary>
			public async Task<bool> CheckPalletNeedReturn(string orderNo, string palletCode)
			{
			// 1. æ£æ¥æ¯å¦ææªåæ£çåºåºè®°å½
			var hasUnpickedLocks = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
			.Where(it => it.OrderNo == orderNo && it.PalletCode == palletCode && it.Status == 1)
			.AnyAsync();

			if (hasUnpickedLocks)
			return true;

			// 2. æ£æ¥åºåºæ¯å¦å·²å®æä½æçè¿æåºåè´§ç©
			var outboundFinished = !await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
			.Where(it => it.PalletCode == palletCode && it.Status == 1)
			.AnyAsync();

			var stockinfo = _stockInfoService.Db.Queryable<Dt_StockInfo>().First(x => x.PalletCode == palletCode);


			var hasRemainingGoods = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
			.Where(it => it.StockId == stockinfo.Id && it.Status == StockStatusEmun.å¥åºç¡®è®¤.ObjToInt())
			.Where(it => it.OutboundQuantity == 0 \|\| it.OutboundQuantity < it.StockQuantity)
			.AnyAsync();

			return outboundFinished && hasRemainingGoods;
			}


			/// <summary>
			/// è·åæåé¾ï¼ä»å½åæ¡ç è¿½æº¯å°åå§æ¡ç ï¼
			/// </summary>
			// å¨ GetSplitChain æ¹æ³ä¸æ·»å æ´ä¸¥æ ¼çéªè¯
			private async Task<List<SplitChainItem>> GetSplitChain(string currentBarcode)
			{
			var chain = new List<SplitChainItem>();
			var visited = new HashSet<string>();

			string current = currentBarcode;
			int maxDepth = 10; // é²æ¢æ éå¾ªç¯

			while (!string.IsNullOrEmpty(current) && maxDepth > 0)
			{
			maxDepth--;

			if (visited.Contains(current))
			{
			_logger.LogWarning($"æ£æµå°å¾ªç¯å¼ç¨å¨æåé¾ä¸: {current}");
			break;
			}

			visited.Add(current);

			var splitRecord = await _splitPackageService.Db.Queryable<Dt_SplitPackageRecord>()
			.Where(it => it.NewBarcode == current && !it.IsReverted)
			.FirstAsync();

			if (splitRecord == null)
			break;

			// éªè¯æåè®°å½çå®æ´æ§
			if (string.IsNullOrEmpty(splitRecord.OriginalBarcode))
			{
			_logger.LogError($"æåè®°å½ {splitRecord.Id} ç¼ºå°åå§æ¡ç ");
			break;
			}

			var item = new SplitChainItem
			{
			SplitRecord = splitRecord,
			OriginalBarcode = splitRecord.OriginalBarcode,
			NewBarcode = splitRecord.NewBarcode,
			SplitQuantity = splitRecord.SplitQty
			};

			chain.Add(item);

			current = splitRecord.OriginalBarcode;
			}

			if (maxDepth <= 0)
			{
			_logger.LogWarning($"æåé¾è¿½æº¯è¾¾å°æå¤§æ·±åº¦: {currentBarcode}");
			}

			chain.Reverse();
			return chain;
			}
			/// <summary>
			/// å¤çæåé¾çåæ¶åæ£
			/// </summary>
			private async Task HandleSplitChainCancel(string orderNo, string palletCode, string barcode,
			decimal cancelQty, Dt_OutStockLockInfo lockInfo, Dt_PickingRecord pickingRecord, List<SplitChainItem> splitChain)
			{
			if (!splitChain.Any())
			return;

			// æ¾å°åå§æ¡ç ï¼é¾çç¬¬ä¸ä¸ªï¼
			var originalSplitItem = splitChain.First();
			var originalBarcode = originalSplitItem.OriginalBarcode;

			// æ¥æ¾åå§æ¡ç çéå®ä¿¡æ¯ååºå
			var originalLockInfo = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
			.Where(it => it.CurrentBarcode == originalBarcode && it.Status == (int)OutLockStockStatusEnum.åºåºä¸)
			.FirstAsync();

			var originalStockDetail = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
			.Where(it => it.Barcode == originalBarcode && it.StockId == originalLockInfo.StockId)
			.FirstAsync();

			if (originalLockInfo == null \|\| originalStockDetail == null)
			throw new Exception("æªæ¾å°åå§æ¡ç çéå®ä¿¡æ¯æåºåä¿¡æ¯");

			// æ¢å¤åå§æ¡ç åºåï¼å°åæ¶çæ°éå åå»ï¼
			originalStockDetail.StockQuantity += cancelQty;
			originalStockDetail.OutboundQuantity += cancelQty;
			await _stockInfoDetailService.Db.Updateable(originalStockDetail).ExecuteCommandAsync();

			// æ¢å¤åå§æ¡ç éå®ä¿¡æ¯
			originalLockInfo.AssignQuantity += cancelQty;
			await _outStockLockInfoService.Db.Updateable(originalLockInfo).ExecuteCommandAsync();

			// å é¤æåé¾ä¸æææ°æ¡ç çéå®ä¿¡æ¯ååºåè®°å½
			var allNewBarcodes = splitChain.Select(x => x.NewBarcode).ToList();

			// å é¤éå®ä¿¡æ¯
			await _outStockLockInfoService.Db.Deleteable<Dt_OutStockLockInfo>()
			.Where(it => allNewBarcodes.Contains(it.CurrentBarcode))
			.ExecuteCommandAsync();

			// å é¤åºåè®°å½ï¼åªå é¤æåäº§ççæ°æ¡ç åºåï¼ä¿çåå§æ¡ç ï¼
			await _stockInfoDetailService.Db.Deleteable<Dt_StockInfoDetail>()
			.Where(it => allNewBarcodes.Contains(it.Barcode) && it.Barcode != originalBarcode)
			.ExecuteCommandAsync();

			// æ´æ°æåé¾ä¸æææåè®°å½ç¶æä¸ºå·²æå
			foreach (var chainItem in splitChain)
			{
			chainItem.SplitRecord.Status = (int)SplitPackageStatusEnum.å·²æå;
			await _splitPackageService.Db.Updateable(chainItem.SplitRecord).ExecuteCommandAsync();
			}

			// æ¢å¤è®¢åæç»æ£éæ°éï¼ä½¿ç¨åå§éå®ä¿¡æ¯çè®¢åæç»IDï¼
			await _outboundOrderDetailService.Db.Updateable<Dt_OutboundOrderDetail>()
			.SetColumns(it => it.PickedQty == it.PickedQty - cancelQty)
			.Where(it => it.Id == originalLockInfo.OrderDetailId)
			.ExecuteCommandAsync();

			// æ¢å¤è®¢åç¶æ
			await CheckAndRevertOrderStatus(orderNo);

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

			//// è®°å½åæ¶æä½åå²
			//await RecordCancelHistory(orderNo, palletCode, barcode, cancelQty, pickingRecord.Id,
			// lockInfo.MaterielCode, "åæ¶æåé¾åæ£");
			}

			/// <summary>
			/// å¤çæ®éæ¡ç çåæ¶åæ£
			/// </summary>
			private async Task HandleNormalBarcodeCancel(string orderNo, string palletCode, string barcode,
			decimal cancelQty, Dt_OutStockLockInfo lockInfo, Dt_PickingRecord pickingRecord)
			{
			// 1. æ¥æ¾åºåä¿¡æ¯
			var stockDetail = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
			.Where(it => it.Barcode == barcode && it.StockId == lockInfo.StockId)
			.FirstAsync();

			if (stockDetail == null)
			throw new Exception("æªæ¾å°å¯¹åºçåºåä¿¡æ¯");

			// 2. æ¢å¤åºåæ°é
			if (stockDetail.StockQuantity == 0)
			{
			// æ´ååºåºçæåµ
			stockDetail.StockQuantity = cancelQty;
			stockDetail.OutboundQuantity = cancelQty;
			}
			else
			{
			// é¨ååºåºçæåµ
			stockDetail.StockQuantity += cancelQty;
			stockDetail.OutboundQuantity += cancelQty;
			}
			await _stockInfoDetailService.Db.Updateable(stockDetail).ExecuteCommandAsync();

			// 3. æ¢å¤éå®ä¿¡æ¯ç¶æ
			lockInfo.AssignQuantity += cancelQty;
			lockInfo.PickedQty -= cancelQty;

			if (lockInfo.PickedQty == 0)
			{
			lockInfo.Status = (int)OutLockStockStatusEnum.åºåºä¸;
			}
			await _outStockLockInfoService.Db.Updateable(lockInfo).ExecuteCommandAsync();

			// 4. å¤çç¸å³çæåè®°å½ç¶ææ¢å¤
			var relatedSplitRecords = await _splitPackageService.Db.Queryable<Dt_SplitPackageRecord>()
			.Where(it => it.OriginalBarcode == barcode &&
			it.Status == (int)SplitPackageStatusEnum.å·²æ£é)
			.ToListAsync();

			foreach (var record in relatedSplitRecords)
			{
			record.Status = (int)SplitPackageStatusEnum.å·²æå;
			await _splitPackageService.Db.Updateable(record).ExecuteCommandAsync();
			}

			// 5. æ¢å¤è®¢åæç»çæ£éæ°é
			await _outboundOrderDetailService.Db.Updateable<Dt_OutboundOrderDetail>()
			.SetColumns(it => it.PickedQty == it.PickedQty - cancelQty)
			.Where(it => it.Id == lockInfo.OrderDetailId)
			.ExecuteCommandAsync();

			// 6. æ¢å¤è®¢åç¶æ
			await CheckAndRevertOrderStatus(orderNo);

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

			//// 8. è®°å½åæ¶æä½åå²
			//await RecordCancelHistory(orderNo, palletCode, barcode, cancelQty, pickingRecord.Id,
			// lockInfo.MaterielCode, "åæ¶åæ£");
			}

			/// <summary>
			/// æ£æ¥å¹¶æ¢å¤è®¢åç¶æ
			/// </summary>
			private async Task CheckAndRevertOrderStatus(string orderNo)
			{
			var order = await _outboundOrderService.Db.Queryable<Dt_OutboundOrder>()
			.Where(x => x.OrderNo == orderNo)
			.FirstAsync();

			if (order != null && order.OrderStatus == OutOrderStatusEnum.åºåºå®æ.ObjToInt())
			{
			await _outboundOrderService.Db.Updateable<Dt_OutboundOrder>()
			.SetColumns(x => x.OrderStatus == OutOrderStatusEnum.åºåºä¸.ObjToInt())
			.Where(x => x.OrderNo == orderNo)
			.ExecuteCommandAsync();
			}
			}




			#region æ¥è¯¢æ¹æ³
			// è·åæªæ£éåè¡¨
			public async Task<List<Dt_OutStockLockInfo>> GetUnpickedList(string orderNo, string palletCode)
			{
			@@ -1789,201 +161,2650 @@

			return summary;
			}

			#endregion

			#region æ ¸å¿ä¸å¡æµç¨
			/// <summary>
			/// è·åæ£éåå²
			/// æ£é
			/// </summary>
			public async Task<List<Dt_PickingRecord>> GetPickingHistory(int orderId)
			{
			// éè¿åºåºåIDæ¥è¯¢ç¸å³çæ£éåå²
			// æ³¨æï¼Dt_PickingRecord ä¸æ²¡æç´æ¥åå¨OrderIdï¼éè¦éè¿åºåºåæç»å³è
			var detailIds = await _outboundOrderDetailService.Db.Queryable<Dt_OutboundOrderDetail>()
			.Where(d => d.OrderId == orderId)
			.Select(d => d.Id)
			.ToListAsync();

			return await Db.Queryable<Dt_PickingRecord>()
			.Where(p => detailIds.Contains(p.OrderDetailId))
			.OrderByDescending(p => p.PickTime)
			.ToListAsync();
			}


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

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

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

			// è®¡ç®åç§æ°é
			var totalStockQuantity = stockInfo.Details.Sum(x => x.StockQuantity);
			var totalOutboundQuantity = stockInfo.Details.Sum(x => x.OutboundQuantity);
			var totalLockedQuantity = lockInfos.Where(x => x.Status == (int)OutLockStockStatusEnum.åºåºä¸)
			.Sum(x => x.AssignQuantity - x.PickedQty);
			var totalPickedQuantity = lockInfos.Sum(x => x.PickedQty);

			var result = new
			{
			PalletCode = palletCode,
			LocationCode = stockInfo.LocationCode,
			StockStatus = stockInfo.StockStatus,
			TotalStockQuantity = totalStockQuantity,
			TotalOutboundQuantity = totalOutboundQuantity,
			TotalLockedQuantity = totalLockedQuantity,
			TotalPickedQuantity = totalPickedQuantity,
			AvailableQuantity = totalStockQuantity - totalOutboundQuantity,
			LockInfos = lockInfos.Select(x => new
			{
			x.Id,
			x.MaterielCode,
			x.OrderDetailId,
			x.AssignQuantity,
			x.PickedQty,
			x.Status,
			x.CurrentBarcode,
			x.IsSplitted
			}).ToList(),
			StockDetails = stockInfo.Details.Select(x => new
			{
			x.Barcode,
			x.MaterielCode,
			StockQuantity = x.StockQuantity,
			OutboundQuantity = x.OutboundQuantity,
			AvailableQuantity = x.StockQuantity - x.OutboundQuantity
			}).ToList()
			};

			return WebResponseContent.Instance.OK(null, result);
			}

			/// <summary>
			/// ç´æ¥åºåº - æ´ä¸ªæçåºåºï¼æ¸ç©ºåºå
			/// </summary>
			public async Task<WebResponseContent> DirectOutbound(DirectOutboundRequest request)
			/// <param name="orderNo"></param>
			/// <param name="palletCode"></param>
			/// <param name="barcode"></param>
			/// <returns></returns>
			public async Task<WebResponseContent> ConfirmPicking(string orderNo, string palletCode, string barcode)
			{
			try
			{
			_unitOfWorkManage.BeginTran();

			var stockInfo = await _stockInfoService.Db.Queryable<Dt_StockInfo>()
			.Includes(x => x.Details)
			.Where(x => x.PalletCode == request.PalletCode).FirstAsync();
			var validationResult = await ValidatePickingRequest(orderNo, palletCode, barcode);
			if (!validationResult.IsValid)
			return WebResponseContent.Instance.Error(validationResult.ErrorMessage);

			if (stockInfo == null)
			return WebResponseContent.Instance.Error("æªæ¾å°æçåºåä¿¡æ¯");
			var (lockInfo, orderDetail, stockDetail) = validationResult.Data;

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

			var lockInfos = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
			.Where(x => x.OrderNo == request.OrderNo && x.PalletCode == request.PalletCode)
			.ToListAsync();
			var (actualQty, adjustedReason) = quantityResult.Data;


			foreach (var lockInfo in lockInfos)
			var overPickingValidation = await ValidateOverPicking(orderDetail.Id, actualQty);
			if (!overPickingValidation.IsValid)
			{
			if (lockInfo.Status == (int)OutLockStockStatusEnum.åºåºä¸)
			{
			lockInfo.PickedQty = lockInfo.AssignQuantity;
			}
			lockInfo.Status = (int)OutLockStockStatusEnum.å·²åºåº;
			await _outStockLockInfoService.Db.Updateable(lockInfo).ExecuteCommandAsync();

			var orderDetail = await _outboundOrderDetailService.Db.Queryable<Dt_OutboundOrderDetail>()
			.Where(x => x.Id == lockInfo.OrderDetailId)
			.FirstAsync();
			if (orderDetail != null)
			{
			orderDetail.OverOutQuantity += lockInfo.PickedQty;
			orderDetail.LockQuantity -= lockInfo.PickedQty;
			orderDetail.OrderDetailStatus = (int)OrderDetailStatusEnum.Over;
			orderDetail.LockQuantity = 0;
			await _outboundOrderDetailService.Db.Updateable(orderDetail).ExecuteCommandAsync();
			}
			}
			var groupDetails = lockInfos.GroupBy(x => x.OrderDetailId).Select(x => new
			{
			OrderDetailId = x.Key,
			TotalQuantity = x.Sum(o => o.PickedQty)
			}).ToList();
			foreach (var item in groupDetails)
			{
			var orderDetail = await _outboundOrderDetailService.Db.Queryable<Dt_OutboundOrderDetail>().Where(x => x.Id == item.OrderDetailId).FirstAsync();
			if (orderDetail != null)
			{
			orderDetail.OverOutQuantity = item.TotalQuantity;
			orderDetail.LockQuantity = 0;
			orderDetail.OrderDetailStatus = (int)OrderDetailStatusEnum.Over;
			await _outboundOrderDetailService.Db.Updateable(orderDetail).ExecuteCommandAsync();
			}
			return WebResponseContent.Instance.Error(overPickingValidation.ErrorMessage);
			}

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

			var lockInfoIds = lockInfos.Select(x => x.Id).ToList();
			var splitRecords = await _splitPackageService.Db.Queryable<Dt_SplitPackageRecord>()
			.Where(x => lockInfoIds.Contains(x.OutStockLockInfoId) &&
			x.Status == (int)SplitPackageStatusEnum.å·²æå)
			.ToListAsync();
			// ç»ä¸æ´æ°è®¢åæ°æ®ï¼ææåæ¯é½å¨è¿éæ´æ°ï¼
			await UpdateOrderRelatedData(orderDetail.Id, pickingResult.ActualPickedQty, orderNo);

			foreach (var record in splitRecords)
			{
			record.Status = (int)SplitPackageStatusEnum.å·²æ£é;
			await _splitPackageService.Db.Updateable(record).ExecuteCommandAsync();
			}


			var location = await _locationInfoService.Db.Queryable<Dt_LocationInfo>()
			.Where(x => x.LocationCode == stockInfo.LocationCode)
			.FirstAsync();
			if (location != null)
			{
			location.LocationStatus = (int)LocationStatusEnum.Free;
			await _locationInfoService.Db.Updateable(location).ExecuteCommandAsync();
			}

			foreach (var detail in stockInfo.Details)
			{
			await _stockInfoDetailService.Db.Deleteable(detail).ExecuteCommandAsync();
			}
			await _stockInfoService.Db.Deleteable(stockInfo).ExecuteCommandAsync();


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

			_unitOfWorkManage.CommitTran();
			return WebResponseContent.Instance.OK("ç´æ¥åºåºæå");

			return CreatePickingResponse(pickingResult, adjustedReason);
			}
			catch (Exception ex)
			{
			_unitOfWorkManage.RollbackTran();
			return WebResponseContent.Instance.Error($"ç´æ¥åºåºå¤±è´¥: {ex.Message}");
			_logger.LogError($"ConfirmPickingå¤±è´¥ - OrderNo: {orderNo}, PalletCode: {palletCode}, Barcode: {barcode}, Error: {ex.Message}");
			return WebResponseContent.Instance.Error($"æ£éç¡®è®¤å¤±è´¥ï¼{ex.Message}");
			}
			}

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

			// åç½®éªè¯
			var validationResult = await ValidateCancelRequest(orderNo, palletCode, barcode);
			if (!validationResult.IsValid)
			return WebResponseContent.Instance.Error(validationResult.ErrorMessage);

			var (pickingRecord, lockInfo, orderDetail) = validationResult.Data;

			//æ§è¡åæ¶é»è¾
			await ExecuteCancelLogic(lockInfo, pickingRecord, orderDetail, orderNo);

			_unitOfWorkManage.CommitTran();

			return WebResponseContent.Instance.OK($"åæ¶åæ£æå");
			}
			catch (Exception ex)
			{
			_unitOfWorkManage.RollbackTran();
			_logger.LogError($"CancelPickingå¤±è´¥ - OrderNo: {orderNo}, PalletCode: {palletCode}, Barcode: {barcode}, Error: {ex.Message}");
			return WebResponseContent.Instance.Error($"åæ¶åæ£å¤±è´¥ï¼{ex.Message}");
			}
			}
			/// <summary>
			/// ååº
			/// </summary>
			/// <param name="orderNo"></param>
			/// <param name="palletCode"></param>
			/// <param name="reason"></param>
			/// <returns></returns>
			public async Task<WebResponseContent> ReturnRemaining(string orderNo, string palletCode, string reason)
			{
			try
			{
			_unitOfWorkManage.BeginTran();


			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 returnAnalysis = await AnalyzeReturnItems(orderNo, palletCode, stockInfo.Id);
			//if (!returnAnalysis.HasItemsToReturn)
			// return await HandleNoReturnItems(orderNo, palletCode, task);

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

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

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

			await ReleaseAllLocksForReallocation(orderNo, palletCode, statusAnalysis);

			_unitOfWorkManage.CommitTran();


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

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

			return WebResponseContent.Instance.OK($"ååºæä½æå");
			//return WebResponseContent.Instance.OK($"ååºæä½æåï¼å±ååºæ°éï¼{statusAnalysis.TotalReturnQty}");
			}
			catch (Exception ex)
			{
			_unitOfWorkManage.RollbackTran();
			_logger.LogError($"ReturnRemainingå¤±è´¥ - OrderNo: {orderNo}, PalletCode: {palletCode}, Error: {ex.Message}");
			return WebResponseContent.Instance.Error($"ååºæä½å¤±è´¥: {ex.Message}");
			}
			}

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

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

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

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

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

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

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

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

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

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


			_unitOfWorkManage.CommitTran();

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

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

			#region åæ£ç¡®è®¤ç§ææ¹æ³

			private async Task<ValidationResult<(Dt_OutStockLockInfo, Dt_OutboundOrderDetail, Dt_StockInfoDetail)>> ValidatePickingRequest(string orderNo, string palletCode, string barcode)
			{
			// 1. åºç¡åæ°éªè¯
			if (string.IsNullOrEmpty(orderNo) \|\| string.IsNullOrEmpty(palletCode) \|\| string.IsNullOrEmpty(barcode))
			return ValidationResult<(Dt_OutStockLockInfo, Dt_OutboundOrderDetail, Dt_StockInfoDetail)>.Error("è®¢åå·ãæçç åæ¡ç ä¸è½ä¸ºç©º");

			// 2. æ¥æ¾ææçéå®ä¿¡æ¯
			var lockInfo = await FindValidLockInfo(orderNo, palletCode, barcode);
			if (lockInfo == null)
			return ValidationResult<(Dt_OutStockLockInfo, Dt_OutboundOrderDetail, Dt_StockInfoDetail)>.Error($"æªæ¾å°ææçéå®ä¿¡æ¯");

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

			if (order?.OrderStatus == (int)OutOrderStatusEnum.åºåºå®æ)
			return ValidationResult<(Dt_OutStockLockInfo, Dt_OutboundOrderDetail, Dt_StockInfoDetail)>.Error($"è®¢å{orderNo}å·²å®æï¼ä¸è½ç»§ç»åæ£");

			// 4. è·åè®¢åæç»
			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)>.Error($"æªæ¾å°è®¢åæç»");

			// 5. æ£æ¥è®¢åæç»æ°é
			if (orderDetail.OverOutQuantity >= orderDetail.NeedOutQuantity)
			return ValidationResult<(Dt_OutStockLockInfo, Dt_OutboundOrderDetail, Dt_StockInfoDetail)>.Error($"è®¢åæç»éæ±æ°éå·²æ»¡è¶³");

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

			if (stockDetail == null)
			return ValidationResult<(Dt_OutStockLockInfo, Dt_OutboundOrderDetail, Dt_StockInfoDetail)>.Error($"æ æçæ¡ç æç©æç¼ç ");

			// 7. æ£æ¥åºåç¶æåæ°é
			if (stockDetail.StockQuantity <= 0)
			return ValidationResult<(Dt_OutStockLockInfo, Dt_OutboundOrderDetail, Dt_StockInfoDetail)>.Error($"æ¡ç {barcode}åºåä¸è¶³");

			if (stockDetail.Status != StockStatusEmun.åºåºéå®.ObjToInt())
			return ValidationResult<(Dt_OutStockLockInfo, Dt_OutboundOrderDetail, Dt_StockInfoDetail)>.Error($"æ¡ç {barcode}ç¶æä¸æ£ç¡®ï¼æ æ³åæ£");

			// 8. æ£æ¥æ¯å¦éå¤åæ£
			var existingPicking = await Db.Queryable<Dt_PickingRecord>()
			.Where(x => x.Barcode == barcode && x.OrderNo == orderNo && x.PalletCode == palletCode && x.OutStockLockId == lockInfo.Id)
			.FirstAsync();

			if (existingPicking != null)
			return ValidationResult<(Dt_OutStockLockInfo, Dt_OutboundOrderDetail, Dt_StockInfoDetail)>.Error($"æ¡ç {barcode}å·²ç»åæ£è¿");

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

			private async Task<Dt_OutStockLockInfo> FindValidLockInfo(string orderNo, string palletCode, string barcode)
			{
			// ä¼åæ¥æ¾ç²¾ç¡®å¹éçè®°å½
			var lockInfo = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
			.Where(it => it.OrderNo == orderNo &&
			it.Status == (int)OutLockStockStatusEnum.åºåºä¸ &&
			it.PalletCode == palletCode &&
			it.CurrentBarcode == barcode &&
			it.AssignQuantity > it.PickedQty).FirstAsync();

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

			if (lockInfo == null)
			{
			// æ£æ¥æ¯å¦å·²ç»å®æåæ£
			var completedLockInfo = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
			.Where(it => it.CurrentBarcode == barcode &&
			(it.Status == (int)OutLockStockStatusEnum.æ£éå®æ \|\|
			it.PickedQty >= it.AssignQuantity)).FirstAsync();

			if (completedLockInfo != null)
			throw new Exception($"æ¡ç {barcode}å·²ç»å®æåæ£ï¼ä¸è½éå¤åæ£");
			else
			return null;
			}
			}

			return lockInfo;
			}

			private async Task<ValidationResult<(decimal, string)>> CalculateActualPickingQuantity(
			Dt_OutStockLockInfo lockInfo, Dt_OutboundOrderDetail orderDetail, Dt_StockInfoDetail stockDetail)
			{
			decimal plannedQty = lockInfo.AssignQuantity - lockInfo.PickedQty;
			decimal remainingOrderQty = orderDetail.NeedOutQuantity - orderDetail.OverOutQuantity;
			decimal stockQuantity = stockDetail.StockQuantity;

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

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

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

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

			if (adjustedReason != null)
			{
			_logger.LogWarning($"åæ£æ°éè°æ´ï¼{adjustedReason}ï¼è®¢å{orderDetail.NeedOutQuantity}ï¼å·²åºåº{orderDetail.OverOutQuantity}ï¼åºå{stockQuantity}");
			}

			return ValidationResult<(decimal, string)>.Success((actualQty, adjustedReason));
			}

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

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

			decimal projectedOverOut = orderDetail.OverOutQuantity + pickingQty;

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

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


			private async Task<PickingResult> ExecutePickingLogic(
			Dt_OutStockLockInfo lockInfo, Dt_OutboundOrderDetail orderDetail, Dt_StockInfoDetail stockDetail,
			string orderNo, string palletCode, string barcode, decimal actualQty)
			{
			decimal stockQuantity = stockDetail.StockQuantity;
			var result = new PickingResult
			{
			FinalLockInfo = lockInfo,
			FinalBarcode = barcode,
			FinalStockId = stockDetail.Id,
			ActualPickedQty = actualQty
			};

			if (actualQty < stockQuantity)
			{
			await HandleSplitPacking(lockInfo, stockDetail, actualQty, stockQuantity, result);
			// æååºæ¯è¿åå®éæ£éæ°é
			result.ActualPickedQty = actualQty;
			}
			else if (actualQty == stockQuantity)
			{
			await HandleFullPicking(lockInfo, stockDetail, actualQty, result);
			// æ´åæ£éè¿åå®éæ£éæ°é
			result.ActualPickedQty = actualQty;
			}
			else
			{
			await HandlePartialPicking(lockInfo, stockDetail, actualQty, stockQuantity, result);
			// é¨åæ£éè¿åè°æ´åçæ°é
			result.ActualPickedQty = result.ActualPickedQty; // å·²ç»å¨æ¹æ³åè°æ´
			}

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

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

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

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

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

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

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



			_logger.LogInformation($"æååæ£å®æ - OrderDetailId: {lockInfo.OrderDetailId}, åæ£æ°é: {actualQty}");
			}
			private async Task HandleFullPicking(Dt_OutStockLockInfo lockInfo, Dt_StockInfoDetail stockDetail,
			decimal actualQty, PickingResult result)
			{
			// 1. æ´æ°åºå
			stockDetail.StockQuantity = 0;
			stockDetail.OutboundQuantity = 0;
			stockDetail.Status = StockStatusEmun.åºåºå®æ.ObjToInt();
			await _stockInfoDetailService.Db.Updateable(stockDetail).ExecuteCommandAsync();

			// 2. æ´æ°éå®ä¿¡æ¯
			lockInfo.PickedQty += actualQty;
			lockInfo.Status = (int)OutLockStockStatusEnum.æ£éå®æ;
			lockInfo.Operator = App.User.UserName;
			await _outStockLockInfoService.Db.Updateable(lockInfo).ExecuteCommandAsync();
			}

			private async Task HandlePartialPicking(Dt_OutStockLockInfo lockInfo, Dt_StockInfoDetail stockDetail,
			decimal actualQty, decimal stockQuantity, PickingResult result)
			{
			decimal stockOutQty = stockQuantity;
			decimal remainingAssignQty = actualQty - stockQuantity;

			// 1. æ´æ°åºå
			stockDetail.StockQuantity = 0;
			stockDetail.OutboundQuantity = 0;
			stockDetail.Status = StockStatusEmun.åºåºå®æ.ObjToInt();
			await _stockInfoDetailService.Db.Updateable(stockDetail).ExecuteCommandAsync();

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

			// 3. æ´æ°æåè®°å½ç¶æ
			await UpdateSplitRecordsStatus(stockDetail.Barcode);

			result.ActualPickedQty = stockOutQty;
			}

			private async Task UpdateOrderRelatedData(int orderDetailId, decimal pickedQty, string orderNo)
			{
			// è·åææ°çè®¢åæç»æ°æ®
			var currentOrderDetail = await _outboundOrderDetailService.Db.Queryable<Dt_OutboundOrderDetail>()
			.FirstAsync(x => x.Id == orderDetailId);

			decimal newOverOutQuantity = currentOrderDetail.OverOutQuantity + pickedQty;
			decimal newPickedQty = currentOrderDetail.PickedQty + pickedQty;

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

			decimal adjustedQty = currentOrderDetail.NeedOutQuantity - currentOrderDetail.OverOutQuantity;

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

			// æ´æ°è®¢åæç»æ°éåç¶æ
			await _outboundOrderDetailService.Db.Updateable<Dt_OutboundOrderDetail>()
			.SetColumns(it => new Dt_OutboundOrderDetail
			{
			PickedQty = newPickedQty,
			OverOutQuantity = newOverOutQuantity,
			OrderDetailStatus = newOverOutQuantity >= currentOrderDetail.NeedOutQuantity ?
			OrderDetailStatusEnum.Over.ObjToInt() :
			OrderDetailStatusEnum.Outbound.ObjToInt()
			})
			.Where(it => it.Id == orderDetailId)
			.ExecuteCommandAsync();

			// æ´æ°éå®æ°é
			await UpdateOrderDetailLockQuantity(orderDetailId);

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

			private async Task RecordPickingHistory(PickingResult result, string orderNo, string palletCode)
			{
			var task = await _taskRepository.Db.Queryable<Dt_Task>()
			.Where(x => x.OrderNo == orderNo && x.PalletCode == palletCode)
			.FirstAsync();

			if (result.FinalLockInfo.Id <= 0)
			{
			throw new Exception($"éå®ä¿¡æ¯IDæ æ: {result.FinalLockInfo.Id}ï¼æ æ³è®°å½æ£éåå²");
			}

			var pickingHistory = new Dt_PickingRecord
			{
			FactoryArea = result.FinalLockInfo.FactoryArea,
			TaskNo = task?.TaskNum ?? 0,
			LocationCode = task?.SourceAddress ?? "",
			StockId = result.FinalStockId,
			OrderNo = orderNo,
			OrderDetailId = result.FinalLockInfo.OrderDetailId,
			PalletCode = palletCode,
			Barcode = result.FinalBarcode,
			MaterielCode = result.FinalLockInfo.MaterielCode,
			PickQuantity = result.ActualPickedQty,
			PickTime = DateTime.Now,
			Operator = App.User.UserName,
			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 ,


			};

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

			#endregion

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

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

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

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

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

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

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

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

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

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

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

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

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

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

			return true;
			}
			private async Task<ValidationResult<(Dt_PickingRecord, Dt_OutStockLockInfo, Dt_OutboundOrderDetail)>> ValidateCancelRequest(string orderNo, string palletCode, string barcode)
			{
			// åºç¡åæ°éªè¯
			if (string.IsNullOrEmpty(orderNo) \|\| string.IsNullOrEmpty(palletCode) \|\| string.IsNullOrEmpty(barcode))
			return ValidationResult<(Dt_PickingRecord, Dt_OutStockLockInfo, Dt_OutboundOrderDetail)>.Error("è®¢åå·ãæçç åæ¡ç ä¸è½ä¸ºç©º");

			// æ¥æ¾æ£éè®°å½
			var pickingRecord = await Db.Queryable<Dt_PickingRecord>()
			.Where(it => it.OrderNo == orderNo &&
			it.PalletCode == palletCode &&
			it.Barcode == barcode)
			.OrderByDescending(it => it.PickTime)
			.FirstAsync();

			if (pickingRecord == null)
			return ValidationResult<(Dt_PickingRecord, Dt_OutStockLockInfo, Dt_OutboundOrderDetail)>.Error("æªæ¾å°å¯¹åºçæ£éè®°å½");

			if (pickingRecord.PickQuantity <= 0)
			{
			return ValidationResult<(Dt_PickingRecord, Dt_OutStockLockInfo, Dt_OutboundOrderDetail)>.Error($"æ£éè®°å½æ°éæ æ: {pickingRecord.PickQuantity}");
			}
			// æ¥æ¾éå®ä¿¡æ¯
			var lockInfo = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
			.Where(it => it.Id == pickingRecord.OutStockLockId)
			.FirstAsync();

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

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

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

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

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

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

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

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

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

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

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

			if (stockDetail == null)
			return false;

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

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

			if (stockDetail == null)
			return false;

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

			// æ°æ®ä¸è´æ§éªè¯
			var context = new CancelPickingContext
			{
			LockInfo = lockInfo,
			PickingRecord = pickingRecord,
			OrderDetail = orderDetail,
			OrderNo = orderNo,
			CancelQuantity = cancelQty
			};

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

			// å¤çä¸åç±»åçåæ¶
			if (lockInfo.IsSplitted == 1 && lockInfo.ParentLockId.HasValue)
			{
			await HandleSplitBarcodeCancel(lockInfo, pickingRecord, cancelQty);
			}
			else
			{
			await HandleNormalBarcodeCancel(lockInfo, pickingRecord, cancelQty);
			}

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

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

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

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

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


			}

			private async Task HandleSplitBarcodeCancel(Dt_OutStockLockInfo lockInfo, Dt_PickingRecord pickingRecord, decimal cancelQty)
			{
			// æ¥æ¾ç¶éå®ä¿¡æ¯
			var parentLockInfo = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
			.Where(x => x.Id == lockInfo.ParentLockId.Value)
			.FirstAsync();

			if (parentLockInfo == null)
			throw new Exception("æªæ¾å°ç¶éå®ä¿¡æ¯ï¼æ æ³åæ¶æååæ£");

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

			_logger.LogInformation($"æ¢å¤åºå - æ¡ç : {stockDetail.Barcode}, æ¢å¤æ°é: {cancelQty}, " +
			$"æ°åºå: {stockDetail.StockQuantity}, æ°ç¶æ: {stockDetail.Status}");
			}
			else
			{
			_logger.LogWarning($"æªæ¾å°åºåè®°å½ - æ¡ç : {pickingRecord.Barcode}, åºåID: {pickingRecord.StockId}");
			}
			}
			private async Task UpdateOrderDetailOnCancel(int orderDetailId, decimal cancelQty)
			{
			// è·åææ°çè®¢åæç»æ°æ®ï¼å¸¦éï¼
			var currentOrderDetail = await _outboundOrderDetailService.Db.Queryable<Dt_OutboundOrderDetail>()
			.With(SqlWith.RowLock)
			.FirstAsync(x => x.Id == orderDetailId);

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

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

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

			// ç¡®å®æ°çç¶æ
			int newStatus;
			if (newOverOutQuantity >= currentOrderDetail.NeedOutQuantity)
			{
			newStatus = OrderDetailStatusEnum.Over.ObjToInt();
			}
			else if (newOverOutQuantity > 0)
			{
			newStatus = OrderDetailStatusEnum.Outbound.ObjToInt();
			}
			else
			{
			newStatus = OrderDetailStatusEnum.New.ObjToInt();
			}

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

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

			// æ´æ°éå®æ°é
			await UpdateOrderDetailLockQuantity(orderDetailId);

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

			#region ååºæä½ç§ææ¹æ³

			private async Task<Dt_StockInfo> GetStockInfo(string palletCode)
			{
			return await _stockInfoService.Db.Queryable<Dt_StockInfo>()
			.FirstAsync(x => x.PalletCode == palletCode);
			}
			/// <summary>
			/// æ£æ¥æ´ä¸ªæçæ¯å¦å·²ç»ååº
			/// </summary>
			private async Task<bool> IsPalletReturned(string palletCode)
			{
			var stockInfo = await _stockInfoService.Db.Queryable<Dt_StockInfo>()
			.Where(x => x.PalletCode == palletCode)
			.FirstAsync();

			if (stockInfo == null)
			return false;

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

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

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


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

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

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

			}

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

			// await UpdateOrderDetailsOnReturn(analysis.RemainingLocks);
			}

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

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

			// å¤çæåè®°å½
			if (analysis.HasSplitRecords)
			{
			var validSplitRecords = analysis.SplitRecords
			.Where(x => x.Status != (int)SplitPackageStatusEnum.å·²æ£é)
			.ToList();

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

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

			/// <summary>
			/// å®å¨éæ¾éå®ï¼åè®¸éæ°åéåºå
			/// </summary>
			private async Task ReleaseAllLocksForReallocation(string orderNo, string palletCode, PalletStatusAnalysis analysis)
			{
			_logger.LogInformation($"å¼å§éæ¾éå®ä»¥ä¾¿éæ°åé - è®¢å: {orderNo}, æç: {palletCode}");

			// 1. å¤çæªåæ£çåºåºéå®è®°å½ - å®å¨éæ¾
			if (analysis.HasRemainingLocks)
			{
			await ReleaseRemainingLocks(analysis.RemainingLocks);
			}

			// 2. å¤çå·²ååºçéå®è®°å½ - å é¤ææ è®°ä¸ºæ æ
			await CleanupReturnedLocks(orderNo, palletCode);

			// 3. éç½®è®¢åæç»çéå®æ°é
			await ResetOrderDetailLockQuantities(analysis);

			_logger.LogInformation($"éå®éæ¾å®æ - è®¢å: {orderNo}, æç: {palletCode}");
			}

			/// <summary>
			/// éæ¾æªåæ£çéå®è®°å½
			/// </summary>
			private async Task ReleaseRemainingLocks(List<Dt_OutStockLockInfo> remainingLocks)
			{
			var lockIds = remainingLocks.Select(x => x.Id).ToList();

			// å°éå®è®°å½ç¶ææ¹ä¸º"å·²éæ¾"ï¼æèç´æ¥å é¤
			// æ è®°ä¸ºå·²éæ¾
			await _outStockLockInfoService.Db.Updateable<Dt_OutStockLockInfo>()
			.SetColumns(it => new Dt_OutStockLockInfo
			{
			Status = (int)OutLockStockStatusEnum.å·²éæ¾, // éè¦æ°å¢è¿ä¸ªç¶æ
			// ReleaseTime = DateTime.Now,
			Operator = App.User.UserName
			})
			.Where(it => lockIds.Contains(it.Id))
			.ExecuteCommandAsync();

			// ç´æ¥å é¤ï¼æ´å½»åºï¼
			// await _outStockLockInfoService.Db.Deleteable<Dt_OutStockLockInfo>()
			// .Where(it => lockIds.Contains(it.Id))
			// .ExecuteCommandAsync();

			_logger.LogInformation($"éæ¾{remainingLocks.Count}æ¡æªåæ£éå®è®°å½");
			}

			/// <summary>
			/// æ¸çå·²ååºçéå®è®°å½
			/// </summary>
			private async Task CleanupReturnedLocks(string orderNo, string palletCode)
			{
			// æ¥æ¾ææç¶æä¸ºååºä¸çéå®è®°å½å¹¶éæ¾
			var returnedLocks = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
			.Where(it => it.OrderNo == orderNo &&
			it.PalletCode == palletCode &&
			it.Status == (int)OutLockStockStatusEnum.ååºä¸)
			.ToListAsync();

			if (returnedLocks.Any())
			{
			var returnedLockIds = returnedLocks.Select(x => x.Id).ToList();

			await _outStockLockInfoService.Db.Updateable<Dt_OutStockLockInfo>()
			.SetColumns(it => new Dt_OutStockLockInfo
			{
			Status = (int)OutLockStockStatusEnum.å·²éæ¾,
			//ReleaseTime = DateTime.Now,
			Operator = App.User.UserName
			})
			.Where(it => returnedLockIds.Contains(it.Id))
			.ExecuteCommandAsync();

			_logger.LogInformation($"æ¸ç{returnedLocks.Count}æ¡ååºä¸éå®è®°å½");
			}
			}

			/// <summary>
			/// éç½®è®¢åæç»çéå®æ°é
			/// </summary>
			private async Task ResetOrderDetailLockQuantities(PalletStatusAnalysis analysis)
			{
			// æ¶éææåå½±åçè®¢åæç»ID
			var affectedOrderDetailIds = new HashSet<int>();

			if (analysis.HasRemainingLocks)
			{
			foreach (var lockInfo in analysis.RemainingLocks)
			{
			affectedOrderDetailIds.Add(lockInfo.OrderDetailId);
			}
			}

			// éç½®è¿äºè®¢åæç»çéå®æ°é
			foreach (var orderDetailId in affectedOrderDetailIds)
			{
			await _outboundOrderDetailService.Db.Updateable<Dt_OutboundOrderDetail>()
			.SetColumns(it => new Dt_OutboundOrderDetail
			{
			LockQuantity = 0, // éç½®éå®æ°é
			OrderDetailStatus = OrderDetailStatusEnum.New.ObjToInt() // éç½®ç¶æä¸ºæ°å»º
			})
			.Where(it => it.Id == orderDetailId)
			.ExecuteCommandAsync();
			}

			_logger.LogInformation($"éç½®{affectedOrderDetailIds.Count}ä¸ªè®¢åæç»çéå®æ°é");
			}
			private async Task HandleRemainingLocksReturn(List<Dt_OutStockLockInfo> remainingLocks, int stockId)
			{
			var lockIds = remainingLocks.Select(x => x.Id).ToList();

			// æ´æ°åºåºéå®è®°å½ç¶æä¸ºååºä¸
			await _outStockLockInfoService.Db.Updateable<Dt_OutStockLockInfo>()
			.SetColumns(it => new Dt_OutStockLockInfo
			{
			Status = (int)OutLockStockStatusEnum.ååºä¸,
			})
			.Where(it => lockIds.Contains(it.Id))
			.ExecuteCommandAsync();

			// å¤çåºåè®°å½
			foreach (var lockInfo in remainingLocks)
			{
			decimal returnQty = lockInfo.AssignQuantity - lockInfo.PickedQty;
			if (returnQty <= 0)
			{
			_logger.LogWarning($"éå®è®°å½{lockInfo.Id}æ éååºï¼åéæ°é: {lockInfo.AssignQuantity}, å·²æ£é: {lockInfo.PickedQty}");
			continue;
			}

			_logger.LogInformation($"å¤çéå®è®°å½ååº - éå®ID: {lockInfo.Id}, æ¡ç : {lockInfo.CurrentBarcode}, ååºæ°é: {returnQty}");
			// æ¥æ¾å¯¹åºçåºåæç»
			var stockDetail = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
			.Where(it => it.Barcode == lockInfo.CurrentBarcode && it.StockId == lockInfo.StockId)
			.FirstAsync();

			if (stockDetail != null)
			{
			stockDetail.StockQuantity += returnQty;
			// æ¢å¤åºåç¶æ
			stockDetail.OutboundQuantity = Math.Max(0, stockDetail.OutboundQuantity - returnQty);
			stockDetail.Status = StockStatusEmun.å¥åºç¡®è®¤.ObjToInt();
			await _stockInfoDetailService.Db.Updateable(stockDetail).ExecuteCommandAsync();
			}
			else
			{
			_logger.LogWarning($"æªæ¾å°å¯¹åºçåºåæç» - æ¡ç : {lockInfo.CurrentBarcode}, åºåID: {lockInfo.StockId}");
			// åå»ºæ°çåºåè®°å½
			//var newStockDetail = new Dt_StockInfoDetail
			//{
			// StockId = lockInfo.StockId,
			// MaterielCode = lockInfo.MaterielCode,
			// MaterielName = lockInfo.MaterielName,
			// OrderNo = lockInfo.OrderNo,
			// BatchNo = lockInfo.BatchNo,
			// StockQuantity = returnQty,
			// OutboundQuantity = 0,
			// Barcode = lockInfo.CurrentBarcode,
			// InboundOrderRowNo = "",
			// Status = StockStatusEmun.å¥åºç¡®è®¤.ObjToInt(),
			// SupplyCode = lockInfo.SupplyCode,
			// WarehouseCode = lockInfo.WarehouseCode,
			// Unit = lockInfo.Unit,
			//};
			//await _stockInfoDetailService.Db.Insertable(newStockDetail).ExecuteCommandAsync();
			}
			try
			{
			var orderDetail = await _outboundOrderDetailService.Db.Queryable<Dt_OutboundOrderDetail>()
			.FirstAsync(x => x.Id == lockInfo.OrderDetailId);

			if (orderDetail != null)
			{
			decimal newLockQuantity = Math.Max(0, orderDetail.LockQuantity - returnQty);

			await _outboundOrderDetailService.Db.Updateable<Dt_OutboundOrderDetail>()
			.SetColumns(it => new Dt_OutboundOrderDetail
			{
			LockQuantity = newLockQuantity
			})
			.Where(it => it.Id == lockInfo.OrderDetailId)
			.ExecuteCommandAsync();

			_logger.LogInformation($"æ´æ°è®¢åæç»éå®æ°é - OrderDetailId: {lockInfo.OrderDetailId}, " +
			$"æ£åéå®: {returnQty}, æ°éå®æ°é: {newLockQuantity}");
			}
			}
			catch (Exception ex)
			{
			_logger.LogError($"æ´æ°è®¢åæç»éå®æ°éå¤±è´¥ - OrderDetailId: {lockInfo.OrderDetailId}, Error: {ex.Message}");
			}
			}


			}

			private async Task UpdateOrderDetailsOnReturn(List<Dt_OutStockLockInfo> remainingLocks)
			{
			// æè®¢åæç»åç»
			var orderDetailGroups = remainingLocks.GroupBy(x => x.OrderDetailId);

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

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

			if (orderDetail != null)
			{
			// è°æ´å·²æ£éæ°éåå·²åºåºæ°é
			decimal newPickedQty = Math.Max(0, orderDetail.PickedQty - totalReturnQty);
			decimal newOverOutQuantity = Math.Max(0, orderDetail.OverOutQuantity - totalReturnQty);

			await _outboundOrderDetailService.Db.Updateable<Dt_OutboundOrderDetail>()
			.SetColumns(it => new Dt_OutboundOrderDetail
			{
			PickedQty = newPickedQty,
			OverOutQuantity = newOverOutQuantity,
			})
			.Where(it => it.Id == orderDetailId)
			.ExecuteCommandAsync();
			}
			}
			}

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

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

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

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

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

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

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

			private async Task UpdateStockInfoStatus(Dt_StockInfo stockInfo)
			{
			_logger.LogInformation($"ååºæä½ï¼æç{stockInfo.PalletCode}çå¾AGVååºæ¬è¿");
			// æ´æ°åºåä¸»è¡¨ç¶æ
			stockInfo.StockStatus = StockStatusEmun.å¥åºç¡®è®¤.ObjToInt();
			await _stockInfoService.Db.Updateable(stockInfo).ExecuteCommandAsync();
			}
			/// <summary>
			/// åå»ºååºä»»å¡
			/// </summary>
			/// <param name="orderNo"></param>
			/// <param name="palletCode"></param>
			/// <param name="originalTask"></param>
			/// <param name="analysis"></param>
			/// <returns></returns>
			private async Task CreateReturnTaskAndHandleESS(string orderNo, string palletCode, Dt_Task originalTask, TaskTypeEnum taskTypeEnum, int palletType)
			{
			var firstLocation = await _locationInfoService.Db.Queryable<Dt_LocationInfo>()
			.FirstAsync(x => x.LocationCode == originalTask.SourceAddress);

			// åéæ°è´§ä½
			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 CheckAndUpdateOrderStatus(string orderNo)
			{
			try
			{
			var orderDetails = await _outboundOrderDetailService.Db.Queryable<Dt_OutboundOrderDetail>()
			.LeftJoin<Dt_OutboundOrder>((o, item) => o.OrderId == item.Id)
			.Where((o, item) => item.OrderNo == orderNo)
			.Select((o, item) => o)
			.ToListAsync();

			bool allCompleted = true;
			bool hasPartial = false;
			bool hasLocked = false;

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

			if (detail.OrderDetailStatus == OrderDetailStatusEnum.Outbound.ObjToInt())
			{
			hasPartial = true;
			}

			//if (detail.OrderDetailStatus == OrderDetailStatusEnum.Locked.ObjToInt())
			//{
			// hasLocked = true;
			//}
			}

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

			if (outboundOrder == null) return;

			int newStatus;
			if (allCompleted)
			{
			newStatus = (int)OutOrderStatusEnum.åºåºå®æ;
			}
			else if (hasPartial )
			{
			newStatus = (int)OutOrderStatusEnum.åºåºä¸;
			}
			else
			{
			newStatus = (int)OutOrderStatusEnum.æªå¼å§;
			}

			if (outboundOrder.OrderStatus != newStatus)
			{
			await _outboundOrderService.Db.Updateable<Dt_OutboundOrder>()
			.SetColumns(x => new Dt_OutboundOrder
			{
			OrderStatus = newStatus,
			Operator = App.User.UserName,
			})
			.Where(x => x.OrderNo == orderNo)
			.ExecuteCommandAsync();

			_logger.LogInformation($"è®¢åç¶ææ´æ° - OrderNo: {orderNo}, æ§ç¶æ: {outboundOrder.OrderStatus}, æ°ç¶æ: {newStatus}");

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

			/// <summary>
			/// æ´æ°è®¢åæç»ç¶æï¼åºäºå·²åºåºæ°éï¼
			/// </summary>
			private async Task UpdateOrderDetailStatus(int orderDetailId)
			{
			var orderDetail = await _outboundOrderDetailService.Db.Queryable<Dt_OutboundOrderDetail>()
			.FirstAsync(x => x.Id == orderDetailId);

			if (orderDetail == null) return;

			int newStatus = orderDetail.OrderDetailStatus;

			if (orderDetail.OverOutQuantity >= orderDetail.NeedOutQuantity)
			{
			// å·²åºåºæ°é >= éæ±æ°éï¼æ è®°ä¸ºå®æ
			newStatus = OrderDetailStatusEnum.Over.ObjToInt();
			}
			else if (orderDetail.OverOutQuantity > 0)
			{
			// æé¨ååºåºï¼ä½æªå®æ
			newStatus = OrderDetailStatusEnum.Outbound.ObjToInt();
			}
			else if (orderDetail.LockQuantity > 0)
			{
			// æéå®æ°éï¼ä½æªåºåº
			//newStatus = OrderDetailStatusEnum.Locked.ObjToInt();
			}
			else
			{
			// æ°å»ºç¶æ
			newStatus = OrderDetailStatusEnum.New.ObjToInt();
			}

			// åªæç¶æåçååæ¶ææ´æ°
			if (orderDetail.OrderDetailStatus != newStatus)
			{
			await _outboundOrderDetailService.Db.Updateable<Dt_OutboundOrderDetail>()
			.SetColumns(it => new Dt_OutboundOrderDetail
			{
			OrderDetailStatus = newStatus,

			})
			.Where(it => it.Id == orderDetailId)
			.ExecuteCommandAsync();
			}
			}
			/// <summary>
			/// æ´æ°è®¢åæç»éå®æ°é
			/// </summary>
			private async Task UpdateOrderDetailLockQuantity(int orderDetailId)
			{
			var totalLockedQty = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
			.Where(x => x.OrderDetailId == orderDetailId &&
			x.Status == (int)OutLockStockStatusEnum.åºåºä¸)
			.SumAsync(x => x.AssignQuantity - x.PickedQty);

			await _outboundOrderDetailService.Db.Updateable<Dt_OutboundOrderDetail>()
			.SetColumns(it => new Dt_OutboundOrderDetail
			{
			LockQuantity = totalLockedQty
			})
			.Where(it => it.Id == orderDetailId)
			.ExecuteCommandAsync();
			}
			private async Task UpdateOrderStatusForReturn(string orderNo)
			{
			try
			{
			var orderDetails = await _outboundOrderDetailService.Db.Queryable<Dt_OutboundOrderDetail>()
			.LeftJoin<Dt_OutboundOrder>((o, item) => o.OrderId == item.Id)
			.Where((o, item) => item.OrderNo == orderNo)
			.Select((o, item) => o)
			.ToListAsync();

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

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

			if (outboundOrder == null) return;

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

			if (outboundOrder.OrderStatus != newStatus)
			{
			await _outboundOrderService.Db.Updateable<Dt_OutboundOrder>()
			.SetColumns(x => new Dt_OutboundOrder
			{
			OrderStatus = newStatus,
			Operator = App.User.UserName,
			})
			.Where(x => x.OrderNo == orderNo)
			.ExecuteCommandAsync();

			_logger.LogInformation($"ååºæä½æ´æ°è®¢åç¶æ - OrderNo: {orderNo}, æ°ç¶æ: {newStatus}");
			}
			}
			catch (Exception ex)
			{
			_logger.LogError($"UpdateOrderStatusForReturnå¤±è´¥ - OrderNo: {orderNo}, Error: {ex.Message}");
			}
			}

			private async Task HandleOrderCompletion(Dt_OutboundOrder outboundOrder, string orderNo)
			{
			// è°æ¨åºåºåéæ£åºåºä¸éè¦åé¦MES
			if (outboundOrder.OrderType == OutOrderTypeEnum.Allocate.ObjToInt())
			{
			var allocate = _allocateService.Repository.QueryData(x => x.UpperOrderNo == outboundOrder.UpperOrderNo).First();
			var allocatefeedmodel = new AllocateDto
			{
			ReqCode = Guid.NewGuid().ToString(),
			ReqTime = DateTime.Now.ToString(),
			BusinessType = "3",

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

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

			var groupedData = lists.GroupBy(item => new { item.MaterielCode, item.lineNo, item.Unit, item.WarehouseCode })
			.Select(group => new AllocateDtoDetail
			{
			MaterialCode = group.Key.MaterielCode,
			LineNo = group.Key.lineNo,
			WarehouseCode = group.Key.WarehouseCode,
			Qty = group.Sum(x => x.PickedQty),

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


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

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

			await _outboundOrderService.Db.Updateable<Dt_OutboundOrder>()
			.SetColumns(x => new Dt_OutboundOrder
			{
			ReturnToMESStatus = 1,
			Operator = App.User.UserName,
			}).Where(x => x.OrderNo == orderNo).ExecuteCommandAsync();
			}
			}
			else if (outboundOrder.OrderType == OutOrderTypeEnum.ReCheck.ObjToInt())
			{

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

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

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

			feedmodel.details = groupedData;

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

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

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

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

			#endregion

			#region ç©ºæç

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

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

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



			}
			catch (Exception ex)
			{
			_logger.LogWarning($"æ¸çé¶åºåæ°æ®å¤±è´¥ - StockId: {stockId}, Error: {ex.Message}");
			// æ³¨æï¼æ¸çå¤±è´¥ä¸åºè¯¥å½±åä¸»æµç¨
			}
			}
			/// <summary>
			/// å¤çä»»å¡æ¸çï¼æè®¢ååæçï¼
			/// </summary>
			private async Task HandleTaskCleanup(string orderNo, string palletCode)
			{
			try
			{
			// 1. æ¥æ¾ææä¸è¯¥è®¢ååæçç¸å³çä»»å¡
			var tasks = await _taskRepository.Db.Queryable<Dt_Task>().Where(x => x.OrderNo == orderNo && x.PalletCode == palletCode).ToListAsync();

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

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

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

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

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

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

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

			/// <summary>
			/// æ£æ¥å¹¶æ´æ°è®¢åå®æç¶æ
			/// </summary>
			private async Task CheckAndUpdateOrderCompletion(string orderNo)
			{
			var orderDetails = await _outboundOrderDetailService.Db.Queryable<Dt_OutboundOrderDetail>()
			.LeftJoin<Dt_OutboundOrder>((o, item) => o.OrderId == item.Id)
			.Where((o, item) => item.OrderNo == orderNo)
			.Select((o, item) => o)
			.ToListAsync();

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

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

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

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

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

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

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

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

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



			#region è¾å©æ¹æ³
			/// <summary>
			/// ç»ä¸åææçç¶æ - è¿åæççå®æ´ç¶æä¿¡æ¯
			/// </summary>
			private async Task<PalletStatusAnalysis> AnalyzePalletStatus(string orderNo, string palletCode, int stockId)
			{
			var result = new PalletStatusAnalysis
			{
			OrderNo = orderNo,
			PalletCode = palletCode,
			StockId = stockId
			};

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

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

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

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

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

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

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

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

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

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

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

			return result;
			}

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

			if (stockInfo == null)
			return false;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

			private async Task<Dt_OutStockLockInfo> CreateSplitLockInfo(Dt_OutStockLockInfo originalLock, decimal quantity, string newBarcode)
			{
			var newLockInfo = new Dt_OutStockLockInfo
			{
			OrderNo = originalLock.OrderNo,
			OrderDetailId = originalLock.OrderDetailId,
			BatchNo = originalLock.BatchNo,
			MaterielCode = originalLock.MaterielCode,
			MaterielName = originalLock.MaterielName,
			StockId = originalLock.StockId,
			OrderQuantity = quantity,
			OriginalQuantity = quantity,
			AssignQuantity = quantity,
			PickedQty = quantity,
			LocationCode = originalLock.LocationCode,
			PalletCode = originalLock.PalletCode,
			TaskNum = originalLock.TaskNum,
			Status = (int)OutLockStockStatusEnum.æ£éå®æ,
			Unit = originalLock.Unit,
			SupplyCode = originalLock.SupplyCode,
			OrderType = originalLock.OrderType,
			CurrentBarcode = newBarcode,
			OriginalLockQuantity = quantity,
			IsSplitted = 1,
			ParentLockId = originalLock.Id,
			Operator = App.User.UserName,
			FactoryArea = originalLock.FactoryArea,
			lineNo = originalLock.lineNo,
			WarehouseCode = originalLock.WarehouseCode,
			BarcodeQty=originalLock.BarcodeQty,
			BarcodeUnit=originalLock.BarcodeUnit,

			};

			var newLockId = await _outStockLockInfoService.Db.Insertable(newLockInfo).ExecuteReturnIdentityAsync();
			newLockInfo.Id = newLockId;
			return newLockInfo;
			}

			private async Task RecordSplitHistory(Dt_OutStockLockInfo lockInfo, Dt_StockInfoDetail stockDetail,
			decimal splitQty, decimal remainQty, string newBarcode)
			{
			var splitHistory = new Dt_SplitPackageRecord
			{
			FactoryArea = lockInfo.FactoryArea,
			TaskNum = lockInfo.TaskNum,
			OutStockLockInfoId = lockInfo.Id,
			StockId = stockDetail.StockId,
			Operator = App.User.UserName,
			IsReverted = false,
			OriginalBarcode = stockDetail.Barcode,
			NewBarcode = newBarcode,
			SplitQty = splitQty,
			RemainQuantity = remainQty,
			MaterielCode = lockInfo.MaterielCode,
			SplitTime = DateTime.Now,
			OrderNo = lockInfo.OrderNo,
			PalletCode = lockInfo.PalletCode,
			Status = (int)SplitPackageStatusEnum.å·²æ£é
			};

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

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

			private async Task UpdateSplitRecordsStatus(string barcode)
			{
			var relatedSplitRecords = await _splitPackageService.Db.Queryable<Dt_SplitPackageRecord>()
			.Where(it => it.OriginalBarcode == barcode \|\| it.NewBarcode == barcode)
			.Where(it => !it.IsReverted)
			.ToListAsync();

			foreach (var record in relatedSplitRecords)
			{
			record.Status = (int)SplitPackageStatusEnum.å·²æ£é;
			await _splitPackageService.Db.Updateable(record).ExecuteCommandAsync();
			}
			}

			private async Task<int> GenerateTaskNumber()
			{
			return await _dailySequenceService.GetNextSequenceAsync();
			}

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

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

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

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



			#region èæåºå¥åº
			public WebResponseContent GetAvailablePurchaseOrders()
			{
			List<Dt_InboundOrder> InOders = _inboundOrderRepository.QueryData().Where(x => x.OrderStatus != InOrderStatusEnum.å¥åºå®æ.ObjToInt()).ToList();
			List<string> InOderCodes = InOders.Select(x => x.UpperOrderNo).ToList();
			return WebResponseContent.Instance.OK("æå",data: InOderCodes);
			}

			public WebResponseContent GetAvailablePickingOrders()
			{
			List<Dt_OutboundOrder> outOders = _outboundOrderService.Db.Queryable<Dt_OutboundOrder>().Where(x => x.OrderStatus != OutOrderStatusEnum.åºåºå®æ.ObjToInt()).ToList();

			List<string> outOderCodes = outOders.Select(x => x.UpperOrderNo).ToList();
			return WebResponseContent.Instance.OK("æå", data: outOderCodes);

			}
			public WebResponseContent BarcodeValidate(NoStockOutModel noStockOut)
			{
			try
			{
			Dt_InboundOrder inboundOrder = Db.Queryable<Dt_InboundOrder>().Where(x => x.UpperOrderNo == noStockOut.inOder && x.OrderStatus != InOrderStatusEnum.å¥åºå®æ.ObjToInt()).Includes(x => x.Details).First();
			if(inboundOrder == null)
			{
			return WebResponseContent.Instance.Error($"æªæ¾å°éè´åï¼{noStockOut.inOder}");
			}
			var matchedDetail = inboundOrder.Details.FirstOrDefault(detail => detail.Barcode == noStockOut.barCode && detail.OrderDetailStatus != OrderDetailStatusEnum.Over.ObjToInt());

			if (matchedDetail == null)
			{
			return WebResponseContent.Instance.Error($"å¨éè´å {noStockOut.inOder} ä¸æªæ¾å°æ¡ç ä¸º {noStockOut.barCode} çæç»ã");
			}
			matchedDetail.NoStockOutQty = 0;

			Dt_OutboundOrder outboundOrder = Db.Queryable<Dt_OutboundOrder>().Where(x => x.UpperOrderNo == noStockOut.outOder && x.OrderStatus != OutOrderStatusEnum.åºåºå®æ.ObjToInt()).Includes(x => x.Details).First();
			if (outboundOrder == null)
			{
			return WebResponseContent.Instance.Error($"æªæ¾å°åºåºåï¼{noStockOut.inOder}");
			}
			var matchedCode = outboundOrder.Details.FirstOrDefault(detail => detail.MaterielCode == matchedDetail.MaterielCode && detail.OrderDetailStatus != OrderDetailStatusEnum.Over.ObjToInt());

			if (matchedCode == null)
			{
			return WebResponseContent.Instance.Error($"å¨åºåºåçç©æç¼ç ä¸æªæ¾å°ä¸éè´åä¸ç{matchedDetail.MaterielCode} å¯¹åºçç©æã");
			}
			matchedCode.NoStockOutQty = 0;

			//å©ä½å¥åºæ°éå³èæåºå¥åºå©ä½å¯åºæ°é
			decimal outQuantity = matchedDetail.OrderQuantity - matchedDetail.ReceiptQuantity;
			if(outQuantity == 0)
			{
			return WebResponseContent.Instance.Error($"è¯¥éè´åä¸çæ¡ç å¯¹åºçå¯åºæ°éä¸º0");
			}
			if (matchedCode.OrderQuantity < outQuantity)
			{
			return WebResponseContent.Instance.Error($"è¯¥éè´åä¸çæ¡ç å¯¹åºçå¯åºæ°éè¶åºåºåºååºåºæ°é{matchedDetail.OrderQuantity - matchedCode.OrderQuantity},ä¸æ»¡è¶³æ´ååºåº");
			}
			//åæ®åºåºéå®æ°é
			matchedDetail.NoStockOutQty += outQuantity;
			matchedCode.NoStockOutQty += outQuantity;

			if ((matchedCode.LockQuantity + matchedCode.NoStockOutQty) > matchedCode.OrderQuantity)
			{
			return WebResponseContent.Instance.Error($"åºåºåæç»æ°éæº¢åº{matchedCode.LockQuantity - matchedCode.OrderQuantity}");
			}
			matchedDetail.OrderDetailStatus = OrderDetailStatusEnum.Inbounding.ObjToInt();
			matchedCode.OrderDetailStatus = OrderDetailStatusEnum.AssignOver.ObjToInt();

			_unitOfWorkManage.BeginTran();
			_inboundOrderDetailService.UpdateData(matchedDetail);
			_outboundOrderDetailService.UpdateData(matchedCode);
			_unitOfWorkManage.CommitTran();
			return WebResponseContent.Instance.OK();
			}
			catch(Exception ex)
			{
			_unitOfWorkManage.RollbackTran();
			return WebResponseContent.Instance.Error(ex.Message);
			}
			}


			public WebResponseContent DeleteBarcode(NoStockOutModel noStockOut)
			{
			try
			{
			Dt_InboundOrder inboundOrder = Db.Queryable<Dt_InboundOrder>().Where(x => x.UpperOrderNo == noStockOut.inOder && x.OrderStatus != InOrderStatusEnum.å¥åºå®æ.ObjToInt()).Includes(x => x.Details).First();
			if (inboundOrder == null)
			{
			return WebResponseContent.Instance.Error($"æªæ¾å°éè´åï¼{noStockOut.inOder}");
			}
			var matchedDetail = inboundOrder.Details.FirstOrDefault(detail => detail.Barcode == noStockOut.barCode && detail.OrderDetailStatus != OrderDetailStatusEnum.Over.ObjToInt());

			if (matchedDetail == null)
			{
			return WebResponseContent.Instance.Error($"å¨éè´å {noStockOut.inOder} ä¸æªæ¾å°æ¡ç ä¸º {noStockOut.barCode} çæç»ã");
			}
			matchedDetail.NoStockOutQty = 0;

			if(matchedDetail.ReceiptQuantity==0 && matchedDetail.OverInQuantity==0)
			{
			matchedDetail.OrderDetailStatus = OrderDetailStatusEnum.New.ObjToInt();
			}

			Dt_OutboundOrder outboundOrder = Db.Queryable<Dt_OutboundOrder>().Where(x => x.UpperOrderNo == noStockOut.outOder && x.OrderStatus != OutOrderStatusEnum.åºåºå®æ.ObjToInt()).Includes(x => x.Details).First();
			if (outboundOrder == null)
			{
			return WebResponseContent.Instance.Error($"æªæ¾å°åºåºåï¼{noStockOut.inOder}");
			}
			var matchedCode = outboundOrder.Details.FirstOrDefault(detail => detail.MaterielCode == matchedDetail.MaterielCode && detail.OrderDetailStatus != OrderDetailStatusEnum.Over.ObjToInt());

			if (matchedCode == null)
			{
			return WebResponseContent.Instance.Error($"å¨åºåºåçç©æç¼ç ä¸æªæ¾å°ä¸éè´åä¸ç{matchedDetail.MaterielCode} å¯¹åºçç©æã");
			}
			matchedCode.NoStockOutQty = 0;
			if (matchedCode.LockQuantity == 0 && matchedCode.OverOutQuantity == 0)
			{
			matchedCode.OrderDetailStatus = OrderDetailStatusEnum.New.ObjToInt();
			}
			_unitOfWorkManage.BeginTran();
			_inboundOrderDetailService.UpdateData(matchedDetail);
			_outboundOrderDetailService.UpdateData(matchedCode);
			_unitOfWorkManage.CommitTran();
			return WebResponseContent.Instance.OK();

			}
			catch(Exception ex)
			{
			_unitOfWorkManage.RollbackTran();
			return WebResponseContent.Instance.Error(ex.Message);
			}
			}

			public WebResponseContent NoStockOutSubmit(NoStockOutSubmit noStockOutSubmit)
			{
			try
			{
			Dt_InboundOrder inboundOrder = Db.Queryable<Dt_InboundOrder>().Where(x => x.UpperOrderNo == noStockOutSubmit.InOderSubmit && x.OrderStatus != InOrderStatusEnum.å¥åºå®æ.ObjToInt()).Includes(x => x.Details).First();
			if (inboundOrder == null)
			{
			return WebResponseContent.Instance.Error($"æªæ¾å°éè´åï¼{noStockOutSubmit.InOderSubmit}");
			}
			Dt_OutboundOrder outboundOrder = Db.Queryable<Dt_OutboundOrder>().Where(x => x.UpperOrderNo == noStockOutSubmit.OutOderSubmit && x.OrderStatus != OutOrderStatusEnum.åºåºå®æ.ObjToInt()).Includes(x => x.Details).First();
			if (outboundOrder == null)
			{
			return WebResponseContent.Instance.Error($"æªæ¾å°åºåºåï¼{noStockOutSubmit.OutOderSubmit}");
			}
			List<Dt_InboundOrderDetail> inboundOrderDetails = new List<Dt_InboundOrderDetail>();
			List<Dt_OutboundOrderDetail> outboundOrderDetails = new List<Dt_OutboundOrderDetail>();
			foreach (var BarCode in noStockOutSubmit.BarCodeSubmit)
			{
			var inboundOrderDetail = inboundOrder.Details.FirstOrDefault(detail => detail.Barcode == BarCode && detail.OrderDetailStatus != OrderDetailStatusEnum.Over.ObjToInt());

			if(inboundOrderDetail == null)
			{
			return WebResponseContent.Instance.Error($"å¨éè´å {noStockOutSubmit.InOderSubmit} ä¸æªæ¾å°æ¡ç ä¸º {BarCode} çæç»ã");
			}
			var outboundOrderDetail = outboundOrder.Details.FirstOrDefault(detail => detail.MaterielCode == inboundOrderDetail.MaterielCode && detail.OrderDetailStatus != OrderDetailStatusEnum.Over.ObjToInt());

			if (outboundOrderDetail == null)
			{
			return WebResponseContent.Instance.Error($"å¨åºåºåçç©æç¼ç ä¸æªæ¾å°ä¸éè´åä¸ç{inboundOrderDetail.MaterielCode} å¯¹åºçç©æã");
			}
			inboundOrderDetail.ReceiptQuantity += inboundOrderDetail.NoStockOutQty;
			inboundOrderDetail.OverInQuantity = inboundOrderDetail.ReceiptQuantity;
			inboundOrderDetail.OrderDetailStatus = OrderDetailStatusEnum.Over.ObjToInt();
			inboundOrderDetails.Add(inboundOrderDetail);

			outboundOrderDetail.LockQuantity += outboundOrderDetail.NoStockOutQty;
			outboundOrderDetail.OverOutQuantity = outboundOrderDetail.LockQuantity;
			if(outboundOrderDetail.OrderQuantity == outboundOrderDetail.OverOutQuantity)
			{
			outboundOrderDetail.OrderDetailStatus = OrderDetailStatusEnum.Over.ObjToInt();
			}
			outboundOrderDetails.Add(outboundOrderDetail);

			}
			//å¤æå¥åºåæ®æç»æ¯å¦å¨é¨æ¯å®æç¶æ
			int e = inboundOrder.Details.Count();
			int w = inboundOrder.Details.Where(x => x.OrderDetailStatus == OrderDetailStatusEnum.Over.ObjToInt()).Count();
			bool inoderOver = inboundOrder.Details.Count() == inboundOrder.Details.Where(x => x.OrderDetailStatus == OrderDetailStatusEnum.Over.ObjToInt()).Count();
			if (inoderOver)
			{
			inboundOrder.OrderStatus = InOrderStatusEnum.å¥åºå®æ.ObjToInt();
			}
			else
			{
			inboundOrder.OrderStatus = InOrderStatusEnum.å¥åºä¸.ObjToInt();
			}
			//å¤æåºåºåæ®æç»æ¯å¦å¨é¨æ¯å®æç¶æ
			bool outOderOver = outboundOrder.Details.Count() == outboundOrder.Details.Where(x => x.OrderDetailStatus == OrderDetailStatusEnum.Over.ObjToInt()).Count();
			if (outOderOver)
			{
			outboundOrder.OrderStatus = OutOrderStatusEnum.åºåºå®æ.ObjToInt();
			}
			else
			{
			outboundOrder.OrderStatus = OutOrderStatusEnum.åºåºä¸.ObjToInt();
			}
			//æ°æ®å¤ç
			_unitOfWorkManage.BeginTran();
			_inboundOrderDetailService.UpdateData(inboundOrderDetails);
			_outboundOrderDetailService.UpdateData(outboundOrderDetails);
			_inboundOrderRepository.UpdateData(inboundOrder);
			_outboundOrderService.UpdateData(outboundOrder);
			_unitOfWorkManage.CommitTran();

			return WebResponseContent.Instance.OK();
			}
			catch(Exception ex)
			{
			_unitOfWorkManage.RollbackTran();
			return WebResponseContent.Instance.Error(ex.Message);
			}
			}
			#endregion


			#endregion
			}



			#region æ¯æç±»å®ä¹

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

			public static ValidationResult<T> Success(T data)
			{
			return new ValidationResult<T>
			{
			IsValid = true,
			Data = data
			};
			}

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


			#region è¿å
			/// <summary>
			/// æåé¾é¡¹
			/// </summary>
			public class SplitChainItem
			public class PickingResult
			{
			public Dt_SplitPackageRecord SplitRecord { get; set; }
			public string OriginalBarcode { get; set; }
			public string NewBarcode { get; set; }
			public decimal SplitQuantity { get; set; }
			public Dt_OutStockLockInfo FinalLockInfo { get; set; }
			public string FinalBarcode { get; set; }
			public int FinalStockId { get; set; }
			public decimal ActualPickedQty { get; set; }
			public List<SplitResult> SplitResults { get; set; } = new List<SplitResult>();
			}
			public class ReturnAnalysisResult

			public class ReturnAnalysisResult
			{
			public bool HasItemsToReturn { get; set; }
			public bool HasRemainingLocks { get; set; }
			@@ -1997,7 +2818,56 @@
			public List<Dt_StockInfoDetail> PalletStockGoods { get; set; } = new List<Dt_StockInfoDetail>();
			public List<Dt_SplitPackageRecord> SplitRecords { get; set; } = new List<Dt_SplitPackageRecord>();
			}
			public class PalletStatusAnalysis
			{
			public string OrderNo { get; set; }
			public string PalletCode { get; set; }
			public int StockId { get; set; }

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

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

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

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

			}