ZhongRui/ALDbanyunxiangmu.git

			@@ -1,6 +1,7 @@
			ï»¿using Dm.filter;
			using MailKit.Search;
			using Microsoft.AspNetCore.Http;
			using Microsoft.AspNetCore.Mvc;
			using Microsoft.Extensions.Logging;
			using SqlSugar;
			using System;
			@@ -17,6 +18,7 @@
			using WIDESEA_Core.BaseServices;
			using WIDESEA_Core.Helper;
			using WIDESEA_DTO.Basic;
			using WIDESEA_DTO.Inbound;
			using WIDESEA_DTO.Outbound;
			using WIDESEA_IBasicService;
			using WIDESEA_IOutboundService;
			@@ -43,7 +45,8 @@
			private readonly ISplitPackageService _splitPackageService;
			private readonly IRepository<Dt_Task> _taskRepository;
			private readonly IESSApiService _eSSApiService;

			private readonly IInvokeMESService _invokeMESService;
			private readonly IDailySequenceService _dailySequenceService;

			private readonly ILogger<OutboundPickingService> _logger;

			@@ -61,7 +64,10 @@

			};

			public OutboundPickingService(IRepository<Dt_PickingRecord> BaseDal, IUnitOfWorkManage unitOfWorkManage, IStockInfoService stockInfoService, IStockService stockService, IOutStockLockInfoService outStockLockInfoService, IStockInfoDetailService stockInfoDetailService, ILocationInfoService locationInfoService, IOutboundOrderDetailService outboundOrderDetailService, ISplitPackageService splitPackageService, IOutboundOrderService outboundOrderService, IRepository<Dt_Task> taskRepository, IESSApiService eSSApiService, ILogger<OutboundPickingService> logger) : base(BaseDal)
			public OutboundPickingService(IRepository<Dt_PickingRecord> BaseDal, IUnitOfWorkManage unitOfWorkManage, IStockInfoService stockInfoService, IStockService stockService,
			IOutStockLockInfoService outStockLockInfoService, IStockInfoDetailService stockInfoDetailService, ILocationInfoService locationInfoService,
			IOutboundOrderDetailService outboundOrderDetailService, ISplitPackageService splitPackageService, IOutboundOrderService outboundOrderService,
			IRepository<Dt_Task> taskRepository, IESSApiService eSSApiService, ILogger<OutboundPickingService> logger, IInvokeMESService invokeMESService, IDailySequenceService dailySequenceService) : base(BaseDal)
			{
			_unitOfWorkManage = unitOfWorkManage;
			_stockInfoService = stockInfoService;
			@@ -75,6 +81,8 @@
			_taskRepository = taskRepository;
			_eSSApiService = eSSApiService;
			_logger = logger;
			_invokeMESService = invokeMESService;
			_dailySequenceService = dailySequenceService;
			}


			@@ -139,212 +147,19 @@
			}
			}

			/// <summary>
			/// æ«ç æ£éç¡®è®¤
			/// </summary>
			public async Task<WebResponseContent> ConfirmPicking(PickingConfirmRequest request)
			{
			try
			{
			_unitOfWorkManage.BeginTran();

			// 1. éªè¯æ¡ç æææ§
			var stockDetail = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
			.Where(x => x.Barcode == request.Barcode && x.MaterielCode == request.MaterielCode)
			.FirstAsync();

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

			// 2. æ£æ¥åºåå¯ç¨æ°é
			decimal availableQuantity = stockDetail.StockQuantity - stockDetail.OutboundQuantity;
			if (request.PickQuantity > availableQuantity)
			return WebResponseContent.Instance.Error($"æ£éæ°éè¶è¿å¯ç¨åºåï¼å¯ç¨æ°éï¼{availableQuantity}");

			// 3. æ¥æ¾ç¸å³çåºåºéå®ä¿¡æ¯ï¼æ¯ææååçæ°æ¡ç ï¼
			var lockInfo = await FindLockInfoByBarcode(request.OrderDetailId, request.Barcode, request.MaterielCode);

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

			// 4. æ£æ¥éå®æ°é
			decimal remainingLockQuantity = lockInfo.AssignQuantity - lockInfo.PickedQty;
			if (request.PickQuantity > remainingLockQuantity)
			return WebResponseContent.Instance.Error($"æ£éæ°éè¶è¿éå®æ°éï¼å©ä½å¯æ£éï¼{remainingLockQuantity}");

			// 5. æ´æ°éå®ä¿¡æ¯çå·²æ£éæ°é
			lockInfo.PickedQty += request.PickQuantity;
			await _outStockLockInfoService.Db.Updateable(lockInfo).ExecuteCommandAsync();

			// 6. æ´æ°åºååºåºæ°é - å®éåå°åºå
			stockDetail.OutboundQuantity += request.PickQuantity;
			await _stockInfoService.Db.Updateable(stockDetail).ExecuteCommandAsync();

			// 7. æ´æ°åºåºåæç»
			var orderDetail = await _outboundOrderDetailService.Db.Queryable<Dt_OutboundOrderDetail>()
			.Where(x => x.Id == request.OrderDetailId)
			.FirstAsync();

			orderDetail.OverOutQuantity += request.PickQuantity;
			orderDetail.LockQuantity -= request.PickQuantity;

			// æ£æ¥æ¯å¦å®æåºåº
			if (Math.Abs(orderDetail.OverOutQuantity - orderDetail.OrderQuantity) < 0.001m)
			{
			orderDetail.OrderDetailStatus = (int)OrderDetailStatusEnum.Over;
			orderDetail.LockQuantity = 0;

			// æ´æ°ç¸å³çéå®ä¿¡æ¯ç¶æä¸ºå·²åºåº
			var relatedLockInfos = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
			.Where(x => x.OrderDetailId == request.OrderDetailId &&
			x.Status == (int)OutLockStockStatusEnum.åºåºä¸)
			.ToListAsync();

			foreach (var relatedLock in relatedLockInfos)
			{
			relatedLock.Status = (int)OutLockStockStatusEnum.å·²åºåº;
			}
			await _outStockLockInfoService.Db.Updateable(relatedLockInfos).ExecuteCommandAsync();
			}

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

			// 8. è®°å½æ£éåå²
			var pickHistory = new Dt_PickingRecord
			{
			OrderDetailId = request.OrderDetailId,
			Barcode = request.Barcode,
			PickQuantity = request.PickQuantity,
			PickTime = DateTime.Now,

			LocationCode = request.LocationCode,
			StockId = stockDetail.StockId
			};
			await Db.Insertable(pickHistory).ExecuteCommandAsync();

			_unitOfWorkManage.CommitTran();

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

			public async Task<WebResponseContent> ConfirmPicking(string orderNo, string palletCode, string barcode)
			{
			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)
			.FirstAsync();

			if (lockInfo == null)
			{
			var splitBarcode = await _splitPackageService.Db.Queryable<Dt_SplitPackageRecord>()
			.Where(it => it.NewBarcode == barcode && it.Status == 1)
			.FirstAsync();

			if (splitBarcode != null)
			{
			// éè¿æåæ¡ç è®°å½æ¾å°å¯¹åºçåºåºéå®è®°å½
			lockInfo = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
			.Where(it => it.ParentLockId == splitBarcode.OutStockLockInfoId)
			.FirstAsync();

			if (lockInfo == null)
			throw new Exception($"æªæ¾å°æåæ¡ç {barcode}å¯¹åºçåºåºéå®è®°å½");
			}
			else
			{
			throw new Exception($"æ¡ç {barcode}ä¸å±äºæç{palletCode}æä¸åå¨å¾åæ£è®°å½");
			}

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

			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;

			// 4. æ´æ°åºå
			stockDetail.StockQuantity -= actualQty;
			stockDetail.OutboundQuantity -= actualQty;
			await _stockInfoDetailService.Db.Updateable(stockDetail).ExecuteCommandAsync();

			lockInfo.PickedQty += actualQty;
			lockInfo.Status = (int)OutLockStockStatusEnum.æ£éå®æ;
			await _outStockLockInfoService.Db.Updateable(lockInfo).ExecuteCommandAsync();

			var splitBarcodeRecord = await _splitPackageService.Db.Queryable<Dt_SplitPackageRecord>()
			.Where(it => it.NewBarcode == barcode)
			.FirstAsync();

			if (splitBarcodeRecord != null)
			{
			splitBarcodeRecord.Status = 2;
			await _splitPackageService.Db.Updateable(splitBarcodeRecord).ExecuteCommandAsync();
			}

			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();
			// 9. è®°å½æ£éåå²
			var pickingHistory = new Dt_PickingRecord
			{
			FactoryArea = lockInfo.FactoryArea,
			TaskNo = task?.TaskNum ?? 0,
			LocationCode = task?.SourceAddress ?? "",
			StockId = stockDetail.Id,
			OrderNo = orderNo,
			OrderDetailId = lockInfo.OrderDetailId,
			PalletCode = palletCode,
			Barcode = barcode,
			MaterielCode = lockInfo.MaterielCode,
			PickQuantity = lockInfo.AssignQuantity,
			PickTime = DateTime.Now,
			Operator = App.User.UserName,
			OutStockLockId = lockInfo.Id
			};
			await Db.Insertable(pickingHistory).ExecuteCommandAsync();

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

			}
			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();
			//var orderDetails = await _stockInfoDetailService.Db.Queryable<Dt_OutboundOrderDetail>()
			// .Where(x => x.OrderId == orderNo.ObjToInt())
			// .ToListAsync();

			bool allCompleted = true;
			foreach (var detail in orderDetails)
			@@ -358,347 +173,1291 @@

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

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


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

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

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

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

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

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

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

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

			}
			}

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

			/// <summary>
			/// ååºæä½
			/// </summary>
			//public async Task<WebResponseContent> ReturnRemaining(string orderNo, string palletCode, string reason)
			//{
			// try
			// {
			// // 1. è·åæææªåæ£çåºåºéå®è®°å½ï¼åæ¬æåäº§ççè®°å½
			// var remainingLocks = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
			// .Where(it => it.OrderNo == orderNo && it.Status == 1)
			// .ToListAsync();
			// 1. éªè¯è¾å¥åæ°
			if (string.IsNullOrEmpty(orderNo) \|\| string.IsNullOrEmpty(palletCode) \|\| string.IsNullOrEmpty(barcode))
			{
			throw new Exception("è®¢åå·ãæçç åæ¡ç ä¸è½ä¸ºç©º");
			}

			// if (!remainingLocks.Any())
			// {
			// return WebResponseContent.Instance.Error("æ²¡æéè¦ååºçå©ä½è´§ç©");
			// }
			// var tasks = new List<Dt_Task>();
			// // ææçåç»
			// var palletGroups = remainingLocks.GroupBy(x => x.PalletCode);
			// //æ¥è¯¢ä»»å¡è¡¨
			// var task = _taskRepository.QueryData(x => x.TaskNum == remainingLocks.First().TaskNum).FirstOrDefault();
			// foreach (var group in palletGroups)
			// {
			// if (group.Key == palletCode)
			// {
			// var totalReturnQty = group.Sum(x => x.AssignQuantity - x.PickedQty);
			// 2. æ¥æ¾åºåºéå®ä¿¡æ¯
			var lockInfo = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
			.Where(it => it.OrderNo == orderNo &&
			it.Status == (int)OutLockStockStatusEnum.åºåºä¸ &&
			it.PalletCode == palletCode &&
			it.CurrentBarcode == barcode &&
			it.AssignQuantity > it.PickedQty)
			.FirstAsync();

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

			// // åéæ°è´§ä½
			// var newLocation = _locationInfoService.AssignLocation();
			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();

			// // æ´æ°åºåºéå®è®°å½ç¶æ
			// var lockIds = group.Where(x => x.PalletCode == palletCode).Select(x => x.Id).ToList();
			// await _outStockLockInfoService.Db.Updateable<Dt_OutStockLockInfo>()
			// .SetColumns(it => new Dt_OutStockLockInfo { Status = OutLockStockStatusEnum.ååºä¸.ObjToInt() })
			// .Where(it => lockIds.Contains(it.Id))
			// .ExecuteCommandAsync();
			if (completedLockInfo != null)
			throw new Exception($"æ¡ç {barcode}å·²ç»å®æåæ£ï¼ä¸è½éå¤åæ£");
			else
			throw new Exception($"æ¡ç {barcode}ä¸å±äºæç{palletCode}æä¸åå¨å¾åæ£è®°å½");
			}
			}

			// // æ´æ°æåæ¡ç è®°å½ç¶æ
			// var splitBarcodes = await _splitPackageService.Db.Queryable<Dt_SplitPackageRecord>()
			// .Where(it => lockIds.Contains(it.OutStockLockInfoId))
			// .ToListAsync();
			if (lockInfo.PalletCode != palletCode)
			throw new Exception($"æ¡ç {barcode}ä¸å±äºæç{palletCode}");

			// foreach (var splitBarcode in splitBarcodes)
			// {
			// splitBarcode.Status = 3;
			// await _splitPackageService.Db.Updateable(splitBarcode).ExecuteCommandAsync();
			// }
			// æ£æ¥æ£éåå²ï¼é²æ¢éå¤åæ£
			var existingPicking = await Db.Queryable<Dt_PickingRecord>()
			.Where(x => x.Barcode == barcode &&
			x.OrderNo == orderNo &&
			x.PalletCode == palletCode &&
			x.OutStockLockId == lockInfo.Id)
			.FirstAsync();

			// foreach (var lockInfo in group)
			// {
			// if (lockInfo.PalletCode == palletCode)
			// {
			// decimal returnQty = lockInfo.AssignQuantity - lockInfo.PickedQty;
			if (existingPicking != null)
			{
			throw new Exception($"æ¡ç {barcode}å·²ç»åæ£è¿ï¼ä¸è½éå¤åæ£");
			}

			// // æ£æ¥åºåè®°å½æ¯å¦åå¨
			// var existingStock = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
			// .Where(it => it.Barcode == lockInfo.CurrentBarcode && it.StockId == lockInfo.StockId)
			// .FirstAsync();
			// è·åè®¢åæç»å¹¶æ£æ¥æ°ééå¶
			var orderDetail = await _outboundOrderDetailService.Db.Queryable<Dt_OutboundOrderDetail>()
			.FirstAsync(x => x.Id == lockInfo.OrderDetailId);

			// if (existingStock != null)
			// {
			// // åºåè®°å½åå¨ï¼æ¢å¤éå®æ°é
			// await _stockInfoDetailService.Db.Updateable<Dt_StockInfoDetail>()
			// .SetColumns(it => new Dt_StockInfoDetail
			// {
			// OutboundQuantity = it.OutboundQuantity - returnQty
			// })
			// .Where(it => it.Barcode == lockInfo.CurrentBarcode && it.StockId == lockInfo.StockId)
			// .ExecuteCommandAsync();
			// }
			// else
			// {
			// // åºåè®°å½ä¸åå¨ï¼å¯è½æ¯æåäº§ççæ°æ¡ç ï¼ï¼åå»ºæ°çåºåè®°å½
			// var newStockDetail = new Dt_StockInfoDetail
			// {
			// StockId = lockInfo.StockId,
			// MaterielCode = lockInfo.MaterielCode,
			// OrderNo = lockInfo.OrderNo,
			// BatchNo = lockInfo.BatchNo,
			// StockQuantity = returnQty, // å®éåºåæ°é
			// OutboundQuantity = 0, // ååºåä¸åéå®
			// Barcode = lockInfo.CurrentBarcode,
			// InboundOrderRowNo = "0",
			// Status = StockStatusEmun.å¥åºç¡®è®¤.ObjToInt(),
			if (orderDetail == null)
			throw new Exception($"æªæ¾å°è®¢åæç»ï¼ID: {lockInfo.OrderDetailId}");

			// };
			// await _stockInfoDetailService.Db.Insertable(newStockDetail).ExecuteCommandAsync();
			// }
			// }
			// }
			// å³é®ä¿®å¤ï¼æ£æ¥ç´¯è®¡æ£éæ°éæ¯å¦ä¼è¶è¿è®¢åæ°é
			decimal actualQty = lockInfo.AssignQuantity - lockInfo.PickedQty;
			decimal remainingOrderQty = orderDetail.NeedOutQuantity - orderDetail.OverOutQuantity;

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

			// Dt_Task newtask = new()
			// {
			// CurrentAddress = stations[task.TargetAddress],
			// Grade = 0,
			// PalletCode = palletCode,
			// NextAddress = "",
			// OrderNo= task.OrderNo,
			// Roadway = newLocation.RoadwayNo,
			// SourceAddress = stations[task.TargetAddress],
			// TargetAddress = newLocation.LocationCode,
			// TaskStatus = TaskStatusEnum.New.ObjToInt(),
			// TaskType = TaskTypeEnum.InPick.ObjToInt(),
			// // TaskNum = BaseDal.GetTaskNum(nameof(SequenceEnum.SeqTaskNum)),
			// PalletType = task.PalletType,
			// WarehouseId = task.WarehouseId,
			// };
			// tasks.Add(newtask);
			if (actualQty <= 0)
			{
			throw new Exception($"è®¢å{orderNo}çéæ±æ°éå·²æ»¡è¶³ï¼æ æ³ç»§ç»åæ£");
			}

			// }
			// }
			// try
			// {
			// await _taskRepository.Db.Insertable(tasks).ExecuteCommandAsync();
			// //å é¤ åºåºç task
			_logger.LogWarning($"è°æ´åæ£æ°éï¼ååé{lockInfo.AssignQuantity - lockInfo.PickedQty}ï¼è°æ´ä¸º{actualQty}ï¼è®¢åéæ±{orderDetail.NeedOutQuantity}ï¼å·²åºåº{orderDetail.OverOutQuantity}");
			}

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

			// //ç» ess æµå¨ä¿¡å· ååå»ºä»»å¡
			if (stockDetail == null)
			return WebResponseContent.Instance.Error("æ æçæ¡ç æç©æç¼ç ");

			decimal stockQuantity = stockDetail.StockQuantity;

			// }
			// catch (Exception ex)
			// {
			List<SplitResult> splitResults = new List<SplitResult>();
			Dt_OutStockLockInfo finalLockInfo = lockInfo;
			var finalBarcode = barcode;
			var finalStockId = stockDetail.Id;
			decimal actualPickedQty = actualQty;

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

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

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

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

			// return WebResponseContent.Instance.OK();
			// }
			// catch (Exception ex)
			// {
			// return WebResponseContent.Instance.Error($"ååºæä½å¤±è´¥: {ex.Message}");
			// }
			//}
			var newLockId = await _outStockLockInfoService.Db.Insertable(newLockInfo).ExecuteReturnIdentityAsync();
			newLockInfo.Id = newLockId;

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

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

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

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

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

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

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

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

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

			actualPickedQty = stockOutQty;
			}

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

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

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

			await CheckAndUpdateOrderStatus(orderNo);

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

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

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

			_unitOfWorkManage.CommitTran();

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

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

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

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

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

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

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

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

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

			decimal cancelQty = pickingRecord.PickQuantity;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

			public async Task<WebResponseContent> ReturnRemaining(string orderNo, string palletCode, string reason)
			{
			try
			{
			// 1. è·åæææªåæ£çåºåºéå®è®°å½ï¼åæ¬æåäº§ççè®°å½
			var remainingLocks = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
			.Where(it => it.OrderNo == orderNo && it.Status == 1)
			.ToListAsync();

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

			// 2. æ£æ¥æçä¸æ¯å¦æå¶ä»éåºåºè´§ç©ï¼åºåè´§ç©ï¼
			var palletStockGoods = 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) // æªå®å¨åºåºç
			.ToListAsync();

			// 3. å¦ææ²¡æéè¦ååºçè´§ç©ï¼æ¢æ æªåæ£åºåºè´§ç©ï¼ä¹æ å¶ä»åºåè´§ç©ï¼
			if (!remainingLocks.Any() && !palletStockGoods.Any())
			_unitOfWorkManage.BeginTran();

			if (string.IsNullOrEmpty(orderNo) \|\| string.IsNullOrEmpty(palletCode))
			{
			return WebResponseContent.Instance.Error("æ²¡æéè¦ååºçå©ä½è´§ç©");
			}
			return WebResponseContent.Instance.Error("è®¢åå·åæçç ä¸è½ä¸ºç©º");
			}
			var stockInfo = await _stockInfoService.Db.Queryable<Dt_StockInfo>()
			.FirstAsync(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 (stockInfo == null)
			{
			return WebResponseContent.Instance.Error($"æªæ¾å°æç {palletCode} å¯¹åºçåºåä¿¡æ¯");
			}
			var task = await GetCurrentTask(orderNo, palletCode);
			if (task == null)
			{
			return WebResponseContent.Instance.Error("æªæ¾å°å¯¹åºçä»»å¡ä¿¡æ¯");
			}
			var firstlocation = _locationInfoService.Db.Queryable<Dt_LocationInfo>().First(x => x.LocationCode == task.SourceAddress);
			decimal totalReturnQty = 0;
			var hasRemainingLocks = remainingLocks.Any(x => x.PalletCode == palletCode);

			// æåµ1ï¼å¤çæªåæ£çåºåºéå®è®°å½
			if (hasRemainingLocks)
			// åæéè¦ååºçè´§ç©
			var returnAnalysis = await AnalyzeReturnItems(orderNo, palletCode, stockInfo.Id);

			if (!returnAnalysis.HasItemsToReturn)
			{
			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 = OutLockStockStatusEnum.ååºä¸.ObjToInt() })
			.Where(it => lockIds.Contains(it.Id))
			.ExecuteCommandAsync();

			// æ´æ°æåæ¡ç è®°å½ç¶æ
			var splitBarcodes = await _splitPackageService.Db.Queryable<Dt_SplitPackageRecord>()
			.Where(it => lockIds.Contains(it.OutStockLockInfoId))
			.ToListAsync();

			foreach (var splitBarcode in splitBarcodes)
			{
			splitBarcode.Status = 3;
			await _splitPackageService.Db.Updateable(splitBarcode).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)
			{
			// åºåè®°å½åå¨ï¼æ¢å¤éå®æ°é
			await _stockInfoDetailService.Db.Updateable<Dt_StockInfoDetail>()
			.SetColumns(it => new Dt_StockInfoDetail
			{
			OutboundQuantity = it.OutboundQuantity - returnQty
			})
			.Where(it => it.Barcode == lockInfo.CurrentBarcode && it.StockId == lockInfo.StockId)
			.ExecuteCommandAsync();
			}
			else
			{
			// åºåè®°å½ä¸åå¨ï¼å¯è½æ¯æåäº§ççæ°æ¡ç ï¼ï¼åå»ºæ°çåºåè®°å½
			var newStockDetail = new Dt_StockInfoDetail
			{
			StockId = lockInfo.StockId,
			MaterielCode = lockInfo.MaterielCode,
			OrderNo = lockInfo.OrderNo,
			BatchNo = lockInfo.BatchNo,
			StockQuantity = returnQty,
			OutboundQuantity = 0,
			Barcode = lockInfo.CurrentBarcode,
			InboundOrderRowNo = "0",
			Status = StockStatusEmun.å¥åºç¡®è®¤.ObjToInt(),

			};
			await _stockInfoDetailService.Db.Insertable(newStockDetail).ExecuteCommandAsync();
			}
			}

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

			// æåµ2ï¼åºåºè´§ç©å·²åæ£å®ï¼ä½æçä¸è¿æå¶ä»åºåè´§ç©éè¦ååº
			if (!hasRemainingLocks && palletStockGoods.Any())
			{
			// åéæ°è´§ä½
			var newLocation = _locationInfoService.AssignLocation(firstlocation.LocationType);
			// æ§è¡ååºæä½
			await ExecuteReturnOperations(orderNo, palletCode, stockInfo, task, returnAnalysis);

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

			totalReturnQty = palletStockGoods.Sum(x => x.StockQuantity - x.OutboundQuantity);
			}
			_unitOfWorkManage.CommitTran();

			// ä¿åä»»å¡
			if (tasks.Any())
			{
			try
			{
			await _taskRepository.Db.Insertable(tasks).ExecuteCommandAsync();
			// æ´æ°è®¢åç¶æ
			await UpdateOrderStatusForReturn(orderNo);

			// ç» ESS æµå¨ä¿¡å·ååå»ºä»»å¡
			try
			{
			var result = await _eSSApiService.MoveContainerAsync(new WIDESEA_DTO.Basic.MoveContainerRequest
			{
			slotCode = movestations[task.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(task.TargetAddress) ?? "",
			toStationCode = "",
			toLocationCode = tasks.First().TargetAddress,
			deadline = 0, storageTag = ""
			}
			}
			}
			};

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

			var resulttask = await _eSSApiService.CreateTaskAsync(esstask);

			_logger.LogInformation("ReturnRemaining åå»ºä»»å¡è¿å: " + resulttask);
			}
			}
			catch (Exception ex)
			{
			_logger.LogInformation("ReturnRemaining åå»ºä»»å¡è¿å catch err: " + ex.Message);

			}


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

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

			#region è®¢åç¶æ

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

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

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

			if (outboundOrder == null) return;

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

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

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

			}
			}

			#endregion

			#region Private Methods

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

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

			return task;
			}

			private async Task<ReturnAnalysisResult> AnalyzeReturnItems(string orderNo, string palletCode, int stockId)
			{
			var result = new ReturnAnalysisResult();

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

			if (remainingLocks.Any())
			{
			result.HasRemainingLocks = true;
			result.RemainingLocks = remainingLocks;
			result.RemainingLocksReturnQty = remainingLocks.Sum(x => x.AssignQuantity - x.PickedQty);
			}

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


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

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

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

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

			return result;
			}

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

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

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

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

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

			return totalQty;
			}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

			};

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

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

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

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

			private async Task SendESSCommands(string palletCode, Dt_Task originalTask, Dt_Task returnTask)
			{
			try
			{
			// 1. åéæµå¨ä¿¡å·
			var moveResult = await _eSSApiService.MoveContainerAsync(new WIDESEA_DTO.Basic.MoveContainerRequest
			{
			slotCode = movestations[originalTask.TargetAddress],
			containerCode = palletCode
			});

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

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

			#endregion



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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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



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

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

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

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

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

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

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

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

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

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

			// totalReturnQty += splitReturnQty;

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

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

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


			// }

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

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

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

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

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

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

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


			/// <summary>
			/// åå»ºååºä»»å¡
			@@ -753,69 +1512,227 @@
			return outboundFinished && hasRemainingGoods;
			}

			// åæ¶æ£éåè½
			public async Task<WebResponseContent> CancelPicking(string orderNo, string palletCode, string barcode)

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

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

			while (!string.IsNullOrEmpty(current) && maxDepth > 0)
			{
			_unitOfWorkManage.BeginTran();
			// æ¥æ¾æ£éè®°å½
			var outStockInfo = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
			.Where(x => x.OrderNo == orderNo &&
			x.PalletCode == palletCode &&
			x.CurrentBarcode == barcode &&
			x.Status == 2)
			.FirstAsync();
			maxDepth--;

			if (outStockInfo == null)
			return WebResponseContent.Instance.Error("æªæ¾å°å·²æ£éè®°å½");
			if (visited.Contains(current))
			{
			_logger.LogWarning($"æ£æµå°å¾ªç¯å¼ç¨å¨æåé¾ä¸: {current}");
			break;
			}

			// è¿ååºåºè¯¦æç¶æ
			outStockInfo.PickedQty = 0;
			outStockInfo.Status = 1;
			await _outStockLockInfoService.Db.Updateable(outStockInfo).ExecuteCommandAsync();
			visited.Add(current);

			//// è¿ååºååºåºæ°é
			//await _stockInfoDetailService.Db.Updateable<Dt_StockInfoDetail>()
			// .SetColumns(x => x.OutboundQuantity == x.OutboundQuantity - outStockInfo.AssignQuantity)
			// .Where(x => x.Barcode == barcode)
			// .ExecuteCommandAsync();

			// è¿ååºåºåæç»
			var orderDetail = await _outboundOrderDetailService.Db.Queryable<Dt_OutboundOrderDetail>()
			.Where(x => x.Id == outStockInfo.OrderDetailId)
			var splitRecord = await _splitPackageService.Db.Queryable<Dt_SplitPackageRecord>()
			.Where(it => it.NewBarcode == current && !it.IsReverted)
			.FirstAsync();

			orderDetail.OverOutQuantity -= outStockInfo.AssignQuantity;
			await _outboundOrderDetailService.Db.Updateable(orderDetail).ExecuteCommandAsync();
			if (splitRecord == null)
			break;

			// å é¤æ£éåå²
			await Db.Deleteable<Dt_PickingRecord>()
			.Where(x => x.OutStockLockId == outStockInfo.Id)
			.ExecuteCommandAsync();
			// éªè¯æåè®°å½çå®æ´æ§
			if (string.IsNullOrEmpty(splitRecord.OriginalBarcode))
			{
			_logger.LogError($"æåè®°å½ {splitRecord.Id} ç¼ºå°åå§æ¡ç ");
			break;
			}

			_unitOfWorkManage.CommitTran();
			return WebResponseContent.Instance.OK("åæ¶æ£éæå");
			var item = new SplitChainItem
			{
			SplitRecord = splitRecord,
			OriginalBarcode = splitRecord.OriginalBarcode,
			NewBarcode = splitRecord.NewBarcode,
			SplitQuantity = splitRecord.SplitQty
			};

			chain.Add(item);

			current = splitRecord.OriginalBarcode;
			}
			catch (Exception ex)

			if (maxDepth <= 0)
			{
			return WebResponseContent.Instance.Error($"åæ¶æ£éå¤±è´¥ï¼{ex.Message}");
			_logger.LogWarning($"æåé¾è¿½æº¯è¾¾å°æå¤§æ·±åº¦: {currentBarcode}");
			}

			chain.Reverse();
			return chain;
			}
			/// <summary>
			/// æ ¹æ®æ¡ç æ¥æ¾éå®ä¿¡æ¯
			/// å¤çæåé¾çåæ¶åæ£
			/// </summary>
			private async Task<Dt_OutStockLockInfo> FindLockInfoByBarcode(int orderDetailId, string barcode, string materielCode)
			private async Task HandleSplitChainCancel(string orderNo, string palletCode, string barcode,
			decimal cancelQty, Dt_OutStockLockInfo lockInfo, Dt_PickingRecord pickingRecord, List<SplitChainItem> splitChain)
			{
			return await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
			.Where(x => x.OrderDetailId == orderDetailId &&
			x.MaterielCode == materielCode &&
			x.CurrentBarcode == barcode &&
			x.Status == (int)OutLockStockStatusEnum.åºåºä¸ &&
			x.AssignQuantity > x.PickedQty)
			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();
			}
			}




			// è·åæªæ£éåè¡¨
			public async Task<List<Dt_OutStockLockInfo>> GetUnpickedList(string orderNo, string palletCode)
			@@ -896,88 +1813,6 @@
			.ToListAsync();
			}

			public async Task GetPalletPickingSummary(string orderNo, string palletCode)
			{
			var summary = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
			.Where(x => x.OrderNo == orderNo && x.PalletCode == palletCode)
			.GroupBy(x => new { x.PalletCode, x.Status })
			.Select(x => new
			{
			PalletCode = x.PalletCode,
			Status = x.Status,
			TotalAssignQty = SqlFunc.AggregateSum(x.AssignQuantity),
			TotalPickedQty = SqlFunc.AggregateSum(x.PickedQty)
			})
			.ToListAsync();

			// return summary;
			}



			/// <summary>
			/// æ¤éæ£é
			/// </summary>
			public async Task<WebResponseContent> CancelPicking(CancelPickingRequest request)
			{
			// å®ç°æ¤éæ£éçé»è¾ï¼éè¦ï¼
			// 1. æ¢å¤åºååºåºæ°é
			// 2. æ¢å¤éå®ä¿¡æ¯çå·²æ£éæ°é
			// 3. æ¢å¤åºåºåæç»çå·²åºæ°éåéå®æ°é
			// 4. å é¤ææ è®°æ£éåå²è®°å½
			// æ³¨æï¼è¿ééè¦äºå¡å¤ç
			try
			{
			_unitOfWorkManage.BeginTran();

			var pickHistory = await Db.Queryable<Dt_PickingRecord>()
			.Where(x => x.Id == request.PickingHistoryId)
			.FirstAsync();

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

			// æ¢å¤åºå
			var stockDetail = await _stockInfoService.Db.Queryable<Dt_StockInfoDetail>()
			.Where(x => x.Barcode == pickHistory.Barcode && x.StockId == pickHistory.StockId)
			.FirstAsync();
			if (stockDetail != null)
			{
			stockDetail.OutboundQuantity -= pickHistory.PickQuantity;
			await _stockInfoService.Db.Updateable(stockDetail).ExecuteCommandAsync();
			}
			// æ¢å¤éå®ä¿¡æ¯
			var lockInfo = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
			.Where(x => x.OrderDetailId == pickHistory.OrderDetailId && x.StockId == pickHistory.StockId)
			.FirstAsync();
			lockInfo.PickedQty -= pickHistory.PickQuantity;
			await _outStockLockInfoService.Db.Updateable(lockInfo).ExecuteCommandAsync();

			// æ¢å¤åºåºåæç»
			var orderDetail = await _outboundOrderDetailService.Db.Queryable<Dt_OutboundOrderDetail>()
			.Where(x => x.Id == pickHistory.OrderDetailId)
			.FirstAsync();
			orderDetail.OverOutQuantity -= pickHistory.PickQuantity;
			orderDetail.LockQuantity += pickHistory.PickQuantity;
			if (orderDetail.OverOutQuantity < orderDetail.OrderQuantity)
			{
			orderDetail.OrderDetailStatus = orderDetail.LockQuantity > 0 ?
			(int)OrderDetailStatusEnum.Outbound : (int)OrderDetailStatusEnum.AssignOverPartial;
			}
			await _outboundOrderDetailService.Db.Updateable(orderDetail).ExecuteCommandAsync();

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

			_unitOfWorkManage.CommitTran();
			return WebResponseContent.Instance.OK("æ¤éæå");
			}
			catch (Exception ex)
			{
			_unitOfWorkManage.RollbackTran();
			return WebResponseContent.Instance.Error($"æ¤éå¤±è´¥: {ex.Message}");
			}
			}

			/// <summary>
			/// è·åæççåºåºç¶æä¿¡æ¯
			@@ -1142,4 +1977,33 @@
			}
			}


			#region è¿å
			/// <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; }
			}
			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>();
			}

			#endregion

			}