MingHeZhiNeng/DuiDuoJiLiKu.git

			@@ -1,18 +1,45 @@
			ï»¿using Mapster;
			ï»¿using AngleSharp.Dom;
			using log4net.Core;
			using Mapster;
			using Masuit.Tools;
			using Microsoft.EntityFrameworkCore.Storage.ValueConversion.Internal;
			using NewLife;
			using OfficeOpenXml.FormulaParsing.Excel.Functions.Math;
			using OfficeOpenXml.FormulaParsing.Excel.Functions.RefAndLookup;
			using OfficeOpenXml.Table.PivotTable;
			using SixLabors.Fonts.Tables.AdvancedTypographic;
			using SqlSugar;
			using System;
			using System.Collections;
			using System.Collections.Generic;
			using System.Linq;
			using System.Linq.Expressions;
			using System.Reflection;
			using System.Reflection.Metadata;
			using System.Security.Policy;
			using System.Text.RegularExpressions;
			using System.Threading.Tasks;
			using WIDESEA_Cache;
			using WIDESEA_Common;
			using WIDESEA_Core.BaseRepository;
			using WIDESEA_Core.Const;
			using WIDESEA_Core.Enums;
			using WIDESEA_DTO.Basic;
			using WIDESEA_DTO.ERP;
			using WIDESEA_DTO.Location;
			using WIDESEA_DTO.Stock;
			using WIDESEA_DTO.WMS;
			using WIDESEA_IOrderRepository;
			using WIDESEA_IServices;
			using WIDESEA_Model.Models;
			using WIDESEA_Model.Models.Basic;
			using WIDESEA_Model.Models.ERP;
			using WIDESEA_Model.Models.Order;
			using WIDESEA_OrderRepository;
			using WIDESEA_StorageTaskRepository;
			using WIDESEAWCS_BasicInfoRepository;
			using WIDESEAWCS_QuartzJob.Models;
			using static System.Collections.Specialized.BitVector32;

			namespace WIDESEA_StorageTaskServices;

			@@ -31,6 +58,9 @@
			private readonly IDt_AreaInfoRepository _areaInfoRepository; //åºå
			private readonly IDt_StationManagerRepository _stationManagerRepository;
			private readonly ISys_ConfigService _configService;
			private readonly IDt_OrderOutDetailsRepository _orderOutDetailsRepository;
			private readonly IDt_WareAreaInfoRepository _wareAreaInfoRepository;
			private readonly IDt_InventoryRecordRepository _inventoryRecordRepository;

			public Dt_TaskService(IDt_TaskRepository BaseDal,
			IUnitOfWorkManage unitOfWorkManage,
			@@ -44,7 +74,10 @@
			IDt_AreaInfoRepository areaInfoRepository,
			IStockInfoDetailRepository stockInfoDetailRepository,
			IDt_StationManagerRepository stationManagerRepository,
			ISys_ConfigService configService) : base(BaseDal)
			ISys_ConfigService configService,
			IDt_OrderOutDetailsRepository orderOutDetailsRepository,
			IDt_WareAreaInfoRepository wareAreaInfoRepository,
			IDt_InventoryRecordRepository inventoryRecordRepository) : base(BaseDal)
			{
			_unitOfWorkManage = unitOfWorkManage;
			_stockInfoRepository = stockInfoRepository;
			@@ -58,6 +91,9 @@
			_stockInfoDetailRepository = stockInfoDetailRepository;
			_stationManagerRepository = stationManagerRepository;
			_configService = configService;
			_orderOutDetailsRepository = orderOutDetailsRepository;
			_wareAreaInfoRepository = wareAreaInfoRepository;
			_inventoryRecordRepository = inventoryRecordRepository;
			}

			#region å¤é¨æ¥å£æ¹æ³
			@@ -69,25 +105,109 @@
			WebResponseContent content = new WebResponseContent();
			try
			{
			if (task.TaskState.GetTaskStateGroup() == TaskStateGroup.CarryGroup)
			{
			var result1 = UpdateLocationStatus(task.SourceAddress, LocationEnum.Free, task.TaskNum.Value, StatusChangeTypeEnum.AutomaticOutbound);
			await _locationStatusChangeRecordRepository.AddDataAsync(result1.Item1);
			await _locationRepository.UpdateDataAsync(result1.Item2);
			}

			task.TaskState = (int)TaskOutStatusEnum.OutFinish;
			var taskHty = task.Adapt<Dt_Task_Hty>();
			taskHty.FinishTime = DateTime.Now;
			taskHty.OperateType = App.User.UserName != null ? (int)OperateTypeEnum.äººå·¥å®æ : (int)OperateTypeEnum.èªå¨å®æ;
			taskHty.Creater = App.User.UserName != null ? App.User.UserName : "System";
			await _unitOfWorkManage.UseTranAsync(async () =>
			stock.ModifyDate = DateTime.Now;
			stock.LocationCode = task.TargetAddress;
			var result2 = UpdateLocationStatus(task.TargetAddress, LocationEnum.InStock, task.TaskNum.Value, StatusChangeTypeEnum.AutomaticOutbound);

			DtStockInfo_Hty stockInfo_Hty = stock.Adapt<DtStockInfo_Hty>();
			var orderDetails = _orderOutDetailsRepository.QueryData(x => x.PalletCode == task.PalletCode);
			List<Dt_OrderOutDetails_Hty> orderdetailshtys = new List<Dt_OrderOutDetails_Hty>();

			orderDetails.ForEach(item =>
			{
			orderdetailshtys.Add(item.Adapt<Dt_OrderOutDetails_Hty>());
			});

			await ERPAllocateOut(stock);

			//è°æ¨åºåº
			if (task.TaskType == (int)TaskOutboundTypeEnum.OutAllocate)
			{
			if (orderDetails.Count > 0)
			await ERPAllocate(orderDetails.Where(x => x.OrderType == (int)OrderTypeEmun.è°æ¨åºåºå).ToList());
			}
			//å¶ä»åºåº
			else if (task.TaskType == (int)TaskOutboundTypeEnum.OutOther)
			{
			if (orderDetails.Count > 0)
			{
			await ERPMixedSend(orderDetails.Where(x => x.OrderType == (int)OrderTypeEmun.å¶ä»åºåºå).ToList());
			}
			}
			//çäº§é¢æåºåº
			else if (task.TaskType == (int)TaskOutboundTypeEnum.MaterialRequisition)
			{
			if (orderDetails.Count > 0)
			{
			content = await ERPProduction(orderDetails.Where(x => x.OrderType == (int)OrderTypeEmun.çäº§é¢æå).ToList());
			}
			}

			var boxingInfo = await _boxingInfoRepository.QueryFirstNavAsync(x => x.PalletCode == stock.PalletCode);
			if (boxingInfo != null)
			{
			var mergedDetails = boxingInfo.BoxingInfoDetails
			.GroupBy(x => new { x.MaterielCode, x.MaterielName })
			.Select(g => new DtBoxingInfoDetail
			{
			MaterielCode = g.Key.MaterielCode,
			MaterielName = g.Key.MaterielName,
			DemandClassification = g.FirstOrDefault().DemandClassification,
			Warehouse = "WMSåºåºç¼ååº",
			WareHouseId = "205",
			OrderNo = g.FirstOrDefault().OrderNo,
			Unit = g.FirstOrDefault().Unit,
			Specs = g.FirstOrDefault().Specs,
			Weight = g.FirstOrDefault().Weight,
			DrawingNumber = g.FirstOrDefault().DrawingNumber,
			Date = g.FirstOrDefault().Date,
			Remark = g.FirstOrDefault().Remark,
			Quantity = g.Sum(item => item.Quantity),
			})
			.ToList();
			boxingInfo.BoxingInfoDetails = mergedDetails;
			}

			//await _unitOfWorkManage.UseTranAsync(async () =>
			//{
			_unitOfWorkManage.BeginTran();
			await DeleteStockInfoAsync(stock.Id);
			_boxingInfoRepository.UpdateDataNav(boxingInfo);
			await DeleteStockInfoDetailsAsync(stock.StockInfoDetails);
			await AddStockInfoHtyAsync(stockInfo_Hty);
			await _locationStatusChangeRecordRepository.AddDataAsync(result2.Item1);
			await _locationRepository.UpdateDataAsync(result2.Item2);
			await _orderOutDetailsRepository.DeleteDataAsync(orderDetails);
			await SqlSugarHelper.DbWMS.Insertable(orderdetailshtys).ExecuteCommandAsync();

			await DeleteTaskAsync(task.TaskId);
			await AddTaskHtyAsync(taskHty);
			});
			_unitOfWorkManage.CommitTran();
			//});
			content.OK("åºåºå®æ");

			}
			catch (Exception ex)
			{
			_unitOfWorkManage.RollbackTran();
			task.ErrorMessage = ex.Message;
			await BaseDal.UpdateDataAsync(task);
			return content.Error(ex.Message);
			}
			return content;
			}



			#endregion åºåºä»»å¡å®æ

			@@ -103,17 +223,34 @@
			WebResponseContent content = new WebResponseContent();
			try
			{
			// æ´æ°è´§ä½ååºåä¿¡æ¯
			(DtStockInfo updateStock, DtLocationInfo locationInForm, DtLocationInfo locationInfoTo) = UpdateStockLocation(stock, task);
			var taskHty = CreateHistoricalTask(task);
			LogFactory.GetLog("ä»»å¡å®æ").InfoFormat(true, "ç§»åºä»»å¡å®æ", $"è´§ä½å°åï¼{task.TargetAddress},ä¿®æ¹ååºåæ°æ®ï¼{JsonConvert.SerializeObject(updateStock)}ï¼ååè´§ä½æ°æ®ï¼{locationInForm}");
			var locationStart = await _locationRepository.QueryFirstAsync(x => x.LocationCode == task.SourceAddress);
			var locationEnd = await _locationRepository.QueryFirstAsync(x => x.LocationCode == task.TargetAddress);

			// æ§è¡æ°æ®åºäºå¡
			bool isResult = false;
			if (isResult)
			content.OK("ç§»åºä»»å¡å®ææå");
			else
			content.Error("ç§»åºä»»å¡å®æå¤±è´¥");
			task.TaskState = (int)TaskRelocationStatusEnum.AGV_RelocationFinish;
			var taskHty = task.Adapt<Dt_Task_Hty>();
			taskHty.FinishTime = DateTime.Now;
			taskHty.OperateType = App.User.UserName != null ? (int)OperateTypeEnum.äººå·¥å®æ : (int)OperateTypeEnum.èªå¨å®æ;
			taskHty.Creater = App.User.UserName != null ? App.User.UserName : "System";

			if (stock != null)
			{
			stock.ModifyDate = DateTime.Now;
			stock.LocationCode = task.TargetAddress;
			}
			var result1 = UpdateLocationStatus(locationStart.LocationCode, LocationEnum.Free, task.TaskNum.Value, StatusChangeTypeEnum.AutomaticRelocation);
			var result2 = UpdateLocationStatus(locationEnd.LocationCode, LocationEnum.InStock, task.TaskNum.Value, StatusChangeTypeEnum.AutomaticRelocation);
			await _unitOfWorkManage.UseTranAsync(async () =>
			{
			await _locationStatusChangeRecordRepository.AddDataAsync(result1.Item1);
			await _locationRepository.UpdateDataAsync(result1.Item2);
			await _locationStatusChangeRecordRepository.AddDataAsync(result2.Item1);
			await _locationRepository.UpdateDataAsync(result2.Item2);
			if (stock != null)
			_stockInfoRepository.UpdateData(stock);
			await DeleteTaskAsync(task.TaskId);
			await AddTaskHtyAsync(taskHty);
			});
			content.OK("ç§»åºå®æ");
			}
			catch (Exception err)
			{
			@@ -136,25 +273,94 @@
			WebResponseContent content = new WebResponseContent();
			try
			{
			var boxinfo = await _boxingInfoRepository.QueryFirstNavAsync(x => x.PalletCode == task.PalletCode);

			if (boxinfo == null)
			{
			return content.Error("æªæ¾å°ç»çæ°æ®");
			}

			if (task.TaskState.GetTaskStateGroup() == TaskStateGroup.CarryGroup)
			{
			var result1 = UpdateLocationStatus(task.SourceAddress, LocationEnum.Free, task.TaskNum.Value, StatusChangeTypeEnum.AutomaticInbound);
			await _locationStatusChangeRecordRepository.AddDataAsync(result1.Item1);
			await _locationRepository.UpdateDataAsync(result1.Item2);
			}



			var stock = CreateStock(boxinfo, task);

			task.TaskState = (int)TaskInStatusEnum.InFinish;
			var taskHty = task.Adapt<Dt_Task_Hty>();
			taskHty.FinishTime = DateTime.Now;
			taskHty.OperateType = App.User.UserName != null ? (int)OperateTypeEnum.äººå·¥å®æ : (int)OperateTypeEnum.èªå¨å®æ;
			taskHty.Creater = App.User.UserName != null ? App.User.UserName : "System";
			await _unitOfWorkManage.UseTranAsync(async () =>
			{

			var result2 = UpdateLocationStatus(task.TargetAddress, LocationEnum.InStock, task.TaskNum.Value, StatusChangeTypeEnum.AutomaticInbound);

			//await _unitOfWorkManage.UseTranAsync(async () =>
			//{
			_unitOfWorkManage.BeginTran();
			await _stockInfoRepository.AddDataNavAsync(stock);
			await DeleteTaskAsync(task.TaskId);
			await AddTaskHtyAsync(taskHty);
			});
			await _locationStatusChangeRecordRepository.AddDataAsync(result2.Item1);
			await _locationRepository.UpdateDataAsync(result2.Item2);
			_unitOfWorkManage.CommitTran();
			//});
			await ERPAllocate(boxinfo);
			content.OK("å¥åºå®æ");
			}
			catch (Exception ex)
			{
			_unitOfWorkManage.RollbackTran();
			task.ErrorMessage = ex.Message;
			await BaseDal.UpdateDataAsync(task);
			return content.Error(ex.Message);
			}
			return content;
			}


			public DtStockInfo CreateStock(DtBoxingInfo boxingInfo,Dt_Task task)
			{
			var boxDetail = boxingInfo.BoxingInfoDetails.Adapt<List<DtStockInfoDetail>>();
			boxDetail.ForEach(x =>
			{
			x.Status = (int)StockStateEmun.å·²å¥åº;
			});
			var mergedDetails = boxDetail
			.GroupBy(x => new { x.MaterielCode, x.MaterielName })
			.Select(g => new DtStockInfoDetail
			{
			MaterielCode = g.Key.MaterielCode,
			MaterielName = g.Key.MaterielName,
			DemandClassification = g.FirstOrDefault().DemandClassification,
			Warehouse = "æºè½ç«åº",
			WareHouseId = "107",
			OrderNo = g.FirstOrDefault().OrderNo,
			Unit = g.FirstOrDefault().Unit,
			Specs = g.FirstOrDefault().Specs,
			Weight = g.FirstOrDefault().Weight,
			OutboundQuantity = g.FirstOrDefault().OutboundQuantity,
			DrawingNumber = g.FirstOrDefault().DrawingNumber,
			Date = g.FirstOrDefault().Date,
			AllocateWarehouse = g.FirstOrDefault().AllocateWarehouse,
			Remark = g.FirstOrDefault().Remark,
			Quantity = g.Sum(item => item.Quantity),
			})
			.ToList();
			return new DtStockInfo()
			{
			PalletCode = task.PalletCode,
			LocationCode = task.TargetAddress,
			CreateDate = DateTime.Now,
			Creater = "system",
			IsFullExit = boxingInfo.IsFullExit,
			StockInfoDetails = mergedDetails,
			StockStatus = (int)StockStateEmun.å·²å¥åº
			};
			}
			#endregion å¥åºä»»å¡å®æ

			#region AGVæ¬è¿ä»»å¡å®æ
			@@ -163,6 +369,12 @@
			WebResponseContent content = new WebResponseContent();
			try
			{
			var Sourcelocation = await _locationRepository.QueryFirstAsync(x => x.LocationCode == task.SourceAddress);
			var Targetlocation = await _locationRepository.QueryFirstAsync(x => x.LocationCode == task.TargetAddress);

			//UpdateLocationStatus(Sourcelocation, LocationEnum.Free);
			//UpdateLocationStatus(Targetlocation, LocationEnum.InStock);

			task.TaskState = (int)TaskAGVCarryStatusEnum.CarryFinish;
			var taskHty = task.Adapt<Dt_Task_Hty>();
			taskHty.FinishTime = DateTime.Now;
			@@ -248,14 +460,6 @@
			{
			return await CompleteTransferTaskAsync(task, stock);
			}
			else if (task.TaskType.GetTaskTypeGroup() == TaskTypeGroup.CarryGroup)
			{
			return await CompleteCarryTaskAsync(task, stock);
			}
			else if (task.TaskType.GetTaskTypeGroup() == TaskTypeGroup.AcrossFloorGroup)
			{
			return await CompleteAcrossFloorTaskAsync(task, stock);
			}
			else
			{
			return content.Error("æªæ¾å°ä»»å¡ç±»å");
			@@ -264,68 +468,120 @@

			#endregion ä»»å¡å®æ

			#region åæ¶ä»»å¡
			public WebResponseContent TaskCancel(int taskNum)
			{
			WebResponseContent content = new WebResponseContent();
			try
			{
			Dt_Task task = BaseDal.QueryFirst(x => x.TaskNum == taskNum);
			if (task == null)
			{
			return content = WebResponseContent.Instance.Error("æªæ¾å°ä»»å¡ä¿¡æ¯");
			}
			_unitOfWorkManage.BeginTran();
			MethodInfo? methodInfo = GetType().GetMethod(((TaskTypeEnum)task.TaskType) + "TaskCancel");
			if (methodInfo != null)
			{
			WebResponseContent? responseContent = (WebResponseContent?)methodInfo.Invoke(this, new object[] { task });
			if (responseContent != null)
			{
			if (responseContent != null)
			{

			}
			}
			}
			return content = WebResponseContent.Instance.Error("æªæ¾å°ä»»å¡ç±»åå¯¹åºä¸å¡å¤çé»è¾");
			}
			catch (Exception ex)
			{
			_unitOfWorkManage.RollbackTran();
			return content = WebResponseContent.Instance.Error(ex.Message);
			}
			}
			#endregion

			#region è¯·æ±ä»»å¡å¥åº

			public async Task<WebResponseContent> RequestTaskAsync(RequestTaskDto taskDto)
			public async Task<WebResponseContent> RequestInboundTaskAsync(RequestTaskDto taskDto)
			{
			WebResponseContent content = new WebResponseContent();

			try
			{
			var task = await GetByTaskAddress(taskDto.Position, taskDto.TargetAddress);
			var task = BaseDal.QueryFirst(x => x.PalletCode == taskDto.PalletCode);
			if (task != null)
			{
			return content.Error("èµ·ç¹æç»ç¹åå¨ä»»å¡");
			return content.Error("è¯¥æçå·²ç»åå¨ä»»å¡ï¼è¯·å¿éå¤ä¸å");
			}
			var station = _stationManagerRepository.QueryFirst(x => x.stationType == 1 && x.Roadway == "SC1");

			Dt_Task taskNew = new Dt_Task
			var boxingInfo = await _boxingInfoRepository.QueryFirstNavAsync(x => x.PalletCode == taskDto.PalletCode && x.StockStatus == (int)StockStateEmun.ç»çæå);

			if (boxingInfo == null)
			{
			Grade = 1,
			Roadway = "SC1",
			TargetAddress = taskDto.TargetAddress,
			Dispatchertime = DateTime.Now,
			MaterialNo = "",
			NextAddress = station.stationChildCode,
			OrderNo = null,
			PalletCode = taskDto.PalletCode,
			SourceAddress = taskDto.Position,
			CurrentAddress = taskDto.Position,
			TaskState = (int)TaskInStatusEnum.InNew,
			TaskType = (int)TaskInboundTypeEnum.Inbound,
			TaskNum = BaseDal.GetTaskNo().Result,
			CreateDate = DateTime.Now,
			TaskId = 0,
			AGVTaskNum = GenerateUniqueId(),
			Floor = "1F",
			};
			return content.Error("æçä¿¡æ¯ä¸åå¨ï¼è¯·ç¡®è®¤æçå·²ç»çæå");
			}

			foreach (var item in boxingInfo.BoxingInfoDetails)
			{
			var ERPStock = SqlSugarHelper.DBERP.Queryable<ç¨åå³æ¶åºå_ST>().Where(x => x.åå¨å°ç¹åç§° == item.Warehouse && x.æå· == item.MaterielCode && x.åå == item.MaterielName && x.åºåæ°é >= item.Quantity).ToList().FirstOrDefault();
			if (ERPStock == null)
			{
			return content.Error($"ç»çæ°æ®æªå¨ERPåºåæ°æ®ä¸ï¼è¯·äººå·¥ç¡®è®¤æ°æ®æ¯å¦æ£ç¡®");
			}
			}

			var StartAddress = await _locationRepository.QueryFirstAsync(x => x.LocationCode == taskDto.Position);
			if (StartAddress == null)
			{
			return content.Error("èµ·ç¹åºä½æªæ¾å°");
			}
			if (!LocationIsOutBound(StartAddress))
			{
			return content.Error($"èµ·ç¹åºä½{StartAddress.LocationCode}æ¬è¿è·¯å¾è¢«å ç¨ï¼è¯·äººå·¥ç¡®è®¤åä¸åä»»å¡");
			}
			Dt_Task taskNew = new Dt_Task();
			var area = _areaInfoRepository.QueryFirst(x => x.AreaID == taskDto.AreaId);
			if (area == null)
			{
			return content.Error("è¯·éæ©å¥åºåºå");
			}

			var locationInfo = await _locationRepository.QueryDataAsync(x => x.AreaId == area.AreaID && x.EnalbeStatus == 1 && x.LocationStatus == (int)LocationEnum.Free);

			var taskArea = BaseDal.QueryData(x => x.TargetAddress == area.AreaName && x.TaskType == (int)TaskInboundTypeEnum.Inbound);

			if (locationInfo.Count - taskArea.Count <= 0)
			{
			return content.Error("è¯¥åºåæ å¯ç¨åºä½ï¼è¯·éæ©å¶ä»åºå");
			}

			switch (taskDto.AreaId)
			{
			case 1:
			taskNew = InboundStakerArea(taskDto, StartAddress, area);
			break;
			case 2:
			case 3:
			case 4:
			case 5:
			case 6:
			taskNew = InboundAGVCacheArea(taskDto, StartAddress, area);
			break;
			default:
			return content.Error("è¯·éæ©æ£ç¡®çåºåä¿¡æ¯");
			}
			var taskDTO = CreateListTaskDTO(taskNew);

			var result = UpdateLocationStatus(StartAddress.LocationCode, LocationEnum.InStockDisable, taskNew.TaskNum.Value, (int)StatusChangeTypeEnum.AutomaticInbound);

			await _unitOfWorkManage.UseTranAsync(async () =>
			{
			await _locationStatusChangeRecordRepository.AddDataAsync(result.Item1);
			await _locationRepository.UpdateDataAsync(result.Item2);
			BaseDal.AddData(taskNew);
			});
			return content = await SendWCSTask(taskDTO);
			}
			catch (Exception err)
			{
			content.Error(err.Message);
			}

			return content;
			}

			/// <summary>
			/// æ´æ°ä»»å¡è´§ä½
			/// </summary>
			/// <param name="input"></param>
			/// <returns></returns>
			public async Task<WebResponseContent> UpdateExistingTask(RequestTaskDto input)
			{
			WebResponseContent content = new WebResponseContent();
			try
			{
			var task = await BaseDal.QueryFirstAsync(x => x.PalletCode == input.PalletCode);
			if (task == null)
			return content.Error($"ææªæ¾å°ã{input.PalletCode}ãçä»»å¡");

			return content = await UpdateExistingTask(input, task);
			}
			catch (Exception err)
			{
			@@ -333,53 +589,142 @@
			}
			}

			public Dt_Task InboundStakerArea(RequestTaskDto taskDto, DtLocationInfo StartAddress,Dt_AreaInfo area)
			{
			var station = _stationManagerRepository.QueryFirst(x => x.stationType == 1 && x.Roadway == "SC1");

			return new Dt_Task
			{
			Grade = 1,
			Roadway = "SC1",
			TargetAddress = area.AreaName,
			Dispatchertime = DateTime.Now,
			MaterialNo = "",
			NextAddress = station.stationChildCode,
			OrderNo = null,
			PalletCode = taskDto.PalletCode,
			SourceAddress = taskDto.Position,
			CurrentAddress = taskDto.Position,
			TaskState = (int)TaskInStatusEnum.InNew,
			TaskType = (int)TaskInboundTypeEnum.Inbound,
			TaskNum = BaseDal.GetTaskNo().Result,
			CreateDate = DateTime.Now,
			TaskId = 0,
			AGVTaskNum = GenerateUniqueId(),
			Floor = "1F",
			};
			}

			public Dt_Task InboundAGVCacheArea(RequestTaskDto taskDto, DtLocationInfo StartAddress, Dt_AreaInfo area)
			{
			WebResponseContent content = new WebResponseContent();

			Dt_Task taskNew = new Dt_Task();
			if (StartAddress.Floor != area.Spare1)
			{
			taskNew = RequestAcrossFloorTask(StartAddress, area, (int)TaskInboundTypeEnum.Inbound, taskDto);
			}
			else
			{
			taskNew = RequestAGVCarryTask(StartAddress, GetAGVEmptyCacheLocation(area.AreaID, StartAddress).Result, (int)TaskInboundTypeEnum.Inbound, taskDto);
			}
			return taskNew;

			}
			#endregion è¯·æ±ä»»å¡å¥åº

			#region è¯·æ±åºåº
			#region æ´æ°ä»»å¡ç¶æ


			/// <summary>
			/// è¯·æ±æçä»»å¡
			/// æ´æ°ä»»å¡è´§ä½
			/// </summary>
			/// <param name="position">ç®æ ä½ç½®</param>
			/// <param name="tag">æçç±»åï¼1ï¼å®çï¼2ï¼ç©ºçï¼</param>
			/// <param name="areaCode">åºåç¼ç </param>
			/// <param name="roadways">å··éç¼ç éå</param>
			/// <returns>è¿åç»æé</returns>
			public async Task<WebResponseContent> RequestOutTaskAsync(RequestTaskDto taskDto)
			/// <param name="input"></param>
			/// <returns></returns>
			public async Task<WebResponseContent> UpdateTaskStatus(int taskNum, int taskState)
			{
			WebResponseContent content = new WebResponseContent();
			try
			{
			var task = await GetByTaskAddress(taskDto.Position, taskDto.TargetAddress);
			var task = await BaseDal.QueryFirstAsync(x => x.TaskNum == taskNum);
			if (task == null)
			return content.Error("æªæ¾å°ä»»å¡");

			task.TaskState = taskState;
			var asb = await BaseDal.UpdateDataAsync(task);
			if (asb)
			content.OK();
			else
			content.Error();
			}
			catch (Exception ex)
			{
			content.Error(ex.Message);
			}
			return content;
			}

			#endregion

			#region è¯·æ±åºåº
			/// <summary>
			/// æå¨åºåºè³ç¼ååºå
			/// </summary>
			/// <param name="palletCode"></param>
			/// <returns></returns>
			public async Task<WebResponseContent> OutBoundTaskAsync(string palletCode,string remark)
			{
			WebResponseContent content = new WebResponseContent();
			try
			{
			DtStockInfo stcok = await _stockInfoRepository.QueryFirstNavAsync(x => x.PalletCode == palletCode);
			if (stcok == null)
			{
			return content.Error("æçä¿¡æ¯ä¸åå¨ï¼è¯·ç¡®è®¤æçå·²å¥åºæå");
			}

			if (stcok.LocationInfo.LocationStatus != (int)LocationEnum.InStock)
			{
			return content.Error("è¯·ç¡®è®¤åºåè´§ä½ç¶ææ¯å¦ä¸ºæè´§");
			}
			var task = await BaseDal.QueryFirstAsync(x => x.PalletCode == palletCode);
			if (task != null)
			{
			return content.Error("èµ·ç¹æç»ç¹åå¨ä»»å¡");
			return content.Error("è¯¥æçå·²åå¨ä»»å¡");
			}
			var station = _stationManagerRepository.QueryFirst(x => x.stationType == 1 && x.Roadway == "SC1");

			Dt_Task taskNew = new Dt_Task
			var location = await _locationRepository.QueryFirstAsync(x => x.LocationCode == stcok.LocationCode);
			if (location.AreaId == 2)
			{
			Grade = 1,
			Roadway = "SC1",
			TargetAddress = taskDto.TargetAddress,
			Dispatchertime = DateTime.Now,
			MaterialNo = "",
			NextAddress = station.stationChildCode,
			OrderNo = null,
			PalletCode = taskDto.PalletCode,
			SourceAddress = taskDto.Position,
			CurrentAddress = taskDto.Position,
			TaskState = (int)TaskOutStatusEnum.OutNew,
			TaskType = (int)TaskOutboundTypeEnum.Outbound,
			TaskNum = BaseDal.GetTaskNo().Result,
			CreateDate = DateTime.Now,
			TaskId = 0,
			AGVTaskNum = GenerateUniqueId(),
			Floor = "1F",
			};
			var taskDTO = CreateListTaskDTO(taskNew);
			return content.Error("è¯¥æçåºåå·²å¨åºåºç¼ååº");
			}

			return content = await SendWCSTask(taskDTO);
			Dt_Task taskNew = await RequestOutboundTaskAsync(new RequestTaskDto { PalletCode = palletCode, AreaId = 2, Position = stcok.LocationCode, TaskType = (int)TaskOutboundTypeEnum.Outbound });
			List<Dt_InventoryRecord> records = new List<Dt_InventoryRecord>();
			stcok.StockInfoDetails.ForEach(x =>
			{
			records.Add(new Dt_InventoryRecord()
			{
			PalletCode = stcok.PalletCode,
			MaterielCode = x.MaterielCode,
			MaterielName = x.MaterielName,
			Quantity = x.Quantity,
			Status = (int)InventoryStatus.Normal,
			Remark = remark,
			});
			});

			var taskDto = CreateListTaskDTO(taskNew);
			var result = GetlcoationState(taskNew, StatusChangeTypeEnum.AutomaticOutbound);
			await _unitOfWorkManage.UseTranAsync(async () =>
			{
			await BaseDal.AddDataAsync(taskNew);
			await _inventoryRecordRepository.AddDataAsync(records);
			await _stockInfoRepository.UpdateDataAsync(stcok);
			await _locationStatusChangeRecordRepository.AddDataAsync(result.Item1);
			await _locationRepository.UpdateDataAsync(result.Item2);
			});
			return content = await SendWCSTask(taskDto);
			}
			catch (Exception ex)
			{
			@@ -388,7 +733,327 @@
			}


			public async Task<WebResponseContent> OtherOutBoundTaskAsync(List<DtStockInfoDetail> details)
			{
			WebResponseContent content = new WebResponseContent();
			try
			{
			var stock = await _stockInfoRepository.QueryFirstNavAsync(x => x.Id == details[0].StockId);
			if (stock == null)
			{
			return content.Error("æªæ¾å°åºåè¡¨å¤´ä¿¡æ¯");
			}
			if (stock.LocationInfo.LocationStatus != (int)LocationEnum.InStock)
			{
			return content.Error("è¯·ç¡®è®¤åºåè´§ä½ç¶ææ¯å¦ä¸ºæè´§");
			}
			var task = await BaseDal.QueryFirstAsync(x => x.PalletCode == stock.PalletCode);
			if (task != null)
			{
			return content.Error("è¯¥æçå·²åå¨ä»»å¡");
			}
			if (stock.LocationInfo.AreaId == 2)
			{
			return content.Error("è¯¥æçåºåå·²å¨åºåºç¼ååº");
			}

			Dt_Task taskNew = await RequestOutboundTaskAsync(new RequestTaskDto { PalletCode = stock.PalletCode, AreaId = 2, Position = stock.LocationCode, TaskType = (int)TaskOutboundTypeEnum.OutOther });

			List<Dt_OrderOutDetails> outDetails = new List<Dt_OrderOutDetails>();
			details.Where(x => x.OutboundQuantity > 0).ForEach(x =>
			{
			if (x.Quantity < x.OutboundQuantity)
			{
			throw new Exception($"{x.MaterielName}{x.MaterielCode}åºåºæ°éä¸å¯å¤§äºåºåæ°é");
			}
			outDetails.Add(new Dt_OrderOutDetails()
			{
			OrderNo = "",
			PalletCode = stock.PalletCode,
			OrderType = (int)OrderTypeEmun.å¶ä»åºåºå,
			ERPOrderId = "",
			MaterielCode = x.MaterielCode,
			MaterielName = x.MaterielName,
			AllocateWarehouse = "",
			Warehouse = "æºè½ç«åº",
			WareHouseId = "107",
			AllocateWarehouseId = "",
			OutboundQuantity = x.OutboundQuantity,
			});
			});
			stock.StockInfoDetails = details;

			var taskDto = CreateListTaskDTO(taskNew);
			var result = GetlcoationState(taskNew, StatusChangeTypeEnum.AutomaticOutbound);
			await _unitOfWorkManage.UseTranAsync(async () =>
			{
			await BaseDal.AddDataAsync(taskNew);
			await _stockInfoRepository.UpdateDataNavAsync(stock);
			await _locationStatusChangeRecordRepository.AddDataAsync(result.Item1);
			await _locationRepository.UpdateDataAsync(result.Item2);
			await _orderOutDetailsRepository.AddDataAsync(outDetails);
			});
			return content = await SendWCSTask(taskDto);
			}
			catch (Exception ex)
			{
			return content.Error(ex.Message);
			}
			}

			/// <summary>
			/// æå¨è°æ¨
			/// </summary>
			/// <param name="details"></param>
			/// <returns></returns>
			public async Task<WebResponseContent> HandAllocateOutBoundTaskAsync(List<DtStockInfoDetail> details)
			{
			WebResponseContent content = new WebResponseContent();
			try
			{
			var stock = await _stockInfoRepository.QueryFirstNavAsync(x => x.Id == details[0].StockId);
			if (stock == null)
			{
			return content.Error("æªæ¾å°åºåè¡¨å¤´ä¿¡æ¯");
			}
			if (stock.LocationInfo.LocationStatus != (int)LocationEnum.InStock)
			{
			return content.Error("è¯·ç¡®è®¤åºåè´§ä½ç¶ææ¯å¦ä¸ºæè´§");
			}
			var task = await BaseDal.QueryFirstAsync(x => x.PalletCode == stock.PalletCode);
			if (task != null)
			{
			return content.Error("è¯¥æçå·²åå¨ä»»å¡");
			}
			if (stock.LocationInfo.AreaId == 2)
			{
			return content.Error("è¯¥æçåºåå·²å¨åºåºç¼ååº");
			}

			Dt_Task taskNew = await RequestOutboundTaskAsync(new RequestTaskDto { PalletCode = stock.PalletCode, AreaId = 2, Position = stock.LocationCode, TaskType = (int)TaskOutboundTypeEnum.OutAllocate });

			List<Dt_OrderOutDetails> outDetails = new List<Dt_OrderOutDetails>();
			details.Where(x=>x.OutboundQuantity>0).ForEach(x =>
			{
			if (x.Quantity < x.OutboundQuantity)
			{
			throw new Exception($"{x.MaterielName}{x.MaterielCode}åºåºæ°éä¸å¯å¤§äºåºåæ°é");
			}
			var wareinfo = _wareAreaInfoRepository.QueryFirst(y => y.WareAreaCode ==x.AllocateWarehouse);
			if (wareinfo == null)
			{
			throw new Exception($"æªæ¾å°è°æ¨ä»åº{x.AllocateWarehouse}æ°æ®");
			}
			if (wareinfo.WareAreaCode == "205")
			{
			throw new Exception($"ä¸å¯è°æ¨è³WMSåºåºç¼ååº{x.AllocateWarehouse}æ°æ®");
			}
			outDetails.Add(new Dt_OrderOutDetails()
			{
			OrderNo = "",
			PalletCode = stock.PalletCode,
			OrderType = (int)OrderTypeEmun.è°æ¨åºåºå,
			ERPOrderId = "",
			MaterielCode = x.MaterielCode,
			MaterielName = x.MaterielName,
			AllocateWarehouse = wareinfo.WareAreaName,
			Warehouse = "æºè½ç«åº",
			WareHouseId = "107",
			AllocateWarehouseId = wareinfo.WareAreaCode ,
			OutboundQuantity = x.OutboundQuantity,
			});
			});

			stock.StockInfoDetails = details;

			var taskDto = CreateListTaskDTO(taskNew);
			var result = GetlcoationState(taskNew, StatusChangeTypeEnum.AutomaticOutbound);
			await _unitOfWorkManage.UseTranAsync(async () =>
			{
			await BaseDal.AddDataAsync(taskNew);
			await _stockInfoRepository.UpdateDataNavAsync(stock);
			await _locationStatusChangeRecordRepository.AddDataAsync(result.Item1);
			await _locationRepository.UpdateDataAsync(result.Item2);
			await _orderOutDetailsRepository.AddDataAsync(outDetails);
			});
			return content = await SendWCSTask(taskDto);
			}
			catch (Exception ex)
			{
			return content.Error(ex.Message);
			}
			}

			public (List<DtLocationStatusChangeRecord>,List<DtLocationInfo>) GetlcoationState(Dt_Task task, StatusChangeTypeEnum StatusChangeTypeEnum)
			{
			List<DtLocationStatusChangeRecord> locationStatusChangeRecords = new List<DtLocationStatusChangeRecord>();
			List<DtLocationInfo> locations = new List<DtLocationInfo>();
			var result = UpdateLocationStatus(task.SourceAddress, LocationEnum.InStockDisable, task.TaskNum.Value, (int)StatusChangeTypeEnum);
			locationStatusChangeRecords.AddRange(result.Item1);
			locations.AddRange(result.Item2);

			return (locationStatusChangeRecords,locations);
			}

			/// <summary>
			/// è¯·æ±åºåºä»»å¡
			/// </summary>
			/// <param name="taskDto"></param>
			/// <returns></returns>
			public async Task<Dt_Task> RequestOutboundTaskAsync(RequestTaskDto taskDto)
			{
			DtStockInfo stcok = await _stockInfoRepository.QueryFirstAsync(x => x.PalletCode == taskDto.PalletCode);
			if (stcok == null)
			{
			throw new Exception("æçä¿¡æ¯ä¸åå¨ï¼è¯·ç¡®è®¤æçå·²å¥åºæå");
			}

			var StartAddress = await _locationRepository.QueryFirstAsync(x => x.LocationCode == taskDto.Position);
			if (StartAddress == null)
			{
			throw new Exception("èµ·ç¹åºä½æªæ¾å°");
			}
			if (!LocationIsOutBound(StartAddress))
			{
			throw new Exception($"èµ·ç¹åºä½{StartAddress.LocationCode}åºåºè·¯å¾è¢«å ç¨ï¼è¯·ç¨åéè¯");
			}

			var area = _areaInfoRepository.QueryFirst(x => x.AreaID == 2);

			var locationInfo = await _locationRepository.QueryDataAsync(x => x.AreaId == area.AreaID && x.EnalbeStatus == 1 && x.LocationStatus == (int)LocationEnum.Free);

			var taskArea = BaseDal.QueryData(x => x.TargetAddress == area.AreaName && x.TaskType == (int)TaskInboundTypeEnum.Inbound);

			if (locationInfo.Count - taskArea.Count <= 0)
			{
			throw new Exception($"åºåºç¼ååºæ å¯ç¨åºä½ï¼è¯·æ¸çåºä½ååè¯");
			}

			switch (StartAddress.AreaId)
			{
			case 1:
			return OutboundStakerArea(taskDto, StartAddress, area);
			case 2:
			case 3:
			case 4:
			case 5:
			case 6:
			return OutboundAGVCacheArea(taskDto, StartAddress, area);
			default:
			throw new Exception("è¯·éæ©æ£ç¡®çåºåä¿¡æ¯");
			}
			}


			public Dt_Task OutboundStakerArea(RequestTaskDto taskDto, DtLocationInfo StartAddress, Dt_AreaInfo area)
			{
			var station = _stationManagerRepository.QueryFirst(x => x.stationType == 1 && x.Roadway == "SC1");

			return new Dt_Task
			{
			Grade = Convert.ToInt32(StartAddress.Remark),
			Roadway = "SC1",
			TargetAddress = area.AreaName,
			Dispatchertime = DateTime.Now,
			MaterialNo = taskDto.MaterielCode,
			NextAddress = station.stationChildCode,
			OrderNo = taskDto.OrderNo,
			PalletCode = taskDto.PalletCode,
			SourceAddress = taskDto.Position,
			CurrentAddress = taskDto.Position,
			TaskState = (int)TaskOutStatusEnum.OutNew,
			TaskType = taskDto.TaskType,
			TaskNum = BaseDal.GetTaskNo().Result,
			CreateDate = DateTime.Now,
			TaskId = 0,
			AGVTaskNum = GenerateUniqueId(),
			Floor = "1F",
			};
			}

			public Dt_Task OutboundAGVCacheArea(RequestTaskDto taskDto, DtLocationInfo StartAddress, Dt_AreaInfo area)
			{
			Dt_Task taskNew = new Dt_Task();
			if (StartAddress.Floor != area.Spare1)
			{
			taskNew = RequestAcrossFloorTask(StartAddress, area, taskDto.TaskType, taskDto);
			}
			else
			{
			taskNew = RequestAGVCarryTask(StartAddress, GetAGVEmptyCacheLocation(taskDto.AreaId, StartAddress).Result, taskDto.TaskType, taskDto);
			}
			return taskNew;

			}
			#endregion è¯·æ±åºåºï¼å®ç&ç©ºçï¼

			#region è¯·æ±ç§»åºä»»å¡
			public async Task<WebResponseContent> RequestRelocationTaskAsync(string SourceAddress,string TargetAddress)
			{
			WebResponseContent content = new WebResponseContent();
			try
			{
			var startLocation = await _locationRepository.QueryFirstAsync(x => x.LocationCode == SourceAddress);
			var endLocation = await _locationRepository.QueryFirstAsync(x => x.LocationCode == TargetAddress);

			if (!startLocation.IsNotEmptyOrNull() \|\| !endLocation.IsNotEmptyOrNull())
			{
			return content.Error("åºä½ä¿¡æ¯ä¸åå¨");
			}
			if (endLocation.LocationStatus != (int)LocationEnum.Free)
			{
			return content.Error($"ç»ç¹åºä½{endLocation.LocationCode}æªå¤äºç©ºé²ç¶æï¼è¯·äººå·¥ç¡®è®¤åºä½ç¶æ");
			}
			if ((startLocation.AreaId == 1 \|\| endLocation.AreaId == 1) && startLocation.AreaId != endLocation.AreaId)
			{
			return content.Error("ç§»åºèµ·ç¹åºä½ä¸ç»ç¹åºä½ä¸å¨åä¸åºå");
			}
			if (startLocation.Floor != endLocation.Floor)
			{
			return content.Error("ç§»åºèµ·ç¹åºä½ä¸ç»ç¹åºä½ä¸å¨åä¸æ¥¼å±");
			}

			var stock = await _stockInfoRepository.QueryFirstAsync(x => x.LocationCode == startLocation.LocationCode);
			var taskNew = new Dt_Task
			{
			Grade = startLocation.Floor == "1F" ? 10 : 1,
			Roadway = endLocation.RoadwayNo,
			TargetAddress = endLocation.LocationCode,
			Dispatchertime = DateTime.Now,
			MaterialNo = "",
			NextAddress = endLocation.LocationCode,
			OrderNo = null,
			PalletCode = stock == null ? "M" + DateTime.Now.ToString("MMddHHmmss") + "-" + new Random().Next(100, 1000) : stock.PalletCode,
			SourceAddress = startLocation.LocationCode,
			CurrentAddress = startLocation.LocationCode,
			TaskState = startLocation.AreaId == 1 ? (int)TaskRelocationStatusEnum.RelocationNew : (int)TaskRelocationStatusEnum.RelocationNewAGV,
			TaskType = (int)TaskRelocationTypeEnum.Relocation,
			TaskNum = BaseDal.GetTaskNo().Result,
			CreateDate = DateTime.Now,
			TaskId = 0,
			AGVTaskNum = GenerateUniqueId(),
			Floor = startLocation.Floor,
			};


			var result = AddTaskAsync(new List<Dt_Task>() { taskNew });
			await _unitOfWorkManage.UseTranAsync(async () =>
			{
			await _locationStatusChangeRecordRepository.AddDataAsync(result.Item2);
			await _locationRepository.UpdateDataAsync(result.Item1);
			await BaseDal.AddDataAsync(taskNew);
			});
			await SendWCSTask(CreateListTaskDTO(taskNew));
			return content.OK("æå");
			}
			catch (Exception ex)
			{
			return content.Error(ex.Message);
			}
			}


			#endregion

			#region è¯·æ±è·¨æ¥¼å±2ä»»å¡
			/// <summary>
			@@ -404,36 +1069,49 @@
			var task = BaseDal.QueryFirst(x => x.TaskNum == Convert.ToInt32(taskDto.TaskNum) && x.PalletCode == taskDto.PalletCode);
			if(task == null)
			return content.Error("æªæ¾å°ä»»å¡");
			Dt_StationManager stationManager = new Dt_StationManager();
			if (task.Floor == "1F")
			{
			stationManager = _stationManagerRepository.QueryFirst(x => x.stationType == 5 && x.stationFloor == "2F");
			}
			else
			{
			stationManager = _stationManagerRepository.QueryFirst(x => x.stationType == 5 && x.stationFloor == "1F");
			}
			content = await RequestLocation(taskDto.PalletCode);
			Dt_Task taskNew = new Dt_Task
			{
			Grade = 1,
			Roadway = "AGV",
			TargetAddress = task.TargetAddress,
			TargetAddress = content.Data.ToString(),
			Dispatchertime = DateTime.Now,
			MaterialNo = "",
			NextAddress = taskDto.NextAddress,
			NextAddress = content.Data.ToString(),
			OrderNo = null,
			PalletCode = task.PalletCode,
			SourceAddress = taskDto.NextAddress,
			CurrentAddress = taskDto.NextAddress,
			SourceAddress = task.SourceAddress,
			CurrentAddress = stationManager.stationChildCode,
			TaskState = (int)TaskAcrossFloorStatusEnum.SecondCarry,
			TaskType = (int)TaskAcrossFloorTypeEnum.AcrossFloorCarry,
			TaskType = task.TaskType,
			TaskNum = BaseDal.GetTaskNo().Result,
			CreateDate = DateTime.Now,
			TaskId = 0,
			AGVTaskNum = GenerateUniqueId(),
			Floor = "",
			Floor = stationManager.stationFloor,
			};
			var taskDTO = CreateTaskDTO(taskNew);

			task.TaskState = (int)TaskAcrossFloorStatusEnum.FirstCarryFinish;
			var taskHty = task.Adapt<Dt_Task_Hty>();
			taskHty.FinishTime = DateTime.Now;
			taskHty.OperateType = App.User.UserName != null ? (int)OperateTypeEnum.äººå·¥å®æ : (int)OperateTypeEnum.èªå¨å®æ;
			taskHty.Creater = App.User.UserName != null ? App.User.UserName : "System";

			await UpdateStartLocationInfo(taskNew);
			await _unitOfWorkManage.UseTranAsync(async () =>
			{
			await DeleteTaskAsync(task.TaskId);
			await AddTaskHtyAsync(taskHty);
			BaseDal.AddData(taskNew);
			});
			return content.OK(data: taskDTO);
			}
			@@ -446,90 +1124,331 @@
			#endregion

			#region è¯·æ±è·¨æ¥¼å±ä»»å¡
			public async Task<WebResponseContent> RequestAcrossFloorTaskAsync(RequestTaskDto taskDto)
			public Dt_Task RequestAcrossFloorTask(DtLocationInfo StartAddress, Dt_AreaInfo area, int TaskType, RequestTaskDto taskDto)
			{
			WebResponseContent content = new WebResponseContent();
			try
			{
			var task = await GetByTaskAddress(taskDto.Position, taskDto.TargetAddress);
			if (task != null)
			{
			return content.Error("èµ·ç¹æç»ç¹åå¨ä»»å¡");
			}
			var station = _stationManagerRepository.QueryFirst(x => x.stationChildCode == taskDto.Position);

			if (station != null)
			{
			var next = _stationManagerRepository.QueryFirst(x => x.stationType == 5 && x.stationFloor == station.stationFloor);
			Dt_Task taskNew = new Dt_Task
			{
			Grade = 1,
			Roadway = "AGV",
			TargetAddress = taskDto.TargetAddress,
			Dispatchertime = DateTime.Now,
			MaterialNo = "",
			NextAddress = next.stationChildCode,
			OrderNo = null,
			PalletCode = taskDto.PalletCode,
			SourceAddress = taskDto.Position,
			CurrentAddress = taskDto.Position,
			TaskState = (int)TaskAcrossFloorStatusEnum.CarryNew,
			TaskType = (int)TaskAcrossFloorTypeEnum.AcrossFloorCarry,
			TaskNum = BaseDal.GetTaskNo().Result,
			CreateDate = DateTime.Now,
			TaskId = 0,
			AGVTaskNum = GenerateUniqueId(),
			Floor = station.stationFloor,
			};
			var taskDTO = CreateListTaskDTO(taskNew);

			return content = await SendWCSTask(taskDTO);
			}
			return content.Error("æªæ¾å°æåæºç«ç¹");
			}
			catch (Exception ex)
			var next = _stationManagerRepository.QueryFirst(x => x.stationType == 5 && x.stationFloor == StartAddress.Floor);
			return new Dt_Task
			{
			return content.Error(ex.Message);
			}
			Grade = StartAddress.Column,
			Roadway = "AGV",
			TargetAddress = area.AreaName,
			Dispatchertime = DateTime.Now,
			MaterialNo = taskDto.MaterielCode,
			NextAddress = next.stationChildCode,
			OrderNo = taskDto.OrderNo,
			PalletCode = taskDto.PalletCode,
			SourceAddress = StartAddress.LocationCode,
			CurrentAddress = StartAddress.LocationCode,
			TaskState = (int)TaskAcrossFloorStatusEnum.CarryNew,
			TaskType = TaskType,
			TaskNum = BaseDal.GetTaskNo().Result,
			CreateDate = DateTime.Now,
			TaskId = 0,
			Remark = StartAddress.AreaId.ToString(),
			AGVTaskNum = GenerateUniqueId(),
			Floor = StartAddress.Floor,
			};

			}

			#endregion

			#region è¯·æ±AGVæ¬è¿ä»»å¡
			public async Task<WebResponseContent> RequestAGVCarryTaskAsync(RequestTaskDto taskDto)
			public Dt_Task RequestAGVCarryTask(DtLocationInfo StartAddress, DtLocationInfo EndAddress, int TaskType, RequestTaskDto taskDto)
			{
			WebResponseContent content = new WebResponseContent();

			return new Dt_Task
			{
			Grade = StartAddress.Column,
			Roadway = "AGV",
			TargetAddress = EndAddress.LocationCode,
			Dispatchertime = DateTime.Now,
			MaterialNo = taskDto.MaterielCode,
			NextAddress = EndAddress.LocationCode,
			OrderNo = taskDto.OrderNo,
			PalletCode = taskDto.PalletCode,
			SourceAddress = StartAddress.LocationCode,
			CurrentAddress = StartAddress.LocationCode,
			TaskState = (int)TaskAGVCarryStatusEnum.CarryNew,
			TaskType = TaskType,
			TaskNum = BaseDal.GetTaskNo().Result,
			CreateDate = DateTime.Now,
			TaskId = 0,
			Remark = StartAddress.AreaId.ToString(),
			AGVTaskNum = GenerateUniqueId(),
			Floor = StartAddress.Floor,
			};
			}

			#endregion

			#region å¤ææ¯å¦éè¦ç§»åº

			/// <summary>
			/// å¤æå åæºåºåºæ¯å¦éè¦ç§»åº
			/// </summary>
			/// <param name="taskDto"></param>
			/// <returns></returns>
			public async Task<WebResponseContent> StackerIsNeedRelocationAsync(RequestTaskDto taskDto)
			{
			WebResponseContent content = new WebResponseContent();
			try
			{
			var task = await GetByTaskAddress(taskDto.Position,taskDto.TargetAddress);
			if (task != null)
			var task = BaseDal.QueryFirst(x => x.PalletCode == taskDto.PalletCode && x.TaskNum == taskDto.TaskNum);
			if (task == null)
			{
			return content.Error("èµ·ç¹æç»ç¹åå¨ä»»å¡");
			return content.Error("æªæ¾å°ä»»å¡");
			}
			var station = _stationManagerRepository.QueryFirst(x => x.stationChildCode == taskDto.Position);
			Dt_Task taskNew = new Dt_Task
			{
			Grade = 1,
			Roadway = "AGV",
			TargetAddress = taskDto.TargetAddress,
			Dispatchertime = DateTime.Now,
			MaterialNo = "",
			NextAddress = taskDto.TargetAddress,
			OrderNo = null,
			PalletCode = taskDto.PalletCode,
			SourceAddress = taskDto.Position,
			CurrentAddress = taskDto.Position,
			TaskState = (int)TaskAGVCarryStatusEnum.CarryNew,
			TaskType = (int)TaskAGVCarryTypeEnum.Carry,
			TaskNum = BaseDal.GetTaskNo().Result,
			CreateDate = DateTime.Now,
			TaskId = 0,
			AGVTaskNum = GenerateUniqueId(),
			Floor = station.stationFloor,
			};
			var taskDTO = CreateListTaskDTO(taskNew);

			return content = await SendWCSTask(taskDTO);
			var location = await _locationRepository.QueryFirstAsync(x => x.LocationCode == taskDto.Position);

			if (location == null \|\| location.Depth != 2)
			{
			return content.OK(data: _mapper.Map<WMSTaskDTO>(task));
			}

			var locationLateral = _locationRepository.QueryFirst(x => x.RoadwayNo == location.RoadwayNo && x.Row == 1 && x.Layer == location.Layer && x.Column == location.Column);
			if (locationLateral != null && (locationLateral.LocationStatus == (int)LocationEnum.FreeDisable \|\| locationLateral.LocationStatus == (int)LocationEnum.Free) && locationLateral.EnalbeStatus == 1)
			{
			return content.OK(data: _mapper.Map<WMSTaskDTO>(task));
			}
			else if (locationLateral != null && locationLateral.LocationStatus == 1 && locationLateral.EnalbeStatus == 1)
			{
			return content.Error($"ä¸æ·±ä½å¼å¸¸éå®æä¸å¯åºåº");
			}
			else if (locationLateral != null && (locationLateral.LocationStatus == (int)LocationEnum.InStockDisable\|\| locationLateral.LocationStatus == (int)LocationEnum.InStock) && locationLateral.EnalbeStatus == 1)
			{
			var taskLateral = BaseDal.QueryFirst(x => x.SourceAddress == locationLateral.LocationCode);
			if (taskLateral != null)
			{
			return content.OK(data: _mapper.Map<WMSTaskDTO>(taskLateral));
			}

			var TargetAddress = await GetEmptyLocation("SC1");

			if (TargetAddress == null)
			{
			return content.Error($"æªæ¾å°å¯åéè´§ä½,è¯·æ¥çæ¯å¦è¿æç©ºé²å¯ä½¿ç¨è´§ä½");
			}
			var stock = await _stockInfoRepository.QueryFirstAsync(x => x.LocationCode == locationLateral.LocationCode);

			Dt_Task taskNew = new Dt_Task
			{
			Grade = 1,
			Roadway = "SC1",
			TargetAddress = TargetAddress.LocationCode,
			Dispatchertime = DateTime.Now,
			MaterialNo = "",
			NextAddress = TargetAddress.LocationCode,
			OrderNo = null,
			PalletCode = stock == null ? "M" + DateTime.Now.ToString("MMddHHmmss") + "-" + new Random().Next(100, 1000) : stock.PalletCode,
			SourceAddress = locationLateral.LocationCode,
			CurrentAddress = locationLateral.LocationCode,
			TaskState = (int)TaskRelocationStatusEnum.RelocationNew,
			TaskType = (int)TaskRelocationTypeEnum.Relocation,
			TaskNum = BaseDal.GetTaskNo().Result,
			CreateDate = DateTime.Now,
			TaskId = 0,
			Floor = "1F",
			};
			var taskDTO = CreateListTaskDTO(taskNew);

			var isResult = await AddTaskAsync(taskNew, locationLateral, TargetAddress);
			if (!isResult)
			{
			_unitOfWorkManage.RollbackTran();
			return content.Error("æ°å¢ä»»å¡å¤±è´¥");
			}
			return content.OK(data: taskDTO);
			}
			else
			{
			return content.Error("è´§ä½å¼å¸¸éäººå·¥ç¡®è®¤æå¯åºåº");
			}
			}
			catch (Exception ex)
			{
			return content.Error(ex.Message);
			}
			}

			public async Task<WebResponseContent> AGVIsNeedRelocationAsync(RequestTaskDto taskDto)
			{
			WebResponseContent content = new WebResponseContent();
			try
			{
			var task = BaseDal.QueryFirst(x => x.PalletCode == taskDto.PalletCode && x.TaskNum == taskDto.TaskNum);
			if (task == null)
			{
			return content.Error("æªæ¾å°ä»»å¡");
			}

			var location = await _locationRepository.QueryFirstAsync(x => x.LocationCode == taskDto.Position);

			if (location == null)
			{
			return content.Error($"æªæ¾å°è´§ä½ä¿¡æ¯{taskDto.Position}");
			}
			List<DtLocationInfo> locationInfos = new List<DtLocationInfo>();
			switch (location.AreaId)
			{
			case 2:
			locationInfos = _locationRepository.QueryData(x => x.Row == location.Row && x.Column > location.Column && x.Remark == location.Remark && x.AreaId == location.AreaId);
			break;
			case 5:
			case 6:
			locationInfos = _locationRepository.QueryData(x => x.Row == location.Row && x.Column < location.Column && x.Remark == location.Remark && x.AreaId == location.AreaId);
			break;
			default:
			break;
			}

			if (locationInfos.Count == 0)
			{
			return content.OK(data: new List<WMSTaskDTO> { _mapper.Map<WMSTaskDTO>(task) });
			}

			List<WMSTaskDTO> taskDTO = new List<WMSTaskDTO>();
			List<Dt_Task> taskNew = new List<Dt_Task>();
			foreach (var item in locationInfos)
			{
			if(item.LocationStatus == (int)LocationEnum.Lock)
			{
			return content.Error($"{item.LocationCode}è·¯å¾è¢«å ç¨ï¼è¯·ç¨ååè¯");
			}
			if ((item.LocationStatus == (int)LocationEnum.InStockDisable \|\| item.LocationStatus == (int)LocationEnum.InStock) && item.EnalbeStatus == 1)
			{
			DtLocationInfo Targetlocation = await GetAGVEmptyCacheLocation(item.AreaId, item);

			if (Targetlocation == null)
			{
			return content.Error("èµ·ç¹æªå®ä¹æç»ç¹åºåæªæ¾å°ç©ºé²åºä½");
			}
			var stock = _stockInfoRepository.QueryFirst(x => x.LocationCode == item.LocationCode);

			var Relocationtask = BaseDal.QueryFirst(x => x.SourceAddress == item.LocationCode);

			if (Relocationtask != null)
			{
			taskDTO.Add(CreateTaskDTO(Relocationtask));
			continue;
			}
			else
			{
			taskNew.Add(new Dt_Task
			{
			Grade = item.Column,
			Roadway = "AGV",
			TargetAddress = Targetlocation.LocationCode,
			Dispatchertime = DateTime.Now,
			MaterialNo = "",
			NextAddress = Targetlocation.LocationCode,
			OrderNo = null,
			PalletCode = stock == null ? "M" + DateTime.Now.ToString("MMddHHmmss") + "-" + new Random().Next(100, 1000) : stock.PalletCode,
			SourceAddress = item.LocationCode,
			CurrentAddress = item.LocationCode,
			TaskState = (int)TaskRelocationStatusEnum.RelocationNewAGV,
			TaskType = (int)TaskRelocationTypeEnum.Relocation,
			TaskNum = BaseDal.GetTaskNo().Result,
			CreateDate = DateTime.Now,
			TaskId = 0,
			AGVTaskNum = GenerateUniqueId(),
			Floor = item.Floor,
			Remark = item.AreaId.ToString(),
			});
			}

			}
			}
			taskDTO = CreateTaskDTO(taskNew);

			var result = AddTaskAsync(taskNew);
			await _unitOfWorkManage.UseTranAsync(async () =>
			{
			await _locationStatusChangeRecordRepository.AddDataAsync(result.Item2);
			await _locationRepository.UpdateDataAsync(result.Item1);
			await BaseDal.AddDataAsync(taskNew);
			});
			return content.OK(data: taskDTO);
			}
			catch (Exception ex)
			{
			return content.Error(ex.Message);
			}
			}


			#endregion

			#region æ´æ°èµ·ç¹è´§ä½ä¿¡æ¯
			public async Task<WebResponseContent> UpdateStartLocationInfo(Dt_Task task)
			{
			WebResponseContent content = new WebResponseContent();
			try
			{
			if (task == null)
			return content.OK();
			var result = UpdateLocationStatus(task.SourceAddress, LocationEnum.Free, task.TaskNum.Value, task.TaskType.GetTaskTypeGroup() == TaskTypeGroup.OutbondGroup ? (int)StatusChangeTypeEnum.AutomaticOutbound : (int)StatusChangeTypeEnum.AutomaticInbound);

			await _locationStatusChangeRecordRepository.AddDataAsync(result.Item1);
			await _locationRepository.UpdateDataAsync(result.Item2);

			return content.OK();
			}
			catch (Exception ex)
			{
			return content.Error(ex.Message);
			}
			}


			#endregion

			#region è·åç»ç¹è´§ä½ä¿¡æ¯
			public async Task<WebResponseContent> RequestLocation(string palletCode)
			{
			WebResponseContent content = new WebResponseContent();
			try
			{
			var task = await BaseDal.QueryFirstAsync(x => x.PalletCode == palletCode);
			if (task == null)
			return content.Error("æªæ¾å°ä»»å¡");
			var areaInfo = await _areaInfoRepository.QueryFirstAsync(x => x.AreaName == task.TargetAddress);
			if (areaInfo == null)
			return content.Error($"æªæ¾å°ç»ç¹åºåä¿¡æ¯{task.TargetAddress}è¯·èç³»ç®¡çå");
			var location = _locationRepository.QueryFirst(x => x.LocationCode == task.SourceAddress);
			DtLocationInfo locationInfo = new DtLocationInfo();
			switch (areaInfo.AreaID)
			{
			case 1:
			locationInfo = await GetEmptyLocation("SC1");
			break;
			case 2:
			case 3:
			case 4:
			case 5:
			case 6:
			locationInfo = await GetAGVEmptyCacheLocation(areaInfo.AreaID, location);
			break;
			default:
			return content.Error("è¯·éæ©æ£ç¡®çåºåä¿¡æ¯");
			}
			if (locationInfo == null)
			{
			return content.Error("æªæ¾å°å¯åéè´§ä½,è¯·æ¥çæ¯å¦è¿æç©ºé²å¯ä½¿ç¨è´§ä½");
			}
			task.CurrentAddress = task.NextAddress;
			task.TargetAddress = locationInfo.LocationCode;
			task.NextAddress = locationInfo.LocationCode;

			var result = UpdateLocationStatus(locationInfo.LocationCode, LocationEnum.Lock, task.TaskNum.Value, task.TaskType.GetTaskTypeGroup() == TaskTypeGroup.OutbondGroup ? StatusChangeTypeEnum.AutomaticOutbound : StatusChangeTypeEnum.AutomaticInbound);
			await BaseDal.UpdateDataAsync(task);
			await _locationStatusChangeRecordRepository.AddDataAsync(result.Item1);
			await _locationRepository.UpdateDataAsync(result.Item2);

			return content.OK(data: locationInfo.LocationCode);
			}
			catch (Exception ex)
			{
			@@ -538,56 +1457,6 @@
			}

			#endregion

			#region ä»»å¡ç¶ææ´æ¹

			/// <summary>
			/// æ´æ°ä»»å¡ç¶æ&åºåºè§£ç
			/// </summary>
			/// <param name="taskNum"></param>
			/// <param name="taskState"></param>
			/// <returns></returns>
			public async Task<WebResponseContent> UpdateTaskStatus(int taskNum, int taskState)
			{
			WebResponseContent content = new WebResponseContent();
			try
			{
			var task = await BaseDal.QueryFirstAsync(x => x.TaskNum == taskNum);
			if (task == null)
			return content.Error("æªæ¾å°ä»»å¡");

			if (taskState == (int)TaskOutStatusEnum.Line_OutFinish \|\| taskState == (int)TaskInStatusEnum.SC_InFinish)
			{
			var taskHty = CreateHistoricalTask(task);
			await _unitOfWorkManage.UseTranAsync(async () =>
			{
			var asb = await BaseDal.DeleteDataByIdAsync(task.TaskId);
			var asbHty = await _task_HtyRepository.AddDataAsync(taskHty) > 0;
			if (asb && asbHty)
			content.OK();
			else
			throw new Exception();
			});
			content.OK();
			}
			else
			{
			task.TaskState = taskState;
			var asb = await BaseDal.UpdateDataAsync(task);
			if (asb)
			content.OK();
			else
			content.Error();
			}
			}
			catch (Exception ex)
			{
			content.Error(ex.Message);
			}
			return content;
			}

			#endregion ä»»å¡ç¶ææ´æ¹

			#region è·åAGVä»»å¡å·

			@@ -606,10 +1475,32 @@
			}
			#endregion

			#region è·åä»»å¡ä¿¡æ¯
			public WebResponseContent GetTaskInfo()
			{
			WebResponseContent content = new WebResponseContent();
			try
			{
			Expression<Func<Dt_Task, bool>> expression = x => true;
			if (!App.User.IsSuperAdmin)
			{
			expression = x => x.Creater == App.User.UserName;
			}
			var task = BaseDal.Db.Queryable<Dt_Task>().OrderByDescending(x => x.CreateDate).Take(100).Select(x => new Dt_Task { TaskNum = x.TaskNum, PalletCode = x.PalletCode, TaskType = x.TaskType, SourceAddress = x.SourceAddress, TargetAddress = x.TargetAddress }).ToList();
			content = WebResponseContent.Instance.OK(data: task);
			}
			catch (Exception ex)
			{
			content = WebResponseContent.Instance.Error(ex.Message);
			}
			return content;
			}
			#endregion

			#endregion å¤é¨æ¥å£æ¹æ³

			#region è°ç¨WCSæ¥å£
			private string GetAGVIPAddress(string baseIp, string name)
			private string GetWCSIPAddress(string baseIp, string name)
			{
			var configz = _configService.GetConfigsByCategory(CateGoryConst.CONFIG_SYS_IPAddress);
			var wcsBasez = configz.Where(x => x.ConfigKey == baseIp).FirstOrDefault()?.ConfigValue;
			@@ -620,10 +1511,11 @@
			}
			return wcsBasez + address;
			}

			public async Task<WebResponseContent> SendWCSTask(List<WMSTaskDTO> taskDTO)
			{
			WebResponseContent content = new WebResponseContent();
			var AgvSendTaskAddrss = GetAGVIPAddress(SysConfigConst.WCSIPAddress, SysConfigConst.ReceiveTask);
			var AgvSendTaskAddrss = GetWCSIPAddress(SysConfigConst.WCSIPAddress, SysConfigConst.ReceiveTask);
			// åéè¯·æ±å¹¶çå¾ååº
			var result = await HttpHelper.PostAsync(AgvSendTaskAddrss, taskDTO.ToJsonString());

			@@ -633,7 +1525,571 @@
			}
			#endregion

			#region ERPæ¥å£è°ç¨
			public string GetERPIPAddress(string baseIp, string name)
			{
			var configz = _configService.GetConfigsByCategory(CateGoryConst.CONFIG_SYS_IPAddress);
			var wcsBasez = configz.Where(x => x.ConfigKey == baseIp).FirstOrDefault()?.ConfigValue;
			var address = configz.Where(x => x.ConfigKey == name).FirstOrDefault()?.ConfigValue;
			if (wcsBasez == null \|\| address == null)
			{
			throw new InvalidOperationException("WMS IP æªéç½®");
			}
			return wcsBasez + address;
			}

			/// <summary>
			/// çäº§é¢æ
			/// </summary>
			/// <param name="palletCode"></param>
			/// <returns></returns>
			public async Task<WebResponseContent> ERPProduction(List<Dt_OrderOutDetails> orderOutDetails)
			{
			WebResponseContent content = new WebResponseContent();
			try
			{
			MaterialRequisition materialRequisition = new MaterialRequisition
			{
			context = new Context
			{
			CultureName = "zh-CN",
			EntCode = "001",
			OrgCode = "102",
			UserCode = "MH0551"
			},
			documentTypeCode = "LL20",
			businessDate = DateTime.Now.ToString("yyyy-MM-dd"),
			isApproved = true,
			issueList = orderOutDetails.Select(item => new issueList
			{
			PickListID = item.ERPOrderId,
			//åå¨å°ç¹
			WhCode = "205",
			//é¢ææ°é
			IssueQty = item.OutboundQuantity,
			}).ToList()

			};
			var ERPProduction = GetERPIPAddress(SysConfigConst.ERPIPAddress, SysConfigConst.MaterialRequisition);
			// åéè¯·æ±å¹¶çå¾ååº

			var result = await HttpsClient.PostAsync(ERPProduction, materialRequisition.ToJsonString());

			var respone = JsonConvert.DeserializeObject<ResponeData>(result.ToString());
			if (respone.d.ResultStatus)
			{
			return content.OK();
			}
			return content.Error(respone.d.ResultMsg);
			}
			catch (Exception ex)
			{
			return content.Error(ex.Message);
			}
			}
			/// <summary>
			/// è°æ¨
			/// </summary>
			/// <param name="palletCode"></param>
			/// <returns></returns>
			///
			public async Task ERPAllocate(DtBoxingInfo boxing)
			{
			try
			{
			if (boxing == null)
			{
			throw new Exception("æªæ¾å°ç»çä¿¡æ¯");
			}
			Allocate allocate = new Allocate
			{
			context = new Context
			{
			CultureName = "zh-CN",
			EntCode = "001",
			OrgCode = "102",
			UserCode = "MH0551"
			},
			documentTypeCode = "TransIn002",
			businessDate = DateTime.Now.ToString("yyyy-MM-dd"),
			isApproved = true,

			transferInList = boxing.BoxingInfoDetails.Select(item => new transferInList
			{
			//ç©æç¼ç
			ItemCode = item.MaterielCode,
			//è°å¥ä»åºå°å
			TransInWHCode = "107",
			//è°å¥æ°é
			TransInQty = item.Quantity,
			// è°åºä»åºç¼ç
			TransOutWHCode = item.WareHouseId,
			}).ToList()
			};
			var Allocate = GetERPIPAddress(SysConfigConst.ERPIPAddress, SysConfigConst.Allocate);
			// åéè¯·æ±å¹¶çå¾ååº
			var result = await HttpsClient.PostAsync(Allocate, allocate.ToJsonString());

			var respone = JsonConvert.DeserializeObject<ResponeData>(result.ToString());
			if (!respone.d.ResultStatus)
			{
			throw new Exception(respone.d.ResultMsg);
			}

			}
			catch (Exception ex)
			{
			throw new Exception(ex.Message);
			}
			}

			public async Task ERPAllocateOut(DtStockInfo stock)
			{
			try
			{
			if (stock == null)
			{
			throw new Exception("æªæ¾å°åºåä¿¡æ¯");
			}
			Allocate allocate = new Allocate
			{
			context = new Context
			{
			CultureName = "zh-CN",
			EntCode = "001",
			OrgCode = "102",
			UserCode = "MH0551"
			},
			documentTypeCode = "TransIn002",
			businessDate = DateTime.Now.ToString("yyyy-MM-dd"),
			isApproved = true,

			transferInList = stock.StockInfoDetails.Select(item => new transferInList
			{
			//ç©æç¼ç
			ItemCode = item.MaterielCode,
			//è°å¥ä»åºå°å
			TransInWHCode = "205",
			//è°å¥æ°é
			TransInQty = item.Quantity,
			// è°åºä»åºç¼ç
			TransOutWHCode = "107",
			}).ToList()
			};
			var Allocate = GetERPIPAddress(SysConfigConst.ERPIPAddress, SysConfigConst.Allocate);
			// åéè¯·æ±å¹¶çå¾ååº
			var result = await HttpsClient.PostAsync(Allocate, allocate.ToJsonString());

			var respone = JsonConvert.DeserializeObject<ResponeData>(result.ToString());
			if (!respone.d.ResultStatus)
			{
			throw new Exception(respone.d.ResultMsg);
			}

			}
			catch (Exception ex)
			{
			throw new Exception(ex.Message);
			}
			}


			public async Task ERPAllocate(List<Dt_OrderOutDetails> orderOutDetails)
			{
			try
			{
			if (orderOutDetails.Count <= 0)
			{
			throw new Exception($"æªæ¾å°è°æ¨åºåºæ°æ®");
			}
			List<transferInList> transferInList=new List<transferInList>();
			foreach (var item in orderOutDetails)
			{
			if (item.AllocateWarehouseId == "205")
			{
			continue;
			}
			transferInList.Add(new transferInList
			{
			//ç©æç¼ç
			ItemCode = item.MaterielCode,
			//è°å¥ä»åºå°å
			TransInWHCode = item.AllocateWarehouseId,
			//è°å¥æ°é
			TransInQty = item.OutboundQuantity,
			// è°åºä»åºç¼ç
			TransOutWHCode = "205",
			});
			}
			if (transferInList.Count <= 0)
			{
			return;
			}
			Allocate allocate = new Allocate
			{
			context = new Context
			{
			CultureName = "zh-CN",
			EntCode = "001",
			OrgCode = "102",
			UserCode = "MH0551"
			},
			documentTypeCode = "TransIn002",
			businessDate = DateTime.Now.ToString("yyyy-MM-dd"),
			isApproved = true,
			transferInList = transferInList,
			};
			var Allocate = GetERPIPAddress(SysConfigConst.ERPIPAddress, SysConfigConst.Allocate);
			// åéè¯·æ±å¹¶çå¾ååº
			var result = await HttpsClient.PostAsync(Allocate, allocate.ToJsonString());

			var respone = JsonConvert.DeserializeObject<ResponeData>(result.ToString());
			if (!respone.d.ResultStatus)
			{
			throw new Exception($"ERPè°æ¨åºåº{respone.d.ResultMsg}");
			}
			}
			catch (Exception ex)
			{
			throw new Exception(ex.Message);
			}
			}
			/// <summary>
			/// æå
			/// </summary>
			/// <param name="palletCode"></param>
			/// <returns></returns>
			public async Task ERPMixedSend(List<Dt_OrderOutDetails> orderOutDetails)
			{
			try
			{
			if (orderOutDetails.Count <= 0)
			{
			throw new Exception($"æªæ¾å°è°æ¨åºåºæ°æ®");
			}
			MixedSend send = new MixedSend
			{
			context = new Context
			{
			CultureName = "zh-CN",
			EntCode = "001",
			OrgCode = "102",
			UserCode = "MH0551"
			},
			documentTypeCode = "MiscShip001",
			businessDate = DateTime.Now.ToString("yyyy-MM-dd"),
			isApproved = true,

			miscShipList = orderOutDetails.Select(item => new miscShipList
			{
			//ç©æç¼ç
			ItemCode = item.MaterielCode,
			//åå¨å°ç¹ç¼å·
			WhCode = "205",
			//æåæ°é
			Qty = item.OutboundQuantity,

			BenefitDeptCode = "0505",
			}).ToList()
			};
			var ERPMixedSend = GetERPIPAddress(SysConfigConst.ERPIPAddress, SysConfigConst.MixedSend);
			// åéè¯·æ±å¹¶çå¾ååº
			var result = await HttpsClient.PostAsync(ERPMixedSend, send.ToJsonString());

			var respone = JsonConvert.DeserializeObject<ResponeData>(result.ToString());
			if (!respone.d.ResultStatus)
			{
			throw new Exception($"ERPå¶ä»åºåº{respone.d.ResultMsg}");
			}
			}
			catch (Exception ex)
			{
			throw new Exception(ex.Message);
			}
			}
			/// <summary>
			/// ææ¶
			/// </summary>
			/// <param name="palletCode"></param>
			/// <returns></returns>
			public async Task<WebResponseContent> ERPMixedReceive(string palletCode)
			{
			WebResponseContent content = new WebResponseContent();
			try
			{
			DtStockInfo stock = await _stockInfoRepository.QueryFirstNavAsync(x => x.PalletCode == palletCode);
			MixedReceive allocate = new MixedReceive
			{
			context = new Context
			{
			CultureName = "zh-CN",
			EntCode = "001",
			OrgCode = "102",
			UserCode = "MH0551"
			},
			documentTypeCode = "TransIn002",
			businessDate = DateTime.Now.ToString("yyyy-MM-dd"),
			isApproved = true,

			miscRcvList = stock.StockInfoDetails.Where(x => x.OutboundQuantity > 0).Select(item => new miscRcvList
			{
			ItemCode = item.MaterielCode,
			WhCode = item.Warehouse,
			Qty = item.OutboundQuantity,
			CostPrice = 0,
			}).ToList()
			};
			return content.OK(data: allocate);
			}
			catch (Exception ex)
			{
			return content.Error(ex.Message);
			}
			}
			/// <summary>
			/// éæ
			/// </summary>
			/// <param name="palletCode"></param>
			/// <returns></returns>
			public async Task<WebResponseContent> ERPreturnMaterialList(string palletCode)
			{
			WebResponseContent content = new WebResponseContent();
			try
			{
			DtStockInfo stock = await _stockInfoRepository.QueryFirstNavAsync(x => x.PalletCode == palletCode);
			ReturnMaterials allocate = new ReturnMaterials
			{
			context = new Context
			{
			CultureName = "zh-CN",
			EntCode = "001",
			OrgCode = "102",
			UserCode = "MH0551"
			},
			documentTypeCode = "TransIn002",
			businessDate = DateTime.Now.ToString("yyyy-MM-dd"),
			isApproved = true,

			returnMaterialList = stock.StockInfoDetails.Select(item => new returnMaterialList
			{
			PickListID = item.MaterielCode,
			WhCode = item.Warehouse,
			RecedeQty = item.OutboundQuantity,
			RecedeReason = 1,
			}).ToList()
			};
			return content.OK(data: allocate);
			}
			catch (Exception ex)
			{
			return content.Error(ex.Message);
			}
			}

			#endregion

			#region åé¨è°ç¨æ¹æ³

			public (List<DtLocationStatusChangeRecord>,List<DtLocationInfo>) UpdateLocationStatus(DtLocationInfo location, LocationEnum locationStatus, int taskNum, int StatusChangeType)
			{
			List<DtLocationInfo> locations = GetGroupLocations(location);

			List<DtLocationInfo> Beforelocation = locations.Select(x => new DtLocationInfo
			{
			Id = x.Id,
			LocationCode = x.LocationCode,
			LocationStatus = x.LocationStatus
			}).ToList();

			foreach (var item in locations)
			{
			if (locationStatus == LocationEnum.Lock)
			{
			if (item.LocationCode == location.LocationCode)
			{
			item.LocationStatus = (int)LocationEnum.Lock;
			}
			else if (item.LocationStatus == (int)LocationEnum.Free)
			{
			item.LocationStatus = (int)LocationEnum.FreeDisable;
			}
			}
			else if (locationStatus == LocationEnum.InStock)
			{
			if (item.LocationCode == location.LocationCode)
			{
			item.LocationStatus = (int)LocationEnum.InStock;
			}
			else if (item.LocationStatus == (int)LocationEnum.FreeDisable)
			{
			item.LocationStatus = (int)LocationEnum.Free;
			}
			}
			else if (locationStatus == LocationEnum.InStockDisable)
			{
			if (item.LocationStatus == (int)LocationEnum.InStock)
			{
			item.LocationStatus = (int)LocationEnum.InStockDisable;
			}
			else if (item.LocationStatus == (int)LocationEnum.Free)
			{
			item.LocationStatus = (int)LocationEnum.FreeDisable;
			}
			}
			else if (locationStatus == LocationEnum.Free)
			{
			if (item.LocationCode == location.LocationCode)
			{
			item.LocationStatus = (int)LocationEnum.Free;
			}
			else if (item.LocationStatus == (int)LocationEnum.FreeDisable \|\| item.LocationStatus == (int)LocationEnum.InStockDisable)
			{
			item.LocationStatus = (int)LocationEnum.Free;
			}
			}
			}
			List<DtLocationStatusChangeRecord> changeRecordDto = new List<DtLocationStatusChangeRecord>();
			foreach (var item in Beforelocation)
			{
			var loc = locations.Where(x => x.LocationCode == item.LocationCode).FirstOrDefault();
			if (loc != null)
			{
			DtLocationStatusChangeRecord dtLocationStatusChangeRecord = new DtLocationStatusChangeRecord()
			{
			ChangeType = StatusChangeType,
			LocationCode = item.LocationCode,
			LocationId = loc.Id,
			Creater = "System",
			TaskNum = taskNum,
			AfterStatus = loc.LocationStatus,
			BeforeStatus = item.LocationStatus,
			};

			changeRecordDto.Add(dtLocationStatusChangeRecord);
			}
			}
			return (changeRecordDto,locations);
			}

			public (List<DtLocationStatusChangeRecord>, List<DtLocationInfo>) UpdateLocationStatus(string locationCode, LocationEnum locationStatus, int taskNum, int StatusChangeType)
			{
			var location = _locationRepository.QueryFirst(x => x.LocationCode == locationCode);

			List<DtLocationInfo> locations = GetGroupLocations(location);

			List<DtLocationInfo> Beforelocation = locations.Select(x => new DtLocationInfo
			{
			Id = x.Id,
			LocationCode = x.LocationCode,
			LocationStatus = x.LocationStatus
			}).ToList();

			foreach (var item in locations)
			{
			if (locationStatus == LocationEnum.Lock)
			{
			if (item.LocationCode == location.LocationCode)
			{
			item.LocationStatus = (int)LocationEnum.Lock;
			}
			}
			else if (locationStatus == LocationEnum.InStock)
			{
			if (item.LocationCode == location.LocationCode)
			{
			item.LocationStatus = (int)LocationEnum.InStock;
			}
			}
			else if (locationStatus == LocationEnum.InStockDisable)
			{
			if (item.LocationStatus == (int)LocationEnum.InStock)
			{
			item.LocationStatus = (int)LocationEnum.InStockDisable;
			}
			}
			else if (locationStatus == LocationEnum.Free)
			{
			item.LocationStatus = (int)LocationEnum.Free;
			}
			}
			List<DtLocationStatusChangeRecord> changeRecordDto = new List<DtLocationStatusChangeRecord>();
			foreach (var item in Beforelocation)
			{
			var loc = locations.Where(x => x.LocationCode == item.LocationCode).FirstOrDefault();
			if (loc != null)
			{
			DtLocationStatusChangeRecord dtLocationStatusChangeRecord = new DtLocationStatusChangeRecord()
			{
			ChangeType = StatusChangeType,
			LocationCode = item.LocationCode,
			LocationId = loc.Id,
			Creater = "System",
			TaskNum = taskNum,
			AfterStatus = loc.LocationStatus,
			BeforeStatus = item.LocationStatus,
			};

			changeRecordDto.Add(dtLocationStatusChangeRecord);
			}
			}
			return (changeRecordDto, locations);
			}

			public (DtLocationStatusChangeRecord, DtLocationInfo) UpdateLocationStatus(string locationCode, LocationEnum locationStatus, int taskNum, StatusChangeTypeEnum StatusChangeType)
			{
			var location = _locationRepository.QueryFirst(x => x.LocationCode == locationCode);
			int Beforelocation = location.LocationStatus;

			location.LocationStatus = (int)locationStatus;

			DtLocationStatusChangeRecord dtLocationStatusChangeRecord = new DtLocationStatusChangeRecord()
			{
			ChangeType = (int)StatusChangeType,
			LocationCode = locationCode,
			LocationId = location.Id,
			Creater = "System",
			TaskNum = taskNum,
			AfterStatus = location.LocationStatus,
			BeforeStatus = Beforelocation,
			};

			return (dtLocationStatusChangeRecord, location);
			}

			public List<DtLocationInfo> GetGroupLocations(DtLocationInfo location)
			{
			List<DtLocationInfo> locationInfos = _locationRepository.QueryData(x => x.AreaId == location.AreaId);
			List<DtLocationInfo> locations = new List<DtLocationInfo>() { location };
			if (location.AreaId == 1)
			{
			if (location.Depth == 2)
			{
			DtLocationInfo? locationInfo = locationInfos.FirstOrDefault(x => x.Depth == 1 && x.Column == location.Column && x.Layer == location.Layer && x.Row == 1);
			if (locationInfo != null)
			{
			locations.Add(locationInfo);
			}
			}
			}
			else if (location.AreaId == 2)
			{
			var locationLateral = _locationRepository.QueryData(x => x.Row == location.Row && x.Column > location.Column && x.Remark == location.Remark);
			if (locationLateral.Count > 0)
			{
			locations.AddRange(locationLateral);
			}
			}
			else if (location.AreaId == 5 \|\| location.AreaId == 6)
			{
			var locationLateral = _locationRepository.QueryData(x => x.Row == location.Row && x.Column < location.Column && x.Remark == location.Remark);
			if (locationLateral.Count > 0)
			{
			locations.AddRange(locationLateral);
			}
			}
			return locations;

			}

			/// <summary>
			/// åå»ºä»»å¡DTO
			@@ -648,9 +2104,10 @@
			RoadWay = task.Roadway,
			SourceAddress = task.SourceAddress,
			TargetAddress = task.TargetAddress,
			TaskState = task.TaskState.Value,
			TaskState = task.TaskState,
			Id = 0,
			TaskType = task.TaskType,
			Floor =task.Floor,
			AGVTaskNum = task.AGVTaskNum,
			} };
			}
			@@ -665,12 +2122,39 @@
			RoadWay = task.Roadway,
			SourceAddress = task.SourceAddress,
			TargetAddress = task.TargetAddress,
			TaskState = task.TaskState.Value,
			TaskState = task.TaskState,
			Id = 0,
			TaskType = task.TaskType,
			AGVTaskNum = task.AGVTaskNum,
			Remark = task.Remark,
			Floor = task.Floor,
			};
			}
			private List<WMSTaskDTO> CreateTaskDTO(List<Dt_Task> task)
			{
			List<WMSTaskDTO> taskNews = new List<WMSTaskDTO>();
			foreach (var item in task)
			{
			taskNews.Add(new WMSTaskDTO
			{
			TaskNum = item.TaskNum.Value,
			Grade = item.Grade.Value,
			PalletCode = item.PalletCode,
			RoadWay = item.Roadway,
			SourceAddress = item.SourceAddress,
			TargetAddress = item.TargetAddress,
			TaskState = item.TaskState,
			Id = 0,
			TaskType = item.TaskType,
			AGVTaskNum = item.AGVTaskNum,
			Remark = item.Remark,
			Floor = item.Floor,
			});
			}

			return taskNews;
			}

			private async Task DeleteStockInfoAsync(int stockId)
			{
			var isStockUpdated = await _stockInfoRepository.DeleteDataByIdAsync(stockId);
			@@ -689,14 +2173,24 @@
			}
			}

			private async Task UpdateLocationAsync(DtLocationInfo info)
			private async Task DeleteBoxingInfoAsync(int boxingId)
			{
			var isStockUpdated = await _locationRepository.UpdateDataAsync(info);
			var isStockUpdated = await _stockInfoRepository.DeleteDataByIdAsync(boxingId);
			if (!isStockUpdated)
			{
			throw new Exception("åºä½ä¿¡æ¯æ´æ°å¤±è´¥");
			throw new Exception("åºåä¿¡æ¯æ´æ°å¤±è´¥");
			}
			}

			private async Task AddBoxingHtyAsync(DtBoxingInfo_Hty boxingInfo)
			{
			var isStockAdd = await SqlSugarHelper.DbWMS.InsertNav(boxingInfo).IncludesAllFirstLayer().ExecuteCommandAsync();
			if (!isStockAdd)
			{
			throw new Exception("ç»çåå²ä¿¡æ¯æ·»å å¤±è´¥");
			}
			}


			private async Task DeleteStockInfoDetailsAsync(IEnumerable<DtStockInfoDetail> details)
			{
			@@ -794,105 +2288,16 @@
			return taskHty;
			}

			/// <summary>
			/// æ´æ°åºåä½ç½®
			/// </summary>
			/// <param name="stock">åºåå¯¹è±¡</param>
			/// <param name="toLocation">ç®æ ä½ç½®</param>
			// æ´æ°åºååä½ç½®ä¿¡æ¯
			private (DtStockInfo, DtLocationInfo, DtLocationInfo) UpdateStockLocation(DtStockInfo stock, Dt_Task task)
			{
			//ä¿®æ¹æ¥æºåºä½å ç®æ åºä½ç¶æ
			var fromLocation = _locationRepository.QueryFirst(x => x.LocationCode == task.SourceAddress && x.RoadwayNo == task.Roadway);
			fromLocation.LocationStatus = LocationEnum.Free.ObjToInt();
			var toLocation = _locationRepository.QueryFirst(x => x.LocationCode == task.SourceAddress && x.RoadwayNo == task.Roadway);
			toLocation.LocationStatus = LocationEnum.InStock.ObjToInt();

			// å°åºåä½ç½®è®¾ç½®ä¸ºç®æ ä½ç½®
			stock.LocationCode = task.TargetAddress;

			// è¿åæ´æ°åçåºååä½ç½®ä¿¡æ¯
			return (stock, fromLocation, toLocation);
			}

			#region ä»»å¡è¯·æ±æ¹æ³

			private static readonly SemaphoreSlim _semaphoreUpdate = new SemaphoreSlim(1, 1);
			// æ´æ°ä»»å¡è´§ä½

			private async Task<WebResponseContent> UpdateExistingTask(RequestTaskDto input, Dt_Task task)
			{
			await _semaphoreUpdate.WaitAsync();
			try
			{
			if (task == null)
			{
			return new WebResponseContent().Error("ä»»å¡å¯¹è±¡ä¸ºç©º");
			}

			try
			{
			// åå»ºWebResponseContentå¯¹è±¡
			var content = new WebResponseContent();


			var location = await GetEmptyLocation(task.Roadway);
			if (location == null)
			{
			return content.Error("æ æ³è·åè´§ä½ä¿¡æ¯");
			}

			string toAddress = location.LocationCode;
			int taskState = (int)TaskInStatusEnum.Line_InFinish;
			int beforeStatus = location.LocationStatus;
			// æ´æ°è´§ä½ä¿¡æ¯
			location.LocationStatus = (int)LocationEnum.Lock;

			// æ´æ°ä»»å¡ä¿¡æ¯
			MapTaskProperties(task, input, toAddress, taskState);

			// å¼å§äºå¡
			var isResult = await UpdateTaskAsync(task, location, beforeStatus);
			if (!isResult)
			{
			_unitOfWorkManage.RollbackTran();
			return content.Error("æ´æ°ä»»å¡å¤±è´¥");
			}

			// æäº¤äºå¡
			_unitOfWorkManage.CommitTran();
			return content.OK(data: task);

			}
			catch (Exception ex)
			{
			// åæ»äºå¡
			_unitOfWorkManage.RollbackTran();
			// è¿éå¯ä»¥æ·»å æ¥å¿è®°å½
			return new WebResponseContent().Error($"æ´æ°ä»»å¡æ¶åçéè¯¯: {ex.Message}");
			}
			}
			catch (Exception)
			{
			throw;
			}
			finally { _semaphoreUpdate.Release(); }
			}

			private void MapTaskProperties(Dt_Task task, RequestTaskDto input, string toAddress, int taskState)
			{
			task.CurrentAddress = input.Position;
			task.TargetAddress = toAddress;
			task.NextAddress = toAddress;
			task.TaskState = taskState;
			}

			// ä¿®æ¹ä»»å¡
			private async Task<bool> UpdateTaskAsync(Dt_Task task, DtLocationInfo location, int beforeStatus)
			{
			bool isResult = await BaseDal.UpdateDataAsync(task);
			bool isTaskDetail = await _taskExecuteDetailRepository.AddDetailAsync(task, false, TaskDescription.GetTaskUpdateDescription(task.PalletCode, task.CurrentAddress, task.TargetAddress, TaskInStatusEnum.Line_InFinish.GetIntegralRuleTypeEnumDesc()));

			LocationChangeRecordDto changeRecordDto = new LocationChangeRecordDto()
			{
			AfterStatus = location.LocationStatus,
			@@ -900,59 +2305,308 @@
			TaskNum = task.TaskNum.Value,
			LocationId = location.Id,
			LocationCode = location.LocationCode,
			ChangeType = (int)StatusChangeTypeEnum.AutomaticStorage,
			ChangeType = (int)StatusChangeTypeEnum.AutomaticInbound,
			};

			bool isUpdateChange = _locationStatusChangeRecordRepository.AddStatusChangeRecord(changeRecordDto);
			bool isUpdateLo = await _locationRepository.UpdateDataAsync(location);

			return isResult && isUpdateLo && isTaskDetail;
			return isResult && isUpdateLo;
			}

			private async Task<bool> AddTaskAsync(Dt_Task task, DtLocationInfo StartAddress, DtLocationInfo EndAddress)
			{
			bool isResult = await BaseDal.AddDataAsync(task) > 0;
			int SourcebeforeStatus = StartAddress.LocationStatus;

			int TargetbeforeStatus = EndAddress.LocationStatus;

			StartAddress.LocationStatus = (int)LocationEnum.InStockDisable;

			EndAddress.LocationStatus = (int)LocationEnum.Lock;

			List<LocationChangeRecordDto> changeRecordDto = new List<LocationChangeRecordDto>()
			{
			new LocationChangeRecordDto()
			{
			AfterStatus = StartAddress.LocationStatus,
			BeforeStatus = SourcebeforeStatus,
			TaskNum = task.TaskNum.Value,
			LocationId = StartAddress.Id,
			LocationCode = StartAddress.LocationCode,
			ChangeType = (int)StatusChangeTypeEnum.AutomaticRelocation,
			},
			new LocationChangeRecordDto()
			{
			AfterStatus = EndAddress.LocationStatus,
			BeforeStatus = TargetbeforeStatus,
			TaskNum = task.TaskNum.Value,
			LocationId = EndAddress.Id,
			LocationCode = EndAddress.LocationCode,
			ChangeType = (int)StatusChangeTypeEnum.AutomaticRelocation,
			},
			};

			bool isUpdateChange = _locationStatusChangeRecordRepository.AddStatusChangeRecord(changeRecordDto);
			bool Source = await _locationRepository.UpdateDataAsync(StartAddress);
			bool Target = await _locationRepository.UpdateDataAsync(EndAddress);

			return isResult && Source && Target;
			}

			private (List<DtLocationInfo>,List<DtLocationStatusChangeRecord>) AddTaskAsync(List<Dt_Task> task)
			{
			List<DtLocationStatusChangeRecord> changeRecordDto = new List<DtLocationStatusChangeRecord>();
			List<DtLocationInfo> locationos = new List<DtLocationInfo>();
			foreach (var item in task)
			{
			var SourceAddress = _locationRepository.QueryFirst(x => x.LocationCode == item.SourceAddress);
			var TargetAddress = _locationRepository.QueryFirst(x => x.LocationCode == item.TargetAddress);
			int SourcebeforeStatus = SourceAddress.LocationStatus;

			int TargetbeforeStatus = TargetAddress.LocationStatus;

			SourceAddress.LocationStatus = (int)LocationEnum.InStockDisable;
			TargetAddress.LocationStatus = (int)LocationEnum.Lock;
			changeRecordDto.Add(new DtLocationStatusChangeRecord()
			{
			ChangeType = (int)StatusChangeTypeEnum.AutomaticRelocation,
			LocationCode = TargetAddress.LocationCode,
			LocationId = TargetAddress.Id,
			Creater = "System",
			TaskNum = item.TaskNum,
			AfterStatus = TargetAddress.LocationStatus,
			BeforeStatus = TargetbeforeStatus,
			});
			changeRecordDto.Add(new DtLocationStatusChangeRecord
			{
			AfterStatus = TargetAddress.LocationStatus,
			BeforeStatus = TargetbeforeStatus,
			TaskNum = item.TaskNum.Value,
			Creater = "System",
			LocationId = TargetAddress.Id,
			LocationCode = TargetAddress.LocationCode,
			ChangeType = (int)StatusChangeTypeEnum.AutomaticRelocation,
			});
			locationos.Add(TargetAddress);
			locationos.Add(SourceAddress);
			}
			return (locationos, changeRecordDto);
			}

			/// <summary>
			/// è·åè´§ä½å·
			/// </summary>
			/// <returns></returns>
			public async Task<DtLocationInfo> GetEmptyLocation(string roadWay)
			{
			try
			List<DtLocationInfo> locations = await _locationRepository.QueryDataAsync(x => x.RoadwayNo == "SC1" && x.LocationStatus == (int)LocationEnum.Free && x.EnalbeStatus == 1);
			if (locations.Count < 2)
			{
			List<DtLocationInfo> LocationInfoList = await _locationRepository.QueryDataAsync(x => x.RoadwayNo == roadWay && x.LocationStatus == (int)LocationEnum.Free && x.EnalbeStatus == EnableEnum.Enable.ObjToInt());

			List<DtLocationInfo> LocationInfoResult = new List<DtLocationInfo>();
			foreach (DtLocationInfo item in LocationInfoList)
			{
			DtLocationInfo locationItem = new DtLocationInfo();

			if (item.Depth == 2)
			{
			locationItem = _locationRepository.QueryFirst(x => x.Column == item.Column && x.RoadwayNo == item.RoadwayNo && x.Layer == item.Layer && x.Depth != item.Depth && x.Row != item.Row && (SqlFunc.Abs(x.Row - item.Row) == 1) && x.LocationStatus == (int)LocationEnum.Free && x.EnalbeStatus == EnableEnum.Enable.ObjToInt());
			if (locationItem != null)
			{
			LocationInfoResult.Add(item);
			}
			}
			else
			{
			locationItem = _locationRepository.QueryFirst(x => x.Column == item.Column && x.RoadwayNo == item.RoadwayNo && x.Layer == item.Layer && x.Depth != item.Depth && x.Row != item.Row && (SqlFunc.Abs(x.Row - item.Row) == 1) && x.LocationStatus == (int)LocationEnum.InStock && x.EnalbeStatus == EnableEnum.Enable.ObjToInt());
			if (locationItem != null)
			{
			LocationInfoResult.Add(item);
			}
			}
			}
			if (LocationInfoResult.Count < 2)
			{
			throw new Exception("å½åç©ºé²è´§ä½ä¸è¶³ï¼");
			}

			return LocationInfoResult.OrderByDescending(x => x.Depth).ThenBy(x => x.Column).ThenBy(x => x.Layer).FirstOrDefault();
			return null;
			}
			catch (Exception ex)

			List<DtLocationInfo> locationInfos = new List<DtLocationInfo>();
			var locationInside = locations.Where(x => x.Row == 3).ToList();

			if (locations.Where(x => x.Row == 2).OrderBy(x => x.Layer).ThenBy(x => x.Column).FirstOrDefault() != null)
			{
			throw new Exception(ex.Message);
			return locations.Where(x => x.Row == 2).ToList().OrderBy(x => x.Layer).ThenBy(x => x.Column).FirstOrDefault();
			}
			else if (locationInside.Count > 0)
			{
			foreach (var item in locationInside)
			{
			var locationLateral = _locationRepository.QueryFirst(x => x.Row == 1 && x.Layer == item.Layer && x.Column == item.Column);
			if (locationLateral.LocationStatus == (int)LocationEnum.Free && locationLateral.EnalbeStatus == 1)
			{
			locationInfos.Add(item);
			}
			}

			return locationInfos.Distinct().OrderBy(x => x.Layer).ThenBy(x => x.Column).FirstOrDefault();
			}
			else if (locations.Where(x => x.Row == 1).OrderBy(x => x.Layer).ThenBy(x => x.Column).FirstOrDefault() != null)
			{
			return locations.Where(x => x.Row == 1).OrderBy(x => x.Layer).ThenBy(x => x.Column).FirstOrDefault();
			}
			else
			{
			return null;
			}
			}

			public async Task<DtLocationInfo> GetAGVEmptyCacheLocation(int AreaId, DtLocationInfo loc)
			{
			if (loc == null)
			{
			return null;
			}
			switch (AreaId)
			{
			case 2:
			return await FromShallowToDeep(AreaId, loc);
			case 3:
			return await AGVLIKU(AreaId);
			case 5:
			case 6:
			return await FromDeepToShallow(AreaId, loc);
			default:
			return null;
			}
			}

			/// <summary>
			/// ç±æ·±å°æµ
			/// </summary>
			/// <param name="AreaId"></param>
			/// <returns></returns>
			public async Task<DtLocationInfo> FromDeepToShallow(int AreaId, DtLocationInfo loc)
			{
			List<DtLocationInfo> locations = new List<DtLocationInfo>();

			if (AreaId == loc.AreaId)
			{
			locations = await _locationRepository.QueryDataAsync(x => x.AreaId == AreaId && x.LocationStatus == (int)LocationEnum.Free && x.EnalbeStatus == 1 && x.Row != loc.Row);
			}
			else
			{
			locations = await _locationRepository.QueryDataAsync(x => x.AreaId == AreaId && x.LocationStatus == (int)LocationEnum.Free && x.EnalbeStatus == 1);
			}
			if (locations.Count == 0)
			{
			return null;
			}
			List<DtLocationInfo> locationInfos = new List<DtLocationInfo>();
			foreach (var item in locations)
			{
			var locationLateral = _locationRepository.QueryData(x => x.Row == item.Row && x.Column < item.Column && x.Remark == item.Remark);
			if (locationLateral.Count == 0)
			{
			locationInfos.Add(item);
			continue;
			}
			bool Isavailable = true;
			foreach (var lateral in locationLateral)
			{
			if (lateral.LocationStatus != (int)LocationEnum.Free && lateral.EnalbeStatus == 1)
			{
			Isavailable = false;
			continue;
			}
			}
			if (Isavailable)
			locationInfos.Add(item);
			}

			return locationInfos.Distinct().OrderByDescending(x => x.Column).ThenBy(x => x.Row).FirstOrDefault();
			}

			/// <summary>
			/// ç±æµå°æ·±
			/// </summary>
			/// <param name="AreaId"></param>
			/// <returns></returns>
			public async Task<DtLocationInfo> FromShallowToDeep(int AreaId, DtLocationInfo loc)
			{
			List<DtLocationInfo> locations = new List<DtLocationInfo>();

			if (AreaId == loc.AreaId)
			{
			locations = await _locationRepository.QueryDataAsync(x => x.AreaId == AreaId && x.LocationStatus == (int)LocationEnum.Free && x.EnalbeStatus == 1 && x.Row != loc.Row);
			}
			else
			{
			locations = await _locationRepository.QueryDataAsync(x => x.AreaId == AreaId && x.LocationStatus == (int)LocationEnum.Free && x.EnalbeStatus == 1);
			}

			if (locations.Count == 0)
			{
			return null;
			}
			List<DtLocationInfo> locationInfos = new List<DtLocationInfo>();
			foreach (var item in locations)
			{
			var locationLateral = _locationRepository.QueryData(x => x.Row == item.Row && x.Column > item.Column && x.Remark == item.Remark);
			if (locationLateral.Count == 0)
			{
			locationInfos.Add(item);
			continue;
			}
			bool Isavailable = true;
			foreach (var lateral in locationLateral)
			{
			if (lateral.LocationStatus != (int)LocationEnum.Free && lateral.EnalbeStatus == 1)
			{
			Isavailable = false;
			continue;
			}
			}
			if (Isavailable)
			locationInfos.Add(item);
			}
			return locationInfos.Distinct().OrderBy(x => x.Column).ThenBy(x => x.Row).FirstOrDefault();

			}


			public async Task<DtLocationInfo> AGVLIKU(int AreaId)
			{
			WebResponseContent content = new WebResponseContent();

			List<DtLocationInfo> locations = await _locationRepository.QueryDataAsync(x => x.AreaId == AreaId && x.LocationStatus == 0 && x.EnalbeStatus == 1);
			var location = locations.OrderBy(x => x.Layer).ThenBy(x => x.Column).FirstOrDefault();
			return location;

			}


			public bool LocationIsOutBound(DtLocationInfo location)
			{
			if (location.AreaId == 1)
			{
			if (location.Depth == 2)
			{
			var locationLateral = _locationRepository.QueryFirst(x => x.Row == 1 && x.Column == location.Column && x.Layer == location.Layer);

			if (locationLateral.LocationStatus == (int)LocationEnum.Lock && locationLateral.EnalbeStatus == 1)
			{
			return false;
			}
			}
			}

			else if (location.AreaId == 2)
			{
			var locationLateral = _locationRepository.QueryData(x => x.Row == location.Row && x.Column > location.Column && x.Remark == location.Remark);

			foreach (var Lateral in locationLateral)
			{
			if (Lateral.LocationStatus == (int)LocationEnum.Lock && Lateral.EnalbeStatus == 1)
			{
			return false;
			}
			}
			}

			else if (location.AreaId == 5 \|\| location.AreaId == 6)
			{
			var locationLateral = _locationRepository.QueryData(x => x.Row == location.Row && x.Column < location.Column && x.Remark == location.Remark);

			foreach (var lateral in locationLateral)
			{
			if (lateral.LocationStatus == (int)LocationEnum.Lock && lateral.EnalbeStatus == 1)
			{
			return false;
			}
			}
			}

			return true;

			}


			#endregion ä»»å¡è¯·æ±æ¹æ³

			#endregion private åé¨æ¹æ³