ZhongRui/ALDbanyunxiangmu.git

			@@ -1,29 +1,41 @@
			ï»¿using Dm.filter;
			using MailKit.Search;
			using Microsoft.AspNetCore.Http;
			using Microsoft.AspNetCore.Mvc;
			ï»¿using MailKit.Search;
			using Microsoft.Extensions.Logging;
			using Microsoft.IdentityModel.Tokens;
			using Newtonsoft.Json.Serialization;
			using Newtonsoft.Json;
			using SqlSugar;
			using System;
			using System.Collections.Generic;
			using System.Linq;
			using System.Text;
			using System.Threading.Tasks;
			using WIDESEA_Common.LocationEnum;
			using WIDESEA_BasicService;
			using WIDESEA_Common.CommonEnum;
			using WIDESEA_Common.OrderEnum;
			using WIDESEA_Common.StockEnum;
			using WIDESEA_Common.TaskEnum;
			using WIDESEA_Core;
			using WIDESEA_Core.BaseRepository;
			using WIDESEA_Core.BaseServices;
			using WIDESEA_Core.Enums;
			using WIDESEA_Core.Helper;
			using WIDESEA_Core.Utilities;
			using WIDESEA_DTO.Basic;
			using WIDESEA_DTO.Inbound;
			using WIDESEA_DTO.Outbound;
			using WIDESEA_DTO.ReturnMES;
			using WIDESEA_IAllocateService;
			using WIDESEA_IBasicService;
			using WIDESEA_ICheckService;
			using WIDESEA_IInboundService;
			using WIDESEA_IOutboundService;
			using WIDESEA_IStockService;
			using WIDESEA_ITaskInfoService;
			using WIDESEA_Model.Models;
			using WIDESEA_Model.Models.Basic;
			using WIDESEA_Model.Models.Check;
			using WIDESEA_Model.Models.Outbound;
			using Org.BouncyCastle.Asn1.Ocsp;
			using WIDESEA_BasicService.MESOperation;
			using WIDESEA_Core.Util;
			using WIDESEA_DTO.Allocate;
			using OfficeOpenXml.FormulaParsing.Excel.Functions.DateTime;
			using WIDESEA_IRecordService;

			namespace WIDESEA_OutboundService
			{
			@@ -32,6 +44,7 @@
			/// </summary>
			public class OutboundPickingService : ServiceBase<Dt_PickingRecord, IRepository<Dt_PickingRecord>>, IOutboundPickingService
			{
			#region æé å½æ°
			private readonly IUnitOfWorkManage _unitOfWorkManage;
			public IRepository<Dt_PickingRecord> Repository => BaseDal;

			@@ -47,8 +60,20 @@
			private readonly IESSApiService _eSSApiService;
			private readonly IInvokeMESService _invokeMESService;
			private readonly IDailySequenceService _dailySequenceService;

			private readonly IAllocateService _allocateService;
			private readonly IRepository<Dt_InboundOrder> _inboundOrderRepository;
			private readonly IInboundOrderDetailService _inboundOrderDetailService;
			private readonly IRepository<Dt_WarehouseArea> _warehouseAreaRepository;
			private readonly IReCheckOrderService _reCheckOrderService;
			private readonly ITask_HtyService _task_HtyService;
			private readonly ILogger<OutboundPickingService> _logger;
			private readonly IRepository<Dt_InterfaceLog> _interfaceLog;
			private readonly IInboundService _inboundService;
			private readonly IFeedbackMesService _feedbackMesService;
			private readonly HttpClientHelper _httpClientHelper;
			private readonly IRepository<Dt_MesReturnRecord> _mesReturnRecord;
			private readonly IStockQuantityChangeRecordService _stockQuantityChangeRecordService;
			private readonly IInboundOrderService _inboundOrderService;

			private Dictionary<string, string> stations = new Dictionary<string, string>
			{
			@@ -67,7 +92,7 @@
			public OutboundPickingService(IRepository<Dt_PickingRecord> BaseDal, IUnitOfWorkManage unitOfWorkManage, IStockInfoService stockInfoService, IStockService stockService,
			IOutStockLockInfoService outStockLockInfoService, IStockInfoDetailService stockInfoDetailService, ILocationInfoService locationInfoService,
			IOutboundOrderDetailService outboundOrderDetailService, ISplitPackageService splitPackageService, IOutboundOrderService outboundOrderService,
			IRepository<Dt_Task> taskRepository, IESSApiService eSSApiService, ILogger<OutboundPickingService> logger, IInvokeMESService invokeMESService, IDailySequenceService dailySequenceService) : base(BaseDal)
			IRepository<Dt_Task> taskRepository, IESSApiService eSSApiService, ILogger<OutboundPickingService> logger, IInvokeMESService invokeMESService, IDailySequenceService dailySequenceService, IAllocateService allocateService, IRepository<Dt_InboundOrder> inboundOrderRepository, IInboundOrderDetailService inboundOrderDetailService, IRepository<Dt_WarehouseArea> warehouseAreaRepository, IReCheckOrderService reCheckOrderService, ITask_HtyService task_HtyService, IRepository<Dt_InterfaceLog> interfaceLog, IInboundService inboundService, IFeedbackMesService feedbackMesService, HttpClientHelper httpClientHelper, IRepository<Dt_MesReturnRecord> mesReturnRecord,IStockQuantityChangeRecordService stockQuantityChangeRecordService,IInboundOrderService inboundOrderService) : base(BaseDal)
			{
			_unitOfWorkManage = unitOfWorkManage;
			_stockInfoService = stockInfoService;
			@@ -83,8 +108,25 @@
			_logger = logger;
			_invokeMESService = invokeMESService;
			_dailySequenceService = dailySequenceService;
			_allocateService = allocateService;
			_inboundOrderRepository = inboundOrderRepository;
			_inboundOrderDetailService = inboundOrderDetailService;
			_warehouseAreaRepository = warehouseAreaRepository;
			_reCheckOrderService = reCheckOrderService;
			_task_HtyService = task_HtyService;
			_interfaceLog = interfaceLog;
			_inboundService = inboundService;
			_feedbackMesService = feedbackMesService;
			_httpClientHelper = httpClientHelper;
			_mesReturnRecord = mesReturnRecord;
			_stockQuantityChangeRecordService = stockQuantityChangeRecordService;
			_inboundOrderService = inboundOrderService;

			}

			#endregion

			#region æ¥è¯¢æ¹æ³
			// è·åæªæ£éåè¡¨
			public async Task<List<Dt_OutStockLockInfo>> GetUnpickedList(string orderNo, string palletCode)
			{
			@@ -147,6 +189,8 @@
			return summary;
			}

			#endregion

			#region æ ¸å¿ä¸å¡æµç¨
			/// <summary>
			/// æ£é
			@@ -161,27 +205,32 @@
			{
			_unitOfWorkManage.BeginTran();

			// 1. åç½®éªè¯åä¸å¡æ£æ¥
			var validationResult = await ValidatePickingRequest(orderNo, palletCode, barcode);
			if (!validationResult.IsValid)
			return WebResponseContent.Instance.Error(validationResult.ErrorMessage);

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

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

			var (actualQty, adjustedReason) = quantityResult.Data;

			// 3. æ§è¡åæ£é»è¾
			var overPickingValidation = await ValidateOverPicking(orderDetail.Id, actualQty);
			if (!overPickingValidation.IsValid)
			{
			return WebResponseContent.Instance.Error(overPickingValidation.ErrorMessage);
			}

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

			// 4. æ´æ°ç¸å³æ°æ®
			// ç»ä¸æ´æ°è®¢åæ°æ®ï¼ææåæ¯é½å¨è¿éæ´æ°ï¼
			await UpdateOrderRelatedData(orderDetail.Id, pickingResult.ActualPickedQty, orderNo);

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

			_unitOfWorkManage.CommitTran();
			@@ -195,6 +244,7 @@
			return WebResponseContent.Instance.Error($"æ£éç¡®è®¤å¤±è´¥ï¼{ex.Message}");
			}
			}

			/// <summary>
			/// åæ¶æ£é
			/// </summary>
			@@ -212,19 +262,19 @@
			}
			_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}");
			return WebResponseContent.Instance.OK($"åæ¶åæ£æå");
			}
			catch (Exception ex)
			{
			@@ -246,11 +296,11 @@
			{
			_unitOfWorkManage.BeginTran();

			// 1. åºç¡éªè¯

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

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

			if (stockInfo == null)
			@@ -260,23 +310,53 @@
			if (task == null)
			return WebResponseContent.Instance.Error("æªæ¾å°å¯¹åºçä»»å¡ä¿¡æ¯");

			// 3. åæéè¦ååºçè´§ç©
			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)
			{
			try
			{
			var result = await HandleNoReturnItems(orderNo, palletCode, task, stockInfo.Id);
			_unitOfWorkManage.CommitTran();
			if (result.Status)
			{
			task.PalletType = PalletTypeEnum.Empty.ObjToInt();
			await CreateReturnTaskAndHandleESS(orderNo, palletCode, task, TaskTypeEnum.InEmpty, PalletTypeEnum.Empty.ObjToInt());
			}
			return result;
			}
			catch (Exception ex)
			{
			_unitOfWorkManage.RollbackTran();
			_logger.LogError($"ReturnRemaining ååºç©ºç®±å¤±è´¥ - OrderNo: {orderNo}, PalletCode: {palletCode}, Error: {ex.Message}");
			return WebResponseContent.Instance.Error($"ååºç©ºç®±æä½å¤±è´¥: {ex.Message}");
			}

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

			// 5. åå»ºååºä»»å¡
			await CreateReturnTaskAndHandleESS(orderNo, palletCode, task, returnAnalysis);
			}

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

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

			await ReleaseAllLocksForReallocation(orderNo, palletCode, statusAnalysis);

			_unitOfWorkManage.CommitTran();

			// 6. æ´æ°è®¢åç¶æï¼ä¸è§¦åMESåä¼ ï¼

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

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

			return WebResponseContent.Instance.OK($"ååºæä½æåï¼å±ååºæ°éï¼{returnAnalysis.TotalReturnQty}");
			return WebResponseContent.Instance.OK($"ååºæä½æå");
			//return WebResponseContent.Instance.OK($"ååºæä½æåï¼å±ååºæ°éï¼{statusAnalysis.TotalReturnQty}");
			}
			catch (Exception ex)
			{
			@@ -286,22 +366,87 @@
			}
			}

			/// <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();
			@@ -309,18 +454,18 @@
			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())
			@@ -329,14 +474,14 @@
			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();
			@@ -361,7 +506,7 @@
			{
			// æ¥æ¾åä¸è®¢åä¸çè®°å½
			lockInfo = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
			.Where(it => it.OrderNo == orderNo && it.CurrentBarcode == barcode && it.Status == (int)OutLockStockStatusEnum.åºåºä¸ && it.AssignQuantity > it.PickedQty).FirstAsync();
			.Where(it => it.OrderNo == orderNo && it.CurrentBarcode == barcode && it.Status == (int)OutLockStockStatusEnum.åºåºä¸ && it.AssignQuantity > it.PickedQty).FirstAsync();

			if (lockInfo == null)
			{
			@@ -369,10 +514,21 @@
			var completedLockInfo = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
			.Where(it => it.CurrentBarcode == barcode &&
			(it.Status == (int)OutLockStockStatusEnum.æ£éå®æ \|\|
			it.Status == (int)OutLockStockStatusEnum.å·²éæ¾ \|\|
			it.Status == (int)OutLockStockStatusEnum.å·²åèµ° \|\|
			it.PickedQty >= it.AssignQuantity)).FirstAsync();

			if (completedLockInfo != null)
			throw new Exception($"æ¡ç {barcode}å·²ç»å®æåæ£ï¼ä¸è½éå¤åæ£");
			{
			string statusMsg = completedLockInfo.Status switch
			{
			(int)OutLockStockStatusEnum.æ£éå®æ => "å·²ç»å®æåæ£",
			(int)OutLockStockStatusEnum.å·²éæ¾ => "å·²ç»éæ¾",
			(int)OutLockStockStatusEnum.å·²åèµ° => "å·²ç»åèµ°",
			_ => "å·²ç»å®æåæ£"
			};
			throw new Exception($"æ¡ç {barcode}{statusMsg}ï¼ä¸è½éå¤åæ£");
			}
			else
			return null;
			}
			@@ -388,18 +544,29 @@
			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;

			// æ£æ¥1ï¼è®¢åæ°ééå¶
			if (plannedQty > remainingOrderQty && remainingOrderQty > 0)
			if (plannedQty > remainingOrderQty)
			{
			actualQty = remainingOrderQty;
			adjustedReason = $"è®¢åæ°ééå¶ï¼ä»{plannedQty}è°æ´ä¸º{actualQty}";
			}

			// æ£æ¥2ï¼åºåæ°ééå¶
			if (actualQty > stockQuantity)
			{
			actualQty = stockQuantity;
			@@ -407,11 +574,18 @@
			? $"{adjustedReason}ï¼åºåæ°ééå¶ï¼è¿ä¸æ¥è°æ´ä¸º{actualQty}"
			: $"åºåæ°ééå¶ï¼ä»{plannedQty}è°æ´ä¸º{actualQty}";
			}

			// æ£æ¥3ï¼å®éå¯æ£éæ°éå¿é¡»å¤§äº0
			if (actualQty <= 0)
			{
			return ValidationResult<(decimal, string)>.Error($"æ æ³åæ£ï¼è®¡åæ°é{plannedQty}ï¼å©ä½è®¢å{remainingOrderQty}ï¼åºå{stockQuantity}");
			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)
			@@ -422,9 +596,32 @@
			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)
			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
			@@ -438,60 +635,68 @@
			if (actualQty < stockQuantity)
			{
			await HandleSplitPacking(lockInfo, stockDetail, actualQty, stockQuantity, result);
			// æååºæ¯è¿åå®éæ£éæ°é
			result.ActualPickedQty = actualQty;
			}
			else if (actualQty == stockQuantity)
			{
			await HandleFullPicking(lockInfo, stockDetail, actualQty, result);
			// æ´åæ£éè¿åå®éæ£éæ°é
			result.ActualPickedQty = actualQty;
			}
			else
			{
			await HandlePartialPicking(lockInfo, stockDetail, actualQty, stockQuantity, result);
			// é¨åæ£éè¿åè°æ´åçæ°é
			result.ActualPickedQty = result.ActualPickedQty; // å·²ç»å¨æ¹æ³åè°æ´
			}

			return result;
			}

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

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

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

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

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

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

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



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

			// 2. æ´æ°éå®ä¿¡æ¯
			// æ´æ°éå®ä¿¡æ¯
			lockInfo.PickedQty += actualQty;
			lockInfo.Status = (int)OutLockStockStatusEnum.æ£éå®æ;
			lockInfo.Operator = App.User.UserName;
			@@ -504,19 +709,19 @@
			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;
			@@ -531,21 +736,40 @@
			decimal newOverOutQuantity = currentOrderDetail.OverOutQuantity + pickedQty;
			decimal newPickedQty = currentOrderDetail.PickedQty + pickedQty;

			// æç»æ£æ¥ï¼ç¡®ä¿ä¸ä¼è¶è¿è®¢åéæ±æ°é
			if (newOverOutQuantity > currentOrderDetail.NeedOutQuantity)
			{
			throw new Exception($"åæ£åå°å¯¼è´å·²åºåºæ°é({newOverOutQuantity})è¶è¿è®¢åéæ±æ°é({currentOrderDetail.NeedOutQuantity})");
			_logger.LogError($"é²è¶æ£æ£æ¥å¤±è´¥ - OrderDetailId: {orderDetailId}, å·²åºåº: {newOverOutQuantity}, éæ±: {currentOrderDetail.NeedOutQuantity}, æ¬æ¬¡åæ£: {pickedQty}");

			decimal adjustedQty = currentOrderDetail.NeedOutQuantity - currentOrderDetail.OverOutQuantity;

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

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

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

			// æ£æ¥å¹¶æ´æ°è®¢åç¶æ
			await CheckAndUpdateOrderStatus(orderNo);
			@@ -576,7 +800,15 @@
			PickQuantity = result.ActualPickedQty,
			PickTime = DateTime.Now,
			Operator = App.User.UserName,
			OutStockLockId = result.FinalLockInfo.Id
			OutStockLockId = result.FinalLockInfo.Id,
			BarcodeUnit = result.FinalLockInfo.BarcodeUnit,
			BarcodeQty = result.FinalLockInfo.BarcodeQty,
			BatchNo = result.FinalLockInfo.BatchNo,
			lineNo = result.FinalLockInfo.lineNo,
			SupplyCode = result.FinalLockInfo.SupplyCode,
			WarehouseCode = result.FinalLockInfo.WarehouseCode,


			};

			await Db.Insertable(pickingHistory).ExecuteCommandAsync();
			@@ -585,7 +817,75 @@
			#endregion

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

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

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

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

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

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

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

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

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

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

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



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

			if (parentLock == null \|\| parentLock.Status == (int)OutLockStockStatusEnum.ååºä¸ \|\|
			parentLock.Status == (int)OutLockStockStatusEnum.å·²éæ¾ \|\|
			parentLock.Status == (int)OutLockStockStatusEnum.å·²åèµ°)
			return false;
			}

			return true;
			}
			private async Task<ValidationResult<(Dt_PickingRecord, Dt_OutStockLockInfo, Dt_OutboundOrderDetail)>> ValidateCancelRequest(string orderNo, string palletCode, string barcode)
			{
			// åºç¡åæ°éªè¯
			@@ -603,6 +903,10 @@
			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)
			@@ -611,13 +915,38 @@
			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 stockDetail = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
			.Where(it => it.Barcode == barcode && it.StockId == pickingRecord.StockId)
			.FirstAsync();
			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)
			{
			@@ -629,39 +958,9 @@
			}
			}

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

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

			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>
			/// æ£æ¥éå®ä¿¡æ¯å¯¹åºçæ¡ç æ¯å¦å·²ç»ååº
			@@ -679,30 +978,25 @@
			stockDetail.Status == StockStatusEmun.å¥åºå®æ.ObjToInt();
			}
			private async Task ExecuteCancelLogic(Dt_OutStockLockInfo lockInfo, Dt_PickingRecord pickingRecord,
			Dt_OutboundOrderDetail orderDetail, string orderNo)
			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()))
			// æ°æ®ä¸è´æ§éªè¯
			var context = new CancelPickingContext
			{
			throw new Exception($"æ¡ç {pickingRecord.Barcode}å·²ç»ååºï¼æ æ³åæ¶åæ£");
			}
			// æ£æ¥åæ¶åæ°éä¸ä¼ä¸ºè´æ°
			decimal newOverOutQuantity = orderDetail.OverOutQuantity - cancelQty;
			decimal newPickedQty = orderDetail.PickedQty - cancelQty;
			LockInfo = lockInfo,
			PickingRecord = pickingRecord,
			OrderDetail = orderDetail,
			OrderNo = orderNo,
			CancelQuantity = cancelQty
			};

			if (newOverOutQuantity < 0 \|\| newPickedQty < 0)
			{
			throw new Exception($"åæ¶åæ£å°å¯¼è´æ°æ®å¼å¸¸ï¼å·²åºåº{newOverOutQuantity}ï¼å·²æ£é{newPickedQty}");
			}
			var validationResult = await ValidateDataConsistencyBeforeCancel(context);
			if (!validationResult.IsValid)
			throw new Exception(validationResult.ErrorMessage);

			// å¤çä¸åç±»åçåæ¶
			// å¤çä¸åç±»åçåæ¶
			if (lockInfo.IsSplitted == 1 && lockInfo.ParentLockId.HasValue)
			{
			await HandleSplitBarcodeCancel(lockInfo, pickingRecord, cancelQty);
			@@ -712,16 +1006,23 @@
			await HandleNormalBarcodeCancel(lockInfo, pickingRecord, cancelQty);
			}

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

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

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

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

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


			}

			private async Task HandleSplitBarcodeCancel(Dt_OutStockLockInfo lockInfo, Dt_PickingRecord pickingRecord, decimal cancelQty)
			@@ -734,59 +1035,85 @@
			if (parentLockInfo == null)
			throw new Exception("æªæ¾å°ç¶éå®ä¿¡æ¯ï¼æ æ³åæ¶æååæ£");

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

			// æ¢å¤åºå
			var stockDetail = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
			@@ -797,45 +1124,81 @@
			{
			stockDetail.StockQuantity += cancelQty;
			stockDetail.OutboundQuantity = stockDetail.StockQuantity;
			stockDetail.Status = StockStatusEmun.åºåºéå®.ObjToInt();

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

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

			_logger.LogInformation($"æ¢å¤åºå - æ¡ç : {stockDetail.Barcode}, æ¢å¤æ°é: {cancelQty}, " +
			$"æ°åºå: {stockDetail.StockQuantity}, æ°ç¶æ: {stockDetail.Status}");
			}
			else
			{
			_logger.LogWarning($"æªæ¾å°åºåè®°å½ - æ¡ç : {pickingRecord.Barcode}, åºåID: {pickingRecord.StockId}");
			}
			}

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

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

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

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

			// ç¡®å®æ°çç¶æ
			int newStatus;
			if (newOverOutQuantity >= currentOrderDetail.NeedOutQuantity)
			{
			throw new Exception($"åæ¶åæ£å°å¯¼è´å·²åºåºæ°é({newOverOutQuantity})æå·²æ£éæ°é({newPickedQty})ä¸ºè´æ°");
			newStatus = OrderDetailStatusEnum.Over.ObjToInt();
			}
			else if (newOverOutQuantity > 0)
			{
			newStatus = OrderDetailStatusEnum.Outbound.ObjToInt();
			}
			else
			{
			newStatus = OrderDetailStatusEnum.New.ObjToInt();
			}

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

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

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

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

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

			private async Task<Dt_StockInfo> GetStockInfo(string palletCode)
			{
			return await _stockInfoService.Db.Queryable<Dt_StockInfo>()
			.FirstAsync(x => x.PalletCode == palletCode);
			}
			/// <summary>
			/// æ£æ¥æ´ä¸ªæçæ¯å¦å·²ç»ååº
			/// </summary>
			@@ -870,58 +1233,6 @@
			return task;
			}

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

			// æåµ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);
			}

			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;
			@@ -929,11 +1240,14 @@

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

			if (originalStock != null && originalStock.StockQuantity > 0)
			@@ -947,7 +1261,7 @@
			if (!processedBarcodes.Contains(splitRecord.NewBarcode))
			{
			var newStock = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
			.Where(it => it.Barcode == splitRecord.NewBarcode && it.StockId == stockId)
			.Where(it => it.Barcode == splitRecord.NewBarcode && it.StockId == stockId && it.Status != StockStatusEmun.åºåºå®æ.ObjToInt())
			.FirstAsync();

			if (newStock != null && newStock.StockQuantity > 0)
			@@ -961,57 +1275,206 @@
			return totalQty;
			}

			private async Task<WebResponseContent> HandleNoReturnItems(string orderNo, string palletCode,Dt_Task originalTask)
			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.æ£éå®æ);
			try
			{
			var locationtype = 0;
			var stockInfo = await _stockInfoService.Db.Queryable<Dt_StockInfo>()
			.Where(x => x.PalletCode == palletCode)
			.FirstAsync();

			if (allPicked)
			{
			// å é¤åå§åºåºä»»å¡
			await _taskRepository.Db.Deleteable(originalTask).ExecuteCommandAsync();
			return WebResponseContent.Instance.OK("ææè´§ç©å·²æ£éå®æï¼æçä¸ºç©º");
			if (stockInfo == null)
			{
			var firstLocation = await _locationInfoService.Db.Queryable<Dt_LocationInfo>().FirstAsync(x => x.LocationCode == originalTask.SourceAddress);
			locationtype = firstLocation?.LocationType ?? 1;
			}
			else
			{
			locationtype = stockInfo.LocationType;
			_stockInfoService.DeleteData(stockInfo);
			}

			var targetAddress = originalTask.TargetAddress;

			await CleanupZeroStockData(stockInfoId);


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

			}
			else
			catch (Exception ex)
			{
			// å é¤åå§åºåºä»»å¡
			await _taskRepository.Db.Deleteable(originalTask).ExecuteCommandAsync();
			return WebResponseContent.Instance.Error("æ²¡æéè¦ååºçå©ä½è´§ç©");
			_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, ReturnAnalysisResult analysis)
			Dt_Task task, PalletStatusAnalysis analysis)
			{
			// æåµ1ï¼å¤çæªåæ£çåºåºéå®è®°å½
			if (analysis.HasRemainingLocks)
			{
			await HandleRemainingLocksReturn(analysis.RemainingLocks, stockInfo.Id);

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

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

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

			// æåµ3ï¼å¤çæåè®°å½
			// å¤çæåè®°å½
			if (analysis.HasSplitRecords)
			{
			await HandleSplitRecordsReturn(analysis.SplitRecords, orderNo, palletCode);
			var validSplitRecords = analysis.SplitRecords
			.Where(x => x.Status != (int)SplitPackageStatusEnum.å·²æ£é)
			.ToList();

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

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

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

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

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

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

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

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

			// å°éå®è®°å½ç¶ææ¹ä¸º"å·²éæ¾"ï¼æèç´æ¥å é¤
			// æ è®°ä¸ºå·²éæ¾
			await _outStockLockInfoService.Db.Updateable<Dt_OutStockLockInfo>()
			.SetColumns(it => new Dt_OutStockLockInfo
			{
			Status = (int)OutLockStockStatusEnum.å·²éæ¾,

			Operator = App.User.UserName
			})
			.Where(it => lockIds.Contains(it.Id))
			.ExecuteCommandAsync();

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

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

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

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

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

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

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

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

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

			_logger.LogInformation($"éç½®{affectedOrderDetailIds.Count}ä¸ªè®¢åæç»çéå®æ°é");
			}
			private async Task HandleRemainingLocksReturn(List<Dt_OutStockLockInfo> remainingLocks, int stockId)
			{
			var lockIds = remainingLocks.Select(x => x.Id).ToList();
			@@ -1029,7 +1492,13 @@
			foreach (var lockInfo in remainingLocks)
			{
			decimal returnQty = lockInfo.AssignQuantity - lockInfo.PickedQty;
			if (returnQty <= 0)
			{
			_logger.LogWarning($"éå®è®°å½{lockInfo.Id}æ éååºï¼åéæ°é: {lockInfo.AssignQuantity}, å·²æ£é: {lockInfo.PickedQty}");
			continue;
			}

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

			if (stockDetail != null)
			{
			stockDetail.StockQuantity += returnQty;
			// æ¢å¤åºåç¶æ
			stockDetail.OutboundQuantity = Math.Max(0, stockDetail.OutboundQuantity - returnQty);
			stockDetail.Status = StockStatusEmun.å¥åºç¡®è®¤.ObjToInt();
			@@ -1044,59 +1514,56 @@
			}
			else
			{
			_logger.LogWarning($"æªæ¾å°å¯¹åºçåºåæç» - æ¡ç : {lockInfo.CurrentBarcode}, åºåID: {lockInfo.StockId}");
			// åå»ºæ°çåºåè®°å½
			var newStockDetail = new Dt_StockInfoDetail
			{
			StockId = lockInfo.StockId,
			MaterielCode = lockInfo.MaterielCode,
			MaterielName = lockInfo.MaterielName,
			OrderNo = lockInfo.OrderNo,
			BatchNo = lockInfo.BatchNo,
			StockQuantity = returnQty,
			OutboundQuantity = 0,
			Barcode = lockInfo.CurrentBarcode,
			InboundOrderRowNo = "",
			Status = StockStatusEmun.å¥åºç¡®è®¤.ObjToInt(),
			SupplyCode = lockInfo.SupplyCode,
			WarehouseCode = lockInfo.WarehouseCode,
			Unit = lockInfo.Unit,
			};
			await _stockInfoDetailService.Db.Insertable(newStockDetail).ExecuteCommandAsync();
			//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)
			try
			{
			// è°æ´å·²æ£éæ°éåå·²åºåºæ°é
			decimal newPickedQty = Math.Max(0, orderDetail.PickedQty - totalReturnQty);
			decimal newOverOutQuantity = Math.Max(0, orderDetail.OverOutQuantity - totalReturnQty);
			var orderDetail = await _outboundOrderDetailService.Db.Queryable<Dt_OutboundOrderDetail>()
			.FirstAsync(x => x.Id == lockInfo.OrderDetailId);

			await _outboundOrderDetailService.Db.Updateable<Dt_OutboundOrderDetail>()
			.SetColumns(it => new Dt_OutboundOrderDetail
			{
			PickedQty = newPickedQty,
			OverOutQuantity = newOverOutQuantity,
			})
			.Where(it => it.Id == orderDetailId)
			.ExecuteCommandAsync();
			if (orderDetail != null)
			{
			decimal newLockQuantity = Math.Max(0, orderDetail.LockQuantity - returnQty);

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

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


			}


			private async Task HandlePalletStockGoodsReturn(List<Dt_StockInfoDetail> palletStockGoods)
			{
			@@ -1104,24 +1571,42 @@
			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();
			if (stockGood.Status != StockStatusEmun.åºåºå®æ.ObjToInt())
			{
			stockGood.OutboundQuantity = 0;
			stockGood.Status = StockStatusEmun.å¥åºç¡®è®¤.ObjToInt();
			await _stockInfoDetailService.Db.Updateable(stockGood).ExecuteCommandAsync();

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

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

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

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

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

			@@ -1140,7 +1625,7 @@
			/// <param name="originalTask"></param>
			/// <param name="analysis"></param>
			/// <returns></returns>
			private async Task CreateReturnTaskAndHandleESS(string orderNo, string palletCode, Dt_Task originalTask, ReturnAnalysisResult analysis)
			private async Task CreateReturnTaskAndHandleESS(string orderNo, string palletCode, Dt_Task originalTask, TaskTypeEnum taskTypeEnum, int palletType)
			{
			var firstLocation = await _locationInfoService.Db.Queryable<Dt_LocationInfo>()
			.FirstAsync(x => x.LocationCode == originalTask.SourceAddress);
			@@ -1154,22 +1639,42 @@
			Grade = 0,
			PalletCode = palletCode,
			NextAddress = "",
			OrderNo = originalTask.OrderNo,
			// OrderNo = originalTask.OrderNo,
			OrderNo = orderNo,
			Roadway = newLocation.RoadwayNo,
			SourceAddress = stations[originalTask.TargetAddress],
			TargetAddress = newLocation.LocationCode,
			TaskStatus = TaskStatusEnum.New.ObjToInt(),
			TaskType = TaskTypeEnum.InPick.ObjToInt(),
			PalletType = originalTask.PalletType,
			TaskType = taskTypeEnum.ObjToInt(),
			PalletType = palletType,
			WarehouseId = originalTask.WarehouseId

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

			try
			{
			// ä¿åååºä»»å¡
			var insertcount = await _taskRepository.Db.Insertable(returnTask).ExecuteCommandAsync();
			if (insertcount <= 0)
			{
			throw new Exception("åå»ºä»»å¡å¤±è´¥ï¼");
			}
			}
			catch (Exception ex)
			{
			_logger.LogInformation($"CreateReturnTaskAndHandleESS åå»ºä»»å¡å¤±è´¥: {orderNo} ï¼ {palletCode}");
			throw new Exception("åå»ºä»»å¡å¤±è´¥ï¼");
			}
			var targetAddress = originalTask.TargetAddress;

			_logger.LogInformation($"CreateReturnTaskAndHandleESS å é¤åå²ä»»å¡: {orderNo} ï¼ {originalTask.TaskNum}");
			// å é¤åå§åºåºä»»å¡
			await _taskRepository.Db.Deleteable(originalTask).ExecuteCommandAsync();
			// _taskRepository.DeleteAndMoveIntoHty(originalTask, OperateTypeEnum.èªå¨å®æ);
			var result = _task_HtyService.DeleteAndMoveIntoHty(originalTask, OperateTypeEnum.äººå·¥å é¤);
			if (!result)
			{
			await _taskRepository.Db.Deleteable(originalTask).ExecuteCommandAsync();
			}
			_logger.LogInformation($"CreateReturnTaskAndHandleESS å é¤åå²ä»»å¡: {orderNo} ï¼ {originalTask.TaskNum},å½±åè¡ {result}");

			// ç» ESS åéæµå¨ä¿¡å·ååå»ºä»»å¡
			await SendESSCommands(palletCode, targetAddress, returnTask);
			@@ -1186,44 +1691,40 @@
			{
			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 = ""
			}
			}
			}
			};
			//if (moveResult)
			//{
			// åå»ºååºä»»å¡
			//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}");
			}
			//var resultTask = await _eSSApiService.CreateTaskAsync(essTask);
			//_logger.LogInformation($"ReturnRemaining åå»ºä»»å¡æå: {resultTask}");
			//}
			}
			catch (Exception ex)
			{
			@@ -1247,13 +1748,25 @@
			.ToListAsync();

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

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

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

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

			var outboundOrder = await _outboundOrderService.Db.Queryable<Dt_OutboundOrder>()
			@@ -1261,20 +1774,34 @@

			if (outboundOrder == null) return;

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

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

			// åªææ£å¸¸åæ£å®ææ¶æåMESåé¦
			if (allCompleted && newStatus == (int)OutOrderStatusEnum.åºåºå®æ)
			{
			await HandleOrderCompletion(outboundOrder, orderNo);
			}
			_logger.LogInformation($"è®¢åç¶ææ´æ° - OrderNo: {orderNo}, æ§ç¶æ: {outboundOrder.OrderStatus}, æ°ç¶æ: {newStatus}");


			}
			}
			catch (Exception ex)
			@@ -1283,6 +1810,70 @@
			}
			}

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

			if (orderDetail == null) return;

			int newStatus = orderDetail.OrderDetailStatus;

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

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

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

			await _outboundOrderDetailService.Db.Updateable<Dt_OutboundOrderDetail>()
			.SetColumns(it => new Dt_OutboundOrderDetail
			{
			LockQuantity = totalLockedQty
			})
			.Where(it => it.Id == orderDetailId)
			.ExecuteCommandAsync();
			}
			private async Task UpdateOrderStatusForReturn(string orderNo)
			{
			try
			@@ -1313,7 +1904,11 @@
			if (outboundOrder.OrderStatus != newStatus)
			{
			await _outboundOrderService.Db.Updateable<Dt_OutboundOrder>()
			.SetColumns(x => x.OrderStatus == newStatus)
			.SetColumns(x => new Dt_OutboundOrder
			{
			OrderStatus = newStatus,
			Operator = App.User.UserName,
			})
			.Where(x => x.OrderNo == orderNo)
			.ExecuteCommandAsync();

			@@ -1326,78 +1921,252 @@
			}
			}

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

			#region ç©ºæç

			/// <summary>
			/// æ¸çé¶åºåæ°æ®
			/// </summary>
			private async Task CleanupZeroStockData(int stockId)
			{
			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,
			status = outboundOrder.OrderStatus,
			details = new List<FeedbackOutboundDetailsModel>()
			};
			// 1. å é¤åºåæ°éä¸º0çæç»è®°å½
			var deleteDetailCount = await _stockInfoDetailService.Db.Deleteable<Dt_StockInfoDetail>()
			.Where(x => x.StockId == stockId && x.StockQuantity == 0)
			.ExecuteCommandAsync();

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

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

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

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

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

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

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

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

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

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

			}
			}

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

			// è¿éå¯ä»¥æ ¹æ®éè¦æ´æ°æ£éè®°å½çç¶æåæ®µ
			// ä¾å¦ï¼pickingRecord.Status = (int)PickingStatusEnum.å·²å®æ;
			_logger.LogInformation($"æ¾å°{pickingRecords.Count}æ¡æ£éè®°å½ - è®¢å: {orderNo}, æç: {palletCode}");

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

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

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

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

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

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

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

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

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

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

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

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

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

			return result;
			}

			private async Task<string> GenerateNewBarcode()
			{
			@@ -1430,10 +2199,12 @@
			OriginalLockQuantity = quantity,
			IsSplitted = 1,
			ParentLockId = originalLock.Id,
			Operator= App.User.UserName,
			FactoryArea=originalLock.FactoryArea,
			lineNo=originalLock.lineNo,
			WarehouseCode=originalLock.WarehouseCode,
			Operator = App.User.UserName,
			FactoryArea = originalLock.FactoryArea,
			lineNo = originalLock.lineNo,
			WarehouseCode = originalLock.WarehouseCode,
			BarcodeQty = originalLock.BarcodeQty,
			BarcodeUnit = originalLock.BarcodeUnit,

			};

			@@ -1508,11 +2279,6 @@
			}
			}

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

			private WebResponseContent CreatePickingResponse(PickingResult result, string adjustedReason)
			{
			//if (result.SplitResults.Any())
			@@ -1538,8 +2304,1092 @@
			}
			return WebResponseContent.Instance.OK("æ£éç¡®è®¤æå", new { SplitResults = new List<SplitResult>() });
			}

			#endregion


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

			public WebResponseContent GetAvailablePickingOrders(string outOrder)
			{
			Dt_OutboundOrder outboundOrder = Db.Queryable<Dt_OutboundOrder>().Where(x => x.UpperOrderNo == outOrder && x.OrderStatus != OutOrderStatusEnum.åºåºå®æ.ObjToInt()).Includes(x=>x.Details).First();
			if(outboundOrder == null)
			{
			return WebResponseContent.Instance.Error("æªæ¾å°æ»¡è¶³åºåºæ¡ä»¶çåºåºå");
			}
			if(outboundOrder.IsBatch == 0)
			{
			return WebResponseContent.Instance.Error("è¯¥åæ®ä¸å±äºåæ¹åä¼ åæ®ï¼ä¸åè®¸èæåºå¥åº");
			}
			//åæ¸ç©ºåæ®èæåºå¥åºæ°éè¿è¡è®¡ç®
			foreach (var item in outboundOrder.Details)
			{
			item.NoStockOutQty = 0;
			item.documentsNO = "";
			}
			_outboundOrderDetailService.UpdateData(outboundOrder.Details);
			return WebResponseContent.Instance.OK("æå");

			}

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

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

			var detailLists = new List<Dt_InboundOrderDetail>();
			var matchedDetail = inboundOrder.Details.FirstOrDefault(detail =>
			detail.Barcode == noStockOut.barCode &&
			detail.OrderDetailStatus != OrderDetailStatusEnum.Over.ObjToInt());

			if (matchedDetail == null)
			{
			matchedDetail = inboundOrder.Details.FirstOrDefault(detail =>
			detail.OutBoxbarcodes == noStockOut.barCode &&
			detail.OrderDetailStatus != OrderDetailStatusEnum.Over.ObjToInt());

			if (matchedDetail == null)
			{
			return WebResponseContent.Instance.Error($"å¨éè´å {noStockOut.inOder} ä¸æªæ¾å°æ¡ç ä¸º {noStockOut.barCode} çæç»ã");
			}
			else
			{
			// æ·»å ææå¹éå¤ç®±ç ä¸éå®æç¶æçæç»
			foreach (var detail in inboundOrder.Details)
			{
			if (detail.OrderDetailStatus != OrderDetailStatusEnum.Over.ObjToInt() &&
			!string.IsNullOrEmpty(detail.Barcode) &&
			detail.OutBoxbarcodes == noStockOut.barCode)
			{
			detailLists.Add(detail);
			}
			}
			}
			}
			else
			{
			if (!string.IsNullOrEmpty(noStockOut.barCode))
			{
			detailLists.Add(matchedDetail);
			}
			}
			var outDetails = new List<Dt_OutboundOrderDetail>();
			// éåæ¯ä¸ªå¥åºæç»
			foreach (var item in detailLists)
			{
			// éç½®å½åå¥åºæç»çæ åºååºåºæ°é
			item.NoStockOutQty = 0;

			// å½åæ¡ç éè¦åºåºçæ»æ°éï¼å¥åºåå©ä½å¯åºæ°éï¼
			decimal remainingBarcodeQty = item.OrderQuantity - item.ReceiptQuantity;
			if (remainingBarcodeQty <= 0)
			{
			return WebResponseContent.Instance.Error($"è¯¥éè´åä¸çæ¡ç {item.Barcode}å¯¹åºçå¯åºæ°éä¸º0");
			}

			// çéåºåºåä¸ç¬¦åæ¡ä»¶çæç»ï¼åç©æãéå®æãæå©ä½å¯åºæ°éï¼
			var eligibleOutDetails = outboundOrder.Details.Where(detail =>
			detail.MaterielCode == item.MaterielCode &&
			detail.OrderDetailStatus != OrderDetailStatusEnum.Over.ObjToInt() &&
			(detail.OrderQuantity - detail.LockQuantity - detail.MoveQty - detail.NoStockOutQty) > 0).ToList();

			if (!eligibleOutDetails.Any())
			{
			return WebResponseContent.Instance.Error($"å¨åºåºåä¸æªæ¾å°ç©æ{item.MaterielCode}çå¯åºåºæç»");
			}

			// éåç¬¦åæ¡ä»¶çåºåºæç»ï¼éè¡åéæ°é
			foreach (var outDetail in eligibleOutDetails)
			{
			// è®¡ç®å½ååºåºè¡çå©ä½å¯åºæ°é
			decimal rowRemainingQty = outDetail.OrderQuantity - outDetail.LockQuantity - outDetail.MoveQty - outDetail.NoStockOutQty;
			if (rowRemainingQty <= 0) continue;

			if (!outDetail.BatchNo.IsNullOrEmpty())
			{
			if (outDetail.BatchNo != item.BatchNo)
			{
			return WebResponseContent.Instance.Error($"åºåºåè¡æ¹æ¬¡{outDetail.BatchNo}ä¸éè´åæ¹æ¬¡{item.BatchNo}ä¸å¹é");
			}
			}
			if (!outDetail.SupplyCode.IsNullOrEmpty())
			{
			if (outDetail.SupplyCode != item.SupplyCode)
			{
			return WebResponseContent.Instance.Error($"åºåºåè¡ä¾åºå{outDetail.SupplyCode}ä¸éè´åä¾åºå{item.SupplyCode}ä¸å¹é");
			}
			}
			if (!string.IsNullOrEmpty(outboundOrder.FactoryArea) && !string.IsNullOrEmpty(inboundOrder.FactoryArea))
			{
			if (inboundOrder.FactoryArea != outboundOrder.FactoryArea)
			{
			return WebResponseContent.Instance.Error($"è¯¥æ¡ç {item.Barcode}å¯¹åºçåæ®ååºä¸åºåºåæ®ä¸ä¸è´ï¼ä¸åè®¸åºåºã");
			}
			}
			if (inboundOrder.BusinessType != "11" && !outDetail.WarehouseCode.IsNullOrEmpty())
			{
			if (outDetail.WarehouseCode != item.WarehouseCode)
			{
			return WebResponseContent.Instance.Error($"ä»åºä¸ä¸è´ï¼åºåºåè¡ä»åº{outDetail.WarehouseCode}ä¸éè´åä»åº{item.WarehouseCode}ä¸å¹é");
			}
			}
			else
			{
			item.WarehouseCode = outDetail.WarehouseCode;
			}

			// è®¡ç®æ¬æ¬¡åéçæ°éï¼åå©ä½æ¡ç æ°éåå½åè¡å©ä½æ°éçè¾å°å¼ï¼
			decimal assignQty = Math.Min(remainingBarcodeQty, rowRemainingQty);

			// æ´æ°å¥åºæç»ååºåºæç»çæ åºååºåºæ°é
			item.NoStockOutQty += assignQty;
			outDetail.NoStockOutQty += assignQty;

			// æ´æ°å©ä½éè¦åéçæ¡ç æ°é
			remainingBarcodeQty -= assignQty;

			// è®°å½å·²æ´æ°çåºåºæç»ï¼å»éï¼
			if (!outDetails.Contains(outDetail))
			{
			outDetails.Add(outDetail);
			}

			// éªè¯å½åè¡æ¯å¦æº¢åº
			if ((outDetail.LockQuantity + outDetail.NoStockOutQty + outDetail.MoveQty) > outDetail.OrderQuantity)
			{
			return WebResponseContent.Instance.Error($"åºåºåæç»{outDetail.Id}æ°éæº¢åºï¼è¶åºæ°éï¼{(outDetail.LockQuantity + outDetail.NoStockOutQty + outDetail.MoveQty) - outDetail.OrderQuantity}");
			}

			// å¤çMESåæ°åä¼ ï¼è®°å½å½åæ¡ç åéå°è¯¥è¡çå®éæ°é
			List<Barcodes> barcodesList = new List<Barcodes>();
			Barcodes barcodes = new Barcodes
			{
			Barcode = item.Barcode,
			Qty = assignQty,
			SupplyCode = item?.SupplyCode ?? "",
			BatchNo = item?.BatchNo ?? "",
			Unit = item?.Unit ?? ""
			};
			// ååºååè¯¥è¡å·²æçæ¡ç è®°å½
			if (!string.IsNullOrEmpty(outDetail.documentsNO))
			{
			try
			{
			barcodesList = JsonConvert.DeserializeObject<List<Barcodes>>(outDetail.documentsNO) ?? new List<Barcodes>();
			}
			catch (JsonException ex)
			{
			return WebResponseContent.Instance.Error($"åºåºåæç»{outDetail.Id}çdocumentsNOåæ®µæ ¼å¼éè¯¯ï¼{ex.Message}");
			}
			}
			// æ·»å æ¬æ¬¡åéçè®°å½
			barcodesList.Add(barcodes);
			// åºåååå
			JsonSerializerSettings settings = new JsonSerializerSettings
			{
			ContractResolver = new CamelCasePropertyNamesContractResolver()
			};
			outDetail.documentsNO = JsonConvert.SerializeObject(barcodesList, settings);

			// æ¡ç æ°éåéå®æ¯ï¼éåºå½åè¡å¾ªç¯
			if (remainingBarcodeQty <= 0)
			{
			break;
			}
			}

			// ææç¬¦åæ¡ä»¶çåºåºè¡éåå®åï¼æ¡ç æ°éä»æå©ä½
			if (remainingBarcodeQty > 0)
			{
			return WebResponseContent.Instance.Error($"æ¡ç {item.Barcode}éåºåºæ°é{item.OrderQuantity - item.ReceiptQuantity}ï¼ä½åºåºåä¸ç©æ{item.MaterielCode}å©ä½å¯åºæ»éä¸è¶³ï¼ä»å©ä½{remainingBarcodeQty}æ°éæªåé");
			}
			}

			_unitOfWorkManage.BeginTran();
			_inboundOrderDetailService.UpdateData(detailLists);
			_outboundOrderDetailService.UpdateData(outDetails);
			_unitOfWorkManage.CommitTran();

			return WebResponseContent.Instance.OK("æå", data: detailLists);
			}
			catch (Exception ex)
			{
			_unitOfWorkManage.RollbackTran();
			return WebResponseContent.Instance.Error(ex.Message);
			}
			}


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

			var matchedDetail = inboundOrder.Details.FirstOrDefault(detail =>
			detail.Barcode == noStockOut.barCode &&
			detail.OrderDetailStatus != OrderDetailStatusEnum.Over.ObjToInt());

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

			// éç½®å¥åºæç»çæ åºååºåºæ°é
			decimal revokedTotalQty = matchedDetail.NoStockOutQty; // è®°å½éè¦æ¤éçæ»æ°éï¼å¥åºåä¸å·²åéçæ°éï¼
			matchedDetail.NoStockOutQty = 0;
			if(inboundOrder.BusinessType == "11")
			{
			matchedDetail.WarehouseCode ="";
			}

			// éç½®å¥åºæç»ç¶æ
			if (matchedDetail.ReceiptQuantity == 0 && matchedDetail.OverInQuantity == 0)
			{
			matchedDetail.OrderDetailStatus = OrderDetailStatusEnum.New.ObjToInt();
			}

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

			// æ¾å°ææå³èè¯¥æ¡ç çåºåºæç»è¡
			// åç©æãéå®æç¶æãdocumentsNOåå«è¯¥æ¡ç
			var matchedCodeList = outboundOrder.Details.Where(detail =>
			detail.MaterielCode == matchedDetail.MaterielCode && // ç¡®ä¿ç©æå¹é
			detail.OrderDetailStatus != OrderDetailStatusEnum.Over.ObjToInt() &&
			!string.IsNullOrEmpty(detail.documentsNO) &&
			detail.documentsNO.Contains(noStockOut.barCode) // åå«å½åæ¡ç
			).ToList();

			if (!matchedCodeList.Any())
			{
			return WebResponseContent.Instance.Error($"å¨åºåºåä¸æªæ¾å°å³èæ¡ç {noStockOut.barCode}çç©æ{matchedDetail.MaterielCode}æç»ã");
			}

			//éè¡å¤çåºåºæç»çæ¤éé»è¾
			decimal remainingRevokeQty = revokedTotalQty; // å©ä½éè¦æ¤éçæ°é
			foreach (var matchedCode in matchedCodeList)
			{
			if (remainingRevokeQty <= 0) break; // æææ°éå·²æ¤éï¼éåºå¾ªç¯

			// å¤çMESåæ°æ¤é
			List<Barcodes> barcodesList = new List<Barcodes>();
			if (!string.IsNullOrEmpty(matchedCode.documentsNO))
			{
			try
			{
			barcodesList = JsonConvert.DeserializeObject<List<Barcodes>>(matchedCode.documentsNO) ?? new List<Barcodes>();
			}
			catch (JsonException ex)
			{
			return WebResponseContent.Instance.Error($"åºåºåæç»{matchedCode.Id}çdocumentsNOåæ®µæ ¼å¼éè¯¯ï¼{ex.Message}");
			}
			}

			// çéåºå½åæ¡ç çææè®°å½
			var barcodeRecords = barcodesList.Where(b =>
			string.Equals(b.Barcode, noStockOut.barCode, StringComparison.OrdinalIgnoreCase)).ToList();
			if (!barcodeRecords.Any()) continue;

			// è®¡ç®è¯¥è¡éè¦æ¤éçæ°éï¼ç´¯å è¯¥æ¡ç å¨è¯¥è¡çææåéæ°éï¼
			decimal rowRevokeQty = barcodeRecords.Sum(b => b.Qty);
			// å®éæ¤éæ°éï¼åè¯¥è¡å¯æ¤éæ°éåå©ä½éè¦æ¤éæ°éçè¾å°å¼
			decimal actualRevokeQty = Math.Min(rowRevokeQty, remainingRevokeQty);

			// ç§»é¤è¯¥è¡ä¸è¯¥æ¡ç çè®°å½ï¼æé¨åè®°å½ï¼è¥å©ä½æ¤éæ°éä¸è¶³ï¼
			if (actualRevokeQty < rowRevokeQty)
			{
			// å©ä½æ¤éæ°éä¸è¶³ï¼åªç§»é¤é¨åè®°å½ï¼ææ°éæ£åï¼
			decimal tempQty = actualRevokeQty;
			var removeList = new List<Barcodes>();
			foreach (var record in barcodeRecords)
			{
			if (tempQty <= 0) break;
			if (record.Qty <= tempQty)
			{
			removeList.Add(record);
			tempQty -= record.Qty;
			}
			else
			{
			// è®°å½æ°éæåï¼æ£åé¨åæ°é
			record.Qty -= tempQty;
			tempQty = 0;
			}
			}
			barcodesList.RemoveAll(b => removeList.Contains(b));
			}
			else
			{
			// ç§»é¤è¯¥è¡ä¸è¯¥æ¡ç çææè®°å½
			barcodesList.RemoveAll(b =>
			string.Equals(b.Barcode, noStockOut.barCode, StringComparison.OrdinalIgnoreCase));
			}

			//éæ°åºååMESåæ°
			JsonSerializerSettings settings = new JsonSerializerSettings
			{
			ContractResolver = new CamelCasePropertyNamesContractResolver()
			};
			matchedCode.documentsNO = JsonConvert.SerializeObject(barcodesList, settings);

			//æ£ååºåºæç»çæ åºååºåºæ°é
			matchedCode.NoStockOutQty = Math.Max(0, matchedCode.NoStockOutQty - actualRevokeQty);
			remainingRevokeQty -= actualRevokeQty;

			//éç½®åºåºæç»ç¶æ
			if (matchedCode.LockQuantity == 0 && matchedCode.OverOutQuantity == 0)
			{
			matchedCode.OrderDetailStatus = OrderDetailStatusEnum.New.ObjToInt();
			}
			}

			//è¥ä»ææªæ¤éçæ°éï¼è¯´ææ°æ®ä¸ä¸è´
			if (remainingRevokeQty > 0)
			{
			return WebResponseContent.Instance.Error($"æ¤éæ¡ç {noStockOut.barCode}æ¶ï¼åºåºåä¸å¯æ¤éæ°éä¸è¶³ï¼ä»æ{remainingRevokeQty}æ°éæªæ¤é");
			}

			_unitOfWorkManage.BeginTran();
			_inboundOrderDetailService.UpdateData(matchedDetail);
			_outboundOrderDetailService.UpdateData(matchedCodeList);
			_unitOfWorkManage.CommitTran();

			return WebResponseContent.Instance.OK("æ¡ç æ¤éæå", data: new { RevokedQty = revokedTotalQty });
			}
			catch (Exception ex)
			{
			_unitOfWorkManage.RollbackTran();
			return WebResponseContent.Instance.Error(ex.Message);
			}
			}

			public async Task<WebResponseContent> NoStockOutSubmit(NoStockOutSubmit noStockOutSubmit)
			{
			try
			{
			Dt_OutboundOrder outboundOrder = _inboundOrderRepository.Db.Queryable<Dt_OutboundOrder>().Where(x => x.UpperOrderNo == noStockOutSubmit.OutOderSubmit && x.OrderStatus != OutOrderStatusEnum.åºåºå®æ.ObjToInt()).Includes(x => x.Details).First();
			if (outboundOrder == null)
			{
			return WebResponseContent.Instance.Error($"æªæ¾å°åºåºåï¼{noStockOutSubmit.OutOderSubmit}");
			}

			List<Dt_OutboundOrderDetail> outboundOrderDetails = new List<Dt_OutboundOrderDetail>();

			Dictionary<int, List<string>> orderIdBarCodeDict = new Dictionary<int, List<string>>();

			List<Dt_InboundOrderDetail> updateInboundDetails = new List<Dt_InboundOrderDetail>();

			Dictionary<int, Dt_InboundOrder> updateInboundOrders = new Dictionary<int, Dt_InboundOrder>();

			List<Dt_StockQuantityChangeRecord> changeRecords = new List<Dt_StockQuantityChangeRecord>();
			_unitOfWorkManage.BeginTran();

			List<Dt_InboundOrderDetail> allInboundDetails = _inboundOrderDetailService.Db
			.Queryable<Dt_InboundOrderDetail>()
			.Where(detail => noStockOutSubmit.BarCodeSubmit.Contains(detail.Barcode)
			&& detail.OrderDetailStatus != OrderDetailStatusEnum.Over.ObjToInt())
			.ToList();

			var detailGroupByOrderId = allInboundDetails.GroupBy(d => d.OrderId).ToList();
			foreach (var group in detailGroupByOrderId)
			{
			int orderId = group.Key;
			List<Dt_InboundOrderDetail> groupDetails = group.ToList();
			List<string> groupBarCodes = groupDetails.Select(d => d.Barcode).ToList();

			orderIdBarCodeDict[orderId] = groupBarCodes;

			Dt_InboundOrder currentInboundOrder = null;
			if (!updateInboundOrders.TryGetValue(orderId, out currentInboundOrder))
			{
			currentInboundOrder = _inboundOrderRepository.Db
			.Queryable<Dt_InboundOrder>()
			.Where(x => x.Id == orderId)
			.Includes(x => x.Details)
			.First();

			if (currentInboundOrder == null)
			{
			_unitOfWorkManage.RollbackTran();
			return WebResponseContent.Instance.Error($"æªæ¾å°å¥åºåIDä¸º {orderId} çåæ®");
			}
			updateInboundOrders[orderId] = currentInboundOrder;
			}

			foreach (var detail in groupDetails)
			{
			detail.ReceiptQuantity = detail.NoStockOutQty;
			detail.OverInQuantity = detail.NoStockOutQty;

			if (detail.OrderQuantity == detail.OverInQuantity)
			{
			detail.OrderDetailStatus = OrderDetailStatusEnum.Over.ObjToInt();
			}
			updateInboundDetails.Add(detail);

			//æ·»å åºååå¨è®°å½
			Dt_StockQuantityChangeRecord changeRecord = new Dt_StockQuantityChangeRecord
			{
			StockDetailId = detail.Id,
			PalleCode = DateTime.Now.ToString(),
			MaterielCode = detail.MaterielCode,
			MaterielName = detail.MaterielName ?? "",
			BatchNo = detail.BatchNo ?? "",
			OriginalSerilNumber = detail.Barcode,
			NewSerilNumber = "",
			OrderNo = currentInboundOrder.InboundOrderNo,
			TaskNum = 0,
			ChangeType = (int)StockChangeTypeEnum.Inbound,
			ChangeQuantity = detail.NoStockOutQty,
			BeforeQuantity = detail.OverInQuantity - detail.NoStockOutQty,
			AfterQuantity = detail.OverInQuantity,
			SupplyCode = detail.SupplyCode ?? "",
			WarehouseCode = detail.WarehouseCode ?? "",
			Remark = $"èæå¥åº"
			};
			changeRecords.Add(changeRecord);
			}

			var inboundOrder = updateInboundOrders[orderId];
			int totalDetailCount = inboundOrder.Details.Count;

			int finishedDetailCount = inboundOrder.Details.Count(x => x.OrderDetailStatus == OrderDetailStatusEnum.Over.ObjToInt())
			+ groupDetails.Count(x => x.OrderDetailStatus == OrderDetailStatusEnum.Over.ObjToInt());

			inboundOrder.OrderStatus = totalDetailCount == finishedDetailCount
			? InOrderStatusEnum.å¥åºå®æ.ObjToInt()
			: InOrderStatusEnum.å¥åºä¸.ObjToInt();
			}

			if (updateInboundDetails.Any())
			{
			_inboundOrderDetailService.Db.Updateable(updateInboundDetails).ExecuteCommand();
			}
			if (updateInboundOrders.Any())
			{
			// æ¹éæ´æ°å¥åºä¸»å
			_inboundOrderService.Db.Updateable(updateInboundOrders.Values.ToList()).ExecuteCommand();
			}

			// 7. å¾ªç¯åç»ç»æï¼è°ç¨MESåä¼ æ¹æ³ï¼æå¥åºååç»åä¼ ï¼
			foreach (var kvp in orderIdBarCodeDict)
			{
			int orderId = kvp.Key;
			List<string> barCodeList = kvp.Value;
			//å¥åºåä¼ MES
			NoStockOutBatchInOrderFeedbackToMes(orderId, barCodeList);
			}

			//åªå¯¹åºåºæ¡ç çåºåºåæç»è¿è¡è®¡ç®åä¼
			List<Dt_OutboundOrderDetail> outboundOrderDetail = outboundOrder.Details
			.Where(x => !string.IsNullOrWhiteSpace(x.documentsNO)
			&& noStockOutSubmit.BarCodeSubmit.Any(barcode =>
			x.documentsNO.IndexOf(barcode, StringComparison.OrdinalIgnoreCase) >= 0))
			.ToList();

			foreach (var item in outboundOrderDetail)
			{
			item.LockQuantity += item.NoStockOutQty;
			item.OverOutQuantity += item.NoStockOutQty;
			item.CurrentDeliveryQty += item.NoStockOutQty;
			//æ·»å åä¼ MESåæ°
			List<Barcodes> barcodesList = new List<Barcodes>();
			List<Barcodes> documentsNOList = new List<Barcodes>();
			if (!string.IsNullOrEmpty(item.ReturnJsonData))
			{
			barcodesList = JsonConvert.DeserializeObject<List<Barcodes>>(item.ReturnJsonData) ?? new List<Barcodes>();
			}
			if (!string.IsNullOrEmpty(item.documentsNO) && item.documentsNO!="")
			{
			documentsNOList = JsonConvert.DeserializeObject<List<Barcodes>>(item.documentsNO) ?? new List<Barcodes>();
			}
			foreach (var documentsNO in documentsNOList)
			{
			barcodesList.Add(documentsNO);
			}
			JsonSerializerSettings settings = new JsonSerializerSettings
			{
			ContractResolver = new CamelCasePropertyNamesContractResolver()
			};
			item.ReturnJsonData = JsonConvert.SerializeObject(barcodesList, settings);
			//æ·»å åºååå¨è®°å½
			Dt_StockQuantityChangeRecord changeRecord = new Dt_StockQuantityChangeRecord
			{
			StockDetailId = item.Id,
			PalleCode = DateTime.Now.ToString(),
			MaterielCode = item.MaterielCode,
			MaterielName = item.MaterielName ?? "",
			BatchNo = item.BatchNo ?? "",
			OriginalSerilNumber = item.ReturnJsonData,
			NewSerilNumber = "",
			OrderNo = outboundOrder.OrderNo,
			TaskNum = 0,
			ChangeType = (int)StockChangeTypeEnum.Inbound,
			ChangeQuantity = -item.NoStockOutQty,
			BeforeQuantity = item.OrderQuantity,
			AfterQuantity = item.OrderQuantity - item.OverOutQuantity,
			SupplyCode = item.SupplyCode ?? "",
			WarehouseCode = item.WarehouseCode ?? "",
			Remark = $"èæåºåº"
			};
			changeRecords.Add(changeRecord);
			outboundOrderDetails.Add(item);
			}

			_outboundOrderDetailService.UpdateData(outboundOrderDetails);
			//æ¹éæ·»å åºååå¨è®°å½
			if (changeRecords.Any())
			{
			_stockQuantityChangeRecordService.Db.Insertable(changeRecords).ExecuteCommand();
			}
			// æ£æ¥åºåºåæ¯å¦å®æ
			if (CheckOutboundOrderCompleted(outboundOrder.OrderNo))
			{
			outboundOrder.OrderStatus = OutOrderStatusEnum.åºåºå®æ.ObjToInt();

			}
			else
			{
			outboundOrder.OrderStatus = OutOrderStatusEnum.åºåºä¸.ObjToInt();
			}
			_outboundOrderService.UpdateData(outboundOrder);
			_unitOfWorkManage.CommitTran();
			//åºåºåä¼ MES
			_feedbackMesService.OutboundFeedback(outboundOrder.OrderNo);

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


			public WebResponseContent NoStockOutBatchInOrderFeedbackToMes(int id,List<string> barCodeList)
			{
			WebResponseContent content = new WebResponseContent();
			try
			{
			var inboundOrder = _inboundOrderRepository.Db.Queryable<Dt_InboundOrder>()
			.Where(x => x.Id == id)
			.First();

			List<Dt_MesReturnRecord> returnRecords = _mesReturnRecord.QueryData(x => x.OrderNo == inboundOrder.InboundOrderNo && x.OrderId == inboundOrder.Id && x.ReturnStatus == 2);
			foreach (var item in returnRecords)
			{
			HttpResponseResult<MesResponseDTO> httpResponse = _httpClientHelper.Post<MesResponseDTO>(item.ApiUrl, item.RequestData);
			item.ReturnCount += 1;
			bool success = httpResponse.IsSuccess && httpResponse.Data.Code == "200";
			item.ReturnStatus = success ? 1 : 2;
			item.HttpStatusCode = httpResponse.StatusCode.ObjToInt();
			item.LastReturnTime = DateTime.Now;
			item.ResponseData = httpResponse.Content;
			item.SuccessTime = httpResponse.IsSuccess ? DateTime.Now : null;

			//List<Dt_InboundOrderDetail> details=new List<Dt_InboundOrderDetail>();
			//foreach (var y in item.DetailsId.Split(','))
			//{
			// details.Add( _inboundOrderDetailRepository.QueryFirst(x => x.Id == Convert.ToInt32(y)));
			//}
			}
			_mesReturnRecord.UpdateData(returnRecords);

			var inboundOrderDetail = _inboundOrderRepository.Db.Queryable<Dt_InboundOrderDetail>()
			.Where(x => x.OrderId == inboundOrder.Id && x.OrderDetailStatus == (int)OrderDetailStatusEnum.Over && x.ReturnToMESStatus == 0)
			.ToList();

			var detail = inboundOrderDetail.Where(x => barCodeList.Contains(x.Barcode)).ToList();

			if (inboundOrder.OrderType == (int)InOrderTypeEnum.AllocatInbound)//è°æ¨å¥åº
			{
			var allocate = _inboundOrderRepository.Db.Queryable<Dt_AllocateOrder>().Where(x => x.OrderNo == inboundOrder.InboundOrderNo).First();
			var allocatefeedmodel = new AllocateDto
			{
			ReqCode = Guid.NewGuid().ToString(),
			ReqTime = DateTime.Now.ToString(),
			BusinessType = "3",
			FactoryArea = inboundOrder.FactoryArea,
			OperationType = 1,
			Operator = App.User.UserName,
			OrderNo = inboundOrder.UpperOrderNo,
			fromWarehouse = allocate?.FromWarehouse ?? "",
			toWarehouse = allocate?.ToWarehouse ?? "",
			Details = NoStockOutGetAllocateDtoDetails(detail)
			};

			if (allocatefeedmodel.Details.Count <= 0)
			{
			throw new Exception("æªæ¾å°éè¦åä¼ çæ°æ®");
			}

			var response = NoStockOutresponseModel(inboundOrder, 3, null, allocatefeedmodel);

			if (response != null && response.IsSuccess)
			{
			_inboundOrderRepository.Db.Updateable<Dt_InboundOrderDetail>().SetColumns(it => new Dt_InboundOrderDetail { ReturnToMESStatus = 1 })
			.Where(it => it.OrderId == inboundOrder.Id && barCodeList.Contains(it.Barcode)).ExecuteCommand();
			_inboundOrderRepository.Db.Updateable<Dt_InboundOrder>().SetColumns(it => new Dt_InboundOrder { ReturnToMESStatus = 1 })
			.Where(it => it.Id == inboundOrder.Id).ExecuteCommand();
			}
			else
			{
			_inboundOrderRepository.Db.Updateable<Dt_InboundOrderDetail>().SetColumns(it => new Dt_InboundOrderDetail { ReturnToMESStatus = 2 })
			.Where(it => it.OrderId == inboundOrder.Id && barCodeList.Contains(it.Barcode)).ExecuteCommand();
			_inboundOrderRepository.Db.Updateable<Dt_InboundOrder>().SetColumns(it => new Dt_InboundOrder { ReturnToMESStatus =2})
			.Where(it => it.Id == inboundOrder.Id).ExecuteCommand();
			return content.Error("åä¼ MESå¤±è´¥");
			}
			}
			else
			{
			var feedmodel = new FeedbackInboundRequestModel
			{
			reqCode = Guid.NewGuid().ToString(),
			reqTime = DateTime.Now.ToString(),
			business_type = inboundOrder.BusinessType,
			factoryArea = inboundOrder.FactoryArea,
			operationType = 1,
			Operator = App.User.UserName,
			orderNo = inboundOrder.UpperOrderNo,
			status = inboundOrder.OrderStatus,
			details = NoStockOutFeedbackInboundDetailsModelDto(detail)
			};

			if (feedmodel.details.Count <= 0)
			{
			throw new Exception("æªæ¾å°éè¦åä¼ çæ°æ®");
			}
			var response = NoStockOutresponseModel(inboundOrder, 3, feedmodel);

			if (response != null && response.IsSuccess)
			{
			_inboundOrderRepository.Db.Updateable<Dt_InboundOrderDetail>().SetColumns(it => new Dt_InboundOrderDetail { ReturnToMESStatus = 1 })
			.Where(it => it.OrderId == inboundOrder.Id && barCodeList.Contains(it.Barcode)).ExecuteCommand();
			_inboundOrderRepository.Db.Updateable<Dt_InboundOrder>().SetColumns(it => new Dt_InboundOrder { ReturnToMESStatus = 1 })
			.Where(it => it.Id == inboundOrder.Id).ExecuteCommand();
			}
			else
			{
			_inboundOrderRepository.Db.Updateable<Dt_InboundOrderDetail>().SetColumns(it => new Dt_InboundOrderDetail { ReturnToMESStatus = 2 }).Where(it => it.OrderId == inboundOrder.Id && barCodeList.Contains(it.Barcode)).ExecuteCommand();
			_inboundOrderRepository.Db.Updateable<Dt_InboundOrder>().SetColumns(it => new Dt_InboundOrder { ReturnToMESStatus = 2 })
			.Where(it => it.Id == inboundOrder.Id).ExecuteCommand();
			return content.Error("åä¼ MESå¤±è´¥");
			}
			}

			return content.OK("åä¼ MESæå");
			}
			catch (Exception ex)
			{
			return content.Error(ex.Message);
			}
			}

			public List<AllocateDtoDetail> NoStockOutGetAllocateDtoDetails(List<Dt_InboundOrderDetail> inboundOrderDetails)
			{
			var groupedData = inboundOrderDetails.GroupBy(item => new { item.MaterielCode, item.lineNo, item.BarcodeUnit, item.WarehouseCode })
			.Select(group => new AllocateDtoDetail
			{
			MaterialCode = group.Key.MaterielCode,
			LineNo = group.Key.lineNo,
			WarehouseCode = group.Key.WarehouseCode,
			Qty = group.Sum(x => x.BarcodeQty),
			Unit = group.Key.BarcodeUnit,
			Barcodes = group.Select(row => new BarcodeInfo
			{
			Barcode = row.Barcode,
			Qty = row.BarcodeQty,
			BatchNo = row.BatchNo,
			SupplyCode = row.SupplyCode,
			Unit = row.BarcodeUnit
			}).ToList()
			}).ToList();
			return groupedData;
			}
			public List<FeedbackInboundDetailsModel> NoStockOutFeedbackInboundDetailsModelDto(List<Dt_InboundOrderDetail> inboundOrderDetails )
			{
			var groupedData = inboundOrderDetails.GroupBy(item => new { item.MaterielCode, item.lineNo, item.BarcodeUnit, item.WarehouseCode })
			.Select(group => new FeedbackInboundDetailsModel
			{
			materialCode = group.Key.MaterielCode,
			lineNo = group.Key.lineNo,
			warehouseCode = group.Key.WarehouseCode,
			qty = group.Sum(x => x.BarcodeQty),
			unit = group.Key.BarcodeUnit,
			barcodes = group.Select(row => new FeedbackBarcodesModel
			{
			barcode = row.Barcode,
			qty = row.BarcodeQty
			}).ToList()
			}).ToList();
			return groupedData;
			}

			public HttpResponseResult<MesResponseDTO> NoStockOutresponseModel(Dt_InboundOrder order, int InterfaceType, FeedbackInboundRequestModel model = null, AllocateDto allocateDto = null)
			{
			HttpResponseResult<MesResponseDTO> httpResponseResult = new HttpResponseResult<MesResponseDTO>();
			string reqCode = Guid.NewGuid().ToString();
			string reqTime = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");
			string requestData = string.Empty;
			string apiUrl = string.Empty;
			if (model != null)
			{
			apiUrl = AppSettings.GetValue("AldMaterialWarehousing");
			httpResponseResult = _httpClientHelper.Post<MesResponseDTO>(apiUrl, model.Serialize());
			requestData = model.Serialize();
			}
			else
			{
			apiUrl = AppSettings.GetValue("AldAllocationOperation");
			httpResponseResult = _httpClientHelper.Post<MesResponseDTO>(apiUrl, allocateDto.Serialize());
			requestData = allocateDto.Serialize();
			}
			httpResponseResult.ApiUrl = apiUrl;
			bool isSuccess = httpResponseResult.IsSuccess && httpResponseResult.Data.Code == "200";
			string message = "æå";
			if (!isSuccess)
			{
			if (!httpResponseResult.IsSuccess)
			{
			message = $"MESæ¥å£è¿åéè¯¯ï¼HTTPä»£ç ï¼{httpResponseResult.StatusCode}ï¼ä¿¡æ¯ï¼{httpResponseResult.ErrorMessage}";
			}
			else if (httpResponseResult?.Data?.Code != "200")
			{
			message = $"è°ç¨MESæ¥å£å¤±è´¥ï¼ä»£ç ï¼{httpResponseResult?.Data?.Code}ï¼ä¿¡æ¯ï¼{httpResponseResult?.Data?.Message}";
			}
			}
			Dt_MesReturnRecord mesReturnRecord = new Dt_MesReturnRecord()
			{
			ApiUrl = httpResponseResult.ApiUrl,
			InterfaceType = InterfaceType,
			OrderId = order.Id,
			OrderNo = order.InboundOrderNo,
			RequestCode = reqCode,
			RequestData = requestData,
			FailureReason = message,
			LastReturnTime = DateTime.Now,
			HttpStatusCode = httpResponseResult.StatusCode.ObjToInt(),
			ResponseData = httpResponseResult.Content,
			ReturnType = 0,
			ReturnCount = 1,
			ReturnStatus = httpResponseResult.IsSuccess ? 1 : 2,
			SuccessTime = httpResponseResult.IsSuccess ? DateTime.Now : null
			};
			_unitOfWorkManage.Db.Insertable(mesReturnRecord).ExecuteCommand();

			return httpResponseResult;
			}
			public bool CheckOutboundOrderCompleted(string orderNo)
			{
			Dt_OutboundOrder outboundOrder = _outboundOrderService.Db.Queryable<Dt_OutboundOrder>().Where(x => x.OrderNo == orderNo).First();
			if (outboundOrder == null) return false;

			List<Dt_OutboundOrderDetail> details = _outboundOrderDetailService.Db.Queryable<Dt_OutboundOrderDetail>().Where(x => x.OrderId == outboundOrder.Id).ToList();

			// æ£æ¥æææç»çå·²åºæ°éæ¯å¦é½çäºåæ®æ°é
			return details.All(x => x.OverOutQuantity >= x.OrderQuantity - x.MoveQty);
			}

			public WebResponseContent GetPurchaseOrderByBarcode(string barcode)
			{
			try
			{
			Dt_InboundOrderDetail inboundOrderDetail = _stockInfoDetailService.Db.Queryable<Dt_InboundOrderDetail>().Where(x => x.Barcode == barcode && x.OrderDetailStatus != OrderDetailStatusEnum.Over.ObjToInt()).First();
			if (inboundOrderDetail == null)
			{
			inboundOrderDetail = _stockInfoDetailService.Db.Queryable<Dt_InboundOrderDetail>().Where(x => x.OutBoxbarcodes == barcode && x.OrderDetailStatus != OrderDetailStatusEnum.Over.ObjToInt()).First();

			if(inboundOrderDetail == null)
			{
			return WebResponseContent.Instance.Error($"æªæ¾å°è¯¥æ¡ç {barcode}çå¥åºæç»æèæç»ç¶æå·²å¥æºä»å®æ");
			}
			}
			Dt_InboundOrder inboundOrder = _inboundOrderRepository.QueryFirst(x => x.Id == inboundOrderDetail.OrderId && x.OrderStatus != InOrderStatusEnum.å¥åºå®æ.ObjToInt());
			if (inboundOrder == null)
			{
			return WebResponseContent.Instance.Error($"è¯¥å¥åºå{inboundOrder}ç¶æå·²å¥æºä»å®æ");
			}
			var resultData = new { purchaseOrderNo = inboundOrder.UpperOrderNo };

			return WebResponseContent.Instance.OK("æ¥è¯¢éè´åæå", data: resultData);
			}
			catch (Exception ex)
			{
			return WebResponseContent.Instance.Error(ex.Message);
			}
			}
			#endregion

			public WebResponseContent UnPalletQuantity(string orderNo)
			{
			// åå§åè¿åDTOï¼é»è®¤å¼é½ä¸º0ï¼é¿ånullï¼
			var resultDTO = new PalletSumQuantityDTO
			{
			StockSumQuantity = 0,
			StockCount = 0,
			UniqueUnit = ""
			};
			WebResponseContent content = new WebResponseContent();
			try
			{
			if (string.IsNullOrWhiteSpace(orderNo))
			{
			return content.Error("ä¼ å¥çè®¢åå·orderNoä¸ºç©ºæç©ºç½");
			}
			var orderDetail = Db.Queryable<Dt_PickingRecord>().Where(s => s.OrderNo == orderNo).ToList();
			if (orderDetail == null)
			{
			return content.Error("æªæ¾å°åæ®");
			}
			var unitGroups = orderDetail.GroupBy(d => d.BarcodeUnit).ToList();
			if (unitGroups.Count == 1)
			{
			resultDTO.UniqueUnit = unitGroups.First().Key;
			}
			else
			{
			resultDTO.UniqueUnit = "";
			}
			var validDetails = _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>().Where(s => s.OrderNo == orderNo).ToList();
			resultDTO.StockSumQuantity = orderDetail.Sum(d => d.PickQuantity);
			resultDTO.StockCount = orderDetail.Count;
			if (validDetails.Any())
			{
			resultDTO.StockSumQuantity -= validDetails.Sum(d => d.StockQuantity);
			// æç»è®°å½æ°ï¼ç¬¦åæ¡ä»¶çææè®°å½æ¡æ°
			resultDTO.StockCount -= validDetails.Count;
			}
			return content.OK("", resultDTO);
			}
			catch (Exception ex)
			{
			return content.Error("SumQuantity ç»è®¡åºåæ°éå¤±è´¥ï¼è®¢åå·ï¼{OrderNo}");
			}
			}

			public WebResponseContent BarcodeMaterielGroup(BarcodeMaterielGroupDTO materielGroupDTO)
			{

			WebResponseContent content = new WebResponseContent();
			try
			{
			(bool, string, object?) result2 = ModelValidate.ValidateModelData(materielGroupDTO);
			if (!result2.Item1) return content = WebResponseContent.Instance.Error(result2.Item2);

			// materielGroupDTO.WarehouseCode
			var code = _warehouseAreaRepository.Db.Queryable<Dt_WarehouseArea>().Where(x => x.Code == materielGroupDTO.WarehouseType).Select(x => x.Code).First();
			if (string.IsNullOrEmpty(code))
			{
			return content = WebResponseContent.Instance.Error($"ä»åºä¸æ²¡æè¯¥{materielGroupDTO.WarehouseType}ç¼å·ã");
			}

			if (materielGroupDTO.orderTypes == InOrderTypeEnum.ReCheck.ObjToInt())
			{
			var dborder = _reCheckOrderService.Db.Queryable<Dt_ReCheckOrder>().First(x => x.OrderNo == materielGroupDTO.OrderNo);
			if (dborder != null && (dborder.SignSeq == 0 \|\| dborder.SignSeq == 1))
			{
			return content.Error("åªææ¿å°éæ£ç»ææè½å¥åºï¼");
			}


			}
			// Dt_InboundOrder inboundOrder = GetInboundOrder(materielGroupDTO.OrderNo);

			var dbinboundOrderDetails = Db.Queryable<Dt_PickingRecord>().Where(x => x.OrderNo == materielGroupDTO.OrderNo && !x.IsCancelled && x.Barcode == materielGroupDTO.Barcodes).ToList();

			if (dbinboundOrderDetails != null && !dbinboundOrderDetails.Any())
			{
			return content = WebResponseContent.Instance.Error($"åæ®ä¸æ²¡æè¯¥{materielGroupDTO.Barcodes}æ¡ç æ°æ®ã");
			}

			List<string?> materielCodes = dbinboundOrderDetails.GroupBy(x => x.Barcode).Select(x => x.Key).ToList();

			Dt_StockInfo? stockInfo = _stockService.StockInfoService.GetStockByPalletCode(materielGroupDTO.PalletCode);



			(bool, string, object?) result = CheckMaterielGroupParam(materielGroupDTO, materielCodes, stockInfo);
			if (!result.Item1) return content = WebResponseContent.Instance.Error(result.Item2);

			if (stockInfo == null)
			{
			stockInfo = new Dt_StockInfo() { PalletType = (int)PalletTypeEnum.None, LocationType = materielGroupDTO.locationType.ObjToInt() };
			stockInfo.Details = new List<Dt_StockInfoDetail>();
			}
			var inboindId = 0; Dt_InboundOrder dt_InboundOrder = null;
			var orderno = dbinboundOrderDetails.First().OrderNo;
			var dbinbound = _inboundOrderRepository.QueryData(x => x.InboundOrderNo == orderno).FirstOrDefault();
			if (dbinbound == null)
			{
			dt_InboundOrder = new Dt_InboundOrder
			{
			WarehouseId = 0,
			InboundOrderNo = dbinboundOrderDetails.First()?.OrderNo,
			UpperOrderNo = dbinboundOrderDetails.First()?.OrderNo,
			SupplierId = dbinboundOrderDetails.First()?.SupplyCode,
			OrderType = materielGroupDTO.orderTypes,

			BusinessType = materielGroupDTO.orderTypes.ToString(),

			FactoryArea = dbinboundOrderDetails.First()?.FactoryArea,
			Remark = "",
			Details = new List<Dt_InboundOrderDetail>()
			};
			inboindId = _inboundOrderRepository.AddData(dt_InboundOrder);
			}
			else
			{
			dt_InboundOrder = new Dt_InboundOrder { Details = new List<Dt_InboundOrderDetail>() };
			inboindId = dbinbound.Id;
			}

			foreach (var item in dbinboundOrderDetails)
			{
			stockInfo.Details.Add(new Dt_StockInfoDetail
			{
			StockId = stockInfo == null ? 0 : stockInfo.Id,
			Barcode = item.Barcode,
			MaterielCode = item.MaterielCode,
			BatchNo = item.BatchNo,
			Unit = item.BarcodeUnit,
			InboundOrderRowNo = item.lineNo,
			SupplyCode = item.SupplyCode,
			WarehouseCode = materielGroupDTO.WarehouseType,
			StockQuantity = item.PickQuantity,
			BarcodeQty = item.BarcodeQty,
			BarcodeUnit = item.BarcodeUnit,
			FactoryArea = item.FactoryArea,
			Status = 0,
			OrderNo = item.OrderNo,
			BusinessType = materielGroupDTO.orderTypes.ToString(),


			});
			item.WarehouseCode = item.WarehouseCode;

			dt_InboundOrder.Details.Add(new Dt_InboundOrderDetail
			{
			OrderId = inboindId,
			MaterielCode = item.MaterielCode,
			MaterielName = "",
			BatchNo = item.BatchNo,
			OrderQuantity = item.PickQuantity,
			ReceiptQuantity = 0,
			OverInQuantity = 0,
			Unit = item.BarcodeUnit,
			RowNo = 0,
			lineNo = item.lineNo,
			SupplyCode = item.SupplyCode,
			WarehouseCode = item.WarehouseCode,
			Barcode = item.Barcode,
			OutBoxbarcodes = "",
			BarcodeQty = (decimal)item.BarcodeQty,
			BarcodeUnit = item.BarcodeUnit
			});
			}

			_inboundOrderDetailService.Db.Insertable<Dt_InboundOrderDetail>(dt_InboundOrder.Details);
			if (stockInfo.Id == 0)
			{
			stockInfo.PalletCode = materielGroupDTO.PalletCode;
			stockInfo.StockStatus = StockStatusEmun.ç»çæå.ObjToInt();
			}
			stockInfo.PalletType = (int)PalletTypeEnum.None;

			List<int> updateDetailIds = dbinboundOrderDetails.Select(x => x.Id).ToList();

			try
			{
			_unitOfWorkManage.BeginTran();

			_stockService.StockInfoService.AddMaterielGroup(stockInfo);
			_unitOfWorkManage.CommitTran();
			return WebResponseContent.Instance.OK();
			}
			catch (Exception ex)
			{
			_unitOfWorkManage.RollbackTran();
			return WebResponseContent.Instance.Error(ex.Message);
			}
			}
			catch (Exception ex)
			{
			content = WebResponseContent.Instance.Error(ex.Message);
			}
			finally
			{

			}
			return content;

			}


			public (bool, string, object?) CheckMaterielGroupParam(BarcodeMaterielGroupDTO materielGroupDTO, List<string> barcodeCodes, Dt_StockInfo stockInfo)
			{
			(bool, string, object?) result = ModelValidate.ValidateModelData(materielGroupDTO);
			if (!result.Item1) return result;

			if (_taskRepository.QueryFirst(x => x.PalletCode == materielGroupDTO.PalletCode) != null)
			{
			return (false, "è¯¥æçå·å·²æä»»å¡", materielGroupDTO);
			}

			if (stockInfo != null && !string.IsNullOrEmpty(stockInfo.LocationCode) && stockInfo.StockStatus != StockStatusEmun.ç»çæå.ObjToInt())
			{
			return (false, "å·²ä¸æ¶çæçä¸è½åæ¬¡ç»ç", materielGroupDTO);
			}

			if (_stockService.StockInfoDetailService.ExistBarcodes(barcodeCodes))
			{
			return (false, $"{barcodeCodes[0]} æ¡ç å¨åºåä¸å·²åå¨", materielGroupDTO);
			}



			return (true, "æå", materielGroupDTO);
			}



			}

			#region æ¯æç±»å®ä¹
			@@ -1578,20 +3428,55 @@
			public List<SplitResult> SplitResults { get; set; } = new List<SplitResult>();
			}

			public class ReturnAnalysisResult
			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 bool HasUnallocatedLocks { get; set; }
			public List<Dt_OutStockLockInfo> UnallocatedLocks { get; set; } = new List<Dt_OutStockLockInfo>();
			public decimal UnallocatedLocksReturnQty { 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 HashSet<string> ProcessedBarcodes { get; set; } = new HashSet<string>();
			public List<string> AllBarcodes { get; set; } = new List<string>();
			// ç©ºæçç¸å³å±æ§
			public bool IsEmptyPallet { get; set; }
			public bool HasActiveTasks { get; set; }

			// ä¾¿å©æ¹æ³
			public bool CanReturn => HasItemsToReturn && !HasActiveTasks;
			public bool CanRemove => IsEmptyPallet && !HasActiveTasks;
			}

			public class CancelPickingContext
			{
			public string OrderNo { get; set; }
			public string PalletCode { get; set; }
			public string Barcode { get; set; }
			public string Operator { get; set; }

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