ZhongRui/ALDbanyunxiangmu.git

			@@ -9,6 +9,7 @@
			using System.Linq;
			using System.Text;
			using System.Threading.Tasks;
			using WIDESEA_Common.CommonEnum;
			using WIDESEA_Common.LocationEnum;
			using WIDESEA_Common.OrderEnum;
			using WIDESEA_Common.StockEnum;
			@@ -16,6 +17,7 @@
			using WIDESEA_Core;
			using WIDESEA_Core.BaseRepository;
			using WIDESEA_Core.BaseServices;
			using WIDESEA_Core.Enums;
			using WIDESEA_Core.Helper;
			using WIDESEA_DTO.Basic;
			using WIDESEA_DTO.Inbound;
			@@ -86,1125 +88,7 @@
			}


			#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).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.AssignQuantity
			}).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)
			{
			#region "æµè¯æå°"
			// var splitResults=new List<SplitResult>();
			// splitResults.Add(new SplitResult
			//{
			// materialCode = "AAAAbbb",
			// supplierCode = "CVBG",
			// quantityTotal = "1234",
			// batchNumber = "WMLOT25111900032",
			// batch = "A234re",
			// factory = "01",
			// date = DateTime.Now.ToString("yyyy-MM-dd"),
			//});

			//splitResults.Add(new SplitResult
			//{
			// materialCode = "CCDF",
			// supplierCode = "QWCVBG",
			// quantityTotal = "1234",
			// batchNumber = "WMLOT25111900032",
			// batch = "A234re",
			// factory = "01",
			// date = DateTime.Now.ToString("yyyy-MM-dd"),
			//});

			// return WebResponseContent.Instance.OK("æ£éç¡®è®¤æåï¼å·²èªå¨æå", new { SplitResults = splitResults });
			#endregion
			try
			{
			_unitOfWorkManage.BeginTran();

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

			if (lockInfo.PickedQty >= lockInfo.AssignQuantity)
			{
			throw new Exception($"æ¡ç {barcode}å·²ç»å®æåæ£ï¼ä¸è½éå¤åæ£");
			}

			// æ£æ¥æ£éåå²ï¼é²æ¢éå¤åæ£
			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 outorderdetail = _outboundOrderDetailService.Db.Queryable<Dt_OutboundOrderDetail>().First(x => x.Id == lockInfo.OrderDetailId);
			if (outorderdetail != null && lockInfo.AssignQuantity > outorderdetail.OrderQuantity)
			{
			throw new Exception($"æ¡ç {barcode}çåºåºæ°éå¤§äºè®¢åçæ°é");
			}

			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 actualQty = lockInfo.AssignQuantity - lockInfo.PickedQty;
			decimal stockQuantity = stockDetail.StockQuantity;

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

			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
			};
			// æå¥æ°éå®ä¿¡æ¯å¹¶è·åID
			var newLockId = await _outStockLockInfoService.Db.Insertable(newLockInfo).ExecuteReturnIdentityAsync();
			newLockInfo.Id = newLockId; // ç¡®ä¿IDè¢«æ£ç¡®è®¾ç½®

			// è®°å½æååå²ï¼ç¨äºè¿½è¸ªï¼
			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"),
			});
			// æ´æ°æ£éè®°å½ä¸çæ¡ç ä¸ºæ°æ¡ç
			barcode = newBarcode;
			lockInfo = newLockInfo;
			finalLockInfo = newLockInfo;
			finalBarcode = newBarcode;
			finalStockId = stockDetail.Id; // ä½¿ç¨ååºåID
			}
			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();
			finalLockInfo = lockInfo;
			finalBarcode = barcode;
			finalStockId = stockDetail.Id;
			}
			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();
			}
			finalLockInfo = lockInfo;
			finalBarcode = barcode;
			finalStockId = stockDetail.Id;
			}



			await _outboundOrderDetailService.Db.Updateable<Dt_OutboundOrderDetail>()
			.SetColumns(it => it.PickedQty == it.PickedQty + actualQty)
			.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 = actualQty,
			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 = splitResults });

			}
			catch (Exception ex)
			{
			_unitOfWorkManage.RollbackTran();
			return WebResponseContent.Instance.Error($"æ£éç¡®è®¤å¤±è´¥ï¼{ex.Message}");
			}
			}

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

			// åæ¶æ£éåè½
			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 splitChain = await GetSplitChain(barcode);

			if (splitChain.Any())
			{
			// æåµAï¼å¤çæåé¾çåæ¶ï¼å¤æ¬¡æå¨æåï¼
			await HandleSplitChainCancel(orderNo, palletCode, barcode, cancelQty, lockInfo, pickingRecord, splitChain);
			}
			else
			{
			// æåµBï¼å¤çæ®éæ¡ç çåæ¶
			await HandleNormalBarcodeCancel(orderNo, palletCode, barcode, cancelQty, lockInfo, pickingRecord);
			}

			_unitOfWorkManage.CommitTran();
			return WebResponseContent.Instance.OK($"åæ¶åæ£æåï¼æ¢å¤æ°éï¼{cancelQty}");
			}
			catch (Exception ex)
			{
			_unitOfWorkManage.RollbackTran();
			return WebResponseContent.Instance.Error($"åæ¶åæ£å¤±è´¥ï¼{ex.Message}");
			}
			}

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

			/// <summary>
			/// è®°å½åæ¶æä½åå²
			/// </summary>
			private async Task RecordCancelHistory(string orderNo, string palletCode, string barcode,
			decimal cancelQty, int pickingRecordId, string materielCode, string reason)
			{

			//var cancelHistory = new Dt_PickingCancelRecord
			//{
			// OrderNo = orderNo,
			// PalletCode = palletCode,
			// Barcode = barcode,
			// CancelQuantity = cancelQty,
			// CancelTime = DateTime.Now,
			// Operator = App.User.UserName,
			// OriginalPickingRecordId = pickingRecordId,
			// MaterielCode = materielCode,
			// Reason = reason
			//};
			//await Db.Insertable(cancelHistory).ExecuteCommandAsync();
			}

			/// <summary>
			/// æåé¾é¡¹
			/// </summary>
			public class SplitChainItem
			{
			public Dt_SplitPackageRecord SplitRecord { get; set; }
			public string OriginalBarcode { get; set; }
			public string NewBarcode { get; set; }
			public decimal SplitQuantity { get; set; }
			}
			#region æ¥è¯¢æ¹æ³
			// è·åæªæ£éåè¡¨
			public async Task<List<Dt_OutStockLockInfo>> GetUnpickedList(string orderNo, string palletCode)
			{
			@@ -1266,186 +150,1936 @@

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

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

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

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

			_unitOfWorkManage.CommitTran();

			return WebResponseContent.Instance.OK($"åæ¶åæ£æåï¼æ¢å¤æ°éï¼{pickingRecord.PickQuantity}");
			}
			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);

			_unitOfWorkManage.CommitTran();


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

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

			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);
			}
			else if (actualQty == stockQuantity)
			{
			await HandleFullPicking(lockInfo, stockDetail, actualQty, result);
			}
			else
			{
			await HandlePartialPicking(lockInfo, stockDetail, actualQty, stockQuantity, result);
			}

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

			await UpdateOrderRelatedData(lockInfo.OrderDetailId, actualQty, lockInfo.OrderNo);

			_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;
			}
			else
			{
			throw new Exception($"åæ£åå°å¯¼è´å·²åºåºæ°é({newOverOutQuantity})è¶è¿è®¢åéæ±æ°é({currentOrderDetail.NeedOutQuantity})ï¼ä¸æ æ³èªå¨è°æ´");
			}
			}

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

			// æ£æ¥å¹¶æ´æ°è®¢åç¶æ
			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
			};

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

			#endregion

			#region åæ¶åæ£ç§ææ¹æ³

			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 currentStockDetail = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
			.Where(it => it.Barcode == pickingRecord.Barcode && it.StockId == pickingRecord.StockId)
			.FirstAsync();

			if (currentStockDetail != null &&
			(currentStockDetail.Status == StockStatusEmun.å¥åºç¡®è®¤.ObjToInt() \|\|
			currentStockDetail.Status == StockStatusEmun.å¥åºå®æ.ObjToInt()))
			{
			throw new Exception($"æ¡ç {pickingRecord.Barcode}å·²ç»ååºï¼æ æ³åæ¶åæ£");
			}
			// æ£æ¥åæ¶åæ°éä¸ä¼ä¸ºè´æ°
			decimal newOverOutQuantity = orderDetail.OverOutQuantity - cancelQty;
			decimal newPickedQty = orderDetail.PickedQty - cancelQty;

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

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

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

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

			// éæ°æ£æ¥è®¢åç¶æ
			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;
			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 = stockDetail.StockQuantity;
			stockDetail.Status = StockStatusEmun.åºåºéå®.ObjToInt();
			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();

			await UpdateOrderDetailOnCancel(pickingRecord.OrderDetailId, cancelQty);
			}

			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;

			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 = stockDetail.StockQuantity;
			stockDetail.Status = StockStatusEmun.åºåºéå®.ObjToInt();
			await _stockInfoDetailService.Db.Updateable(stockDetail).ExecuteCommandAsync();
			}
			}

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

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

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

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

			#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 (!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, 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;
			}

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

			}
			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)
			{
			await HandlePalletStockGoodsReturn(analysis.PalletStockGoods);
			}

			// å¤çæåè®°å½
			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)
			{
			_logger.LogInformation($"ååºæä½ï¼åç°{palletStockGoods.Count}ä¸ªåºåæç»éè¦ååºï¼çå¾AGVæ¬è¿");
			foreach (var stockGood in palletStockGoods)
			{
			_logger.LogInformation($"å¾ååºè´§ç© - æ¡ç : {stockGood.Barcode}, æ°é: {stockGood.StockQuantity}, å½åç¶æ: {stockGood.Status}");

			// æ¢å¤åºåç¶æ
			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)
			{
			_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)
			{
			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.ObjToInt(),
			PalletType = originalTask.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;
			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();

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



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

			private async Task HandleOrderCompletion(Dt_OutboundOrder outboundOrder, string orderNo)
			{
			// è°æ¨åºåºåéæ£åºåºä¸éè¦åé¦MES
			if (outboundOrder.OrderType == OutOrderTypeEnum.Allocate.ObjToInt() \|\|
			outboundOrder.OrderType == OutOrderTypeEnum.ReCheck.ObjToInt())
			{
			return;
			}

			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 => x.ReturnToMESStatus == 1)
			.Where(x => x.OrderNo == orderNo)
			.ExecuteCommandAsync();
			}
			}
			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.åºåºå®æ;
			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
			};

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

			// 2. åææçä¸çåºåè´§ç©
			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);
			}

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

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

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

			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,

			};

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

			#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
			};
			}
			}

			public class PickingResult
			{
			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 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 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;
			}
			#endregion
			}