ShiDaKe/ShenYangLiku.git

			@@ -32,6 +32,8 @@
			using System.Threading.Tasks;
			using WIDESEAWCS_QuartzJob.StackerCrane;
			using WIDESEAWCS_Core.BaseRepository;
			using Autofac.Core;
			using WIDESEAWCS_Tasks.ConveyorLineJob;

			namespace WIDESEAWCS_Tasks
			{
			@@ -43,8 +45,10 @@
			private readonly ICacheService _cacheService; private readonly IRepository<Dt_Router> _routerRepository;
			private readonly IRepository<Dt_StationManger> _stationMangerRepository;
			private readonly IRepository<Dt_Task> _taskRepository;
			private readonly CommonConveyorLineJob _lineJob;
			//bool SCres = false;

			public CommonStackerCraneJob(ITaskService taskService, ITaskExecuteDetailService taskExecuteDetailService, IRouterService routerService, ICacheService cacheService, IRepository<Dt_Router> routerRepository, IRepository<Dt_StationManger> stationMangerRepository, IRepository<Dt_Task> taskRepository)
			public CommonStackerCraneJob(ITaskService taskService, ITaskExecuteDetailService taskExecuteDetailService, IRouterService routerService, ICacheService cacheService, IRepository<Dt_Router> routerRepository, IRepository<Dt_StationManger> stationMangerRepository, IRepository<Dt_Task> taskRepository, CommonConveyorLineJob lineJob)
			{
			_taskService = taskService;
			_routerService = routerService;
			@@ -52,57 +56,62 @@
			_routerService = routerService;
			_stationMangerRepository = stationMangerRepository;
			_taskRepository = taskRepository;
			_lineJob = lineJob;
			}

			public Task Execute(IJobExecutionContext context)
			{
			try
			{
			SpeStackerCrane speStackerCrane = (SpeStackerCrane)context.JobDetail.JobDataMap.Get("JobParams");
			if (speStackerCrane != null)
			{
			GetStackerObject getStackerObject = new GetStackerObject(speStackerCrane);
			if (!getStackerObject.IsEventSubscribed)
			{
			getStackerObject.StackerCraneTaskCompletedEventHandler += CommonStackerCrane_StackerCraneTaskCompletedEventHandler;
			}
			getStackerObject.CheckStackerCraneTaskCompleted();
			if (getStackerObject.StackerCraneStatusValue == StackerCraneStatus.Normal)
			{
			Dt_Task? task = GetTasks(speStackerCrane);
			if (task != null)
			{
			bool sendFlag = true;
			if (sendFlag)
			{
			StackerCraneTaskCommand? stackerCraneTaskCommand = ConvertToStackerCraneTaskCommand(task);
			if (stackerCraneTaskCommand != null)
			{
			sendFlag = getStackerObject.SendCommand(stackerCraneTaskCommand);
			if (sendFlag)
			{
			speStackerCrane.SetValue(StackerCraneDBName.CommandSend, 1);//å¯å¨å½ä»¤
			speStackerCrane.LastTaskType = task.TaskType;
			task.Dispatchertime = DateTime.Now;
			task.ExceptionMessage = "";
			_taskService.UpdateTask(task, TaskStatusEnum.SC_Executing);
			//å»¶æ¶1s
			Thread.Sleep(1000);
			}
			}
			}
			}
			}
			}
			}
			catch (Exception)
			{
			{
			try
			{

			throw;
			}
			return Task.CompletedTask;
			}
			SpeStackerCrane speStackerCrane = (SpeStackerCrane)context.JobDetail.JobDataMap.Get("JobParams");
			if (speStackerCrane != null)
			{
			GetStackerObject getStackerObject = new GetStackerObject(speStackerCrane);
			if (!getStackerObject.IsEventSubscribed)
			{
			getStackerObject.StackerCraneTaskCompletedEventHandler += CommonStackerCrane_StackerCraneTaskCompletedEventHandler;
			}
			getStackerObject.CheckStackerCraneTaskCompleted();
			if (getStackerObject.StackerCraneStatusValue == StackerCraneStatus.Normal)
			{
			//var a = speStackerCrane.GetValue<StackerCraneDBName, Int32>(StackerCraneDBName.CurrentTaskNum);
			Dt_Task? task = GetTasks(speStackerCrane);
			if (task != null)
			{
			WriteInfo("æ¥æ¾å åæºä»»å¡å·", $"ä»»å¡ä¿¡æ¯,ä»»å¡å·:{task.TaskNum}ï¼å åæºç¼å·{speStackerCrane.DeviceCode}");
			bool sendFlag = true;
			if (sendFlag)
			{
			StackerCraneTaskCommand? stackerCraneTaskCommand = ConvertToStackerCraneTaskCommand(task); //è½¬æ¢ä¸ºå åæºä»»å¡
			if (stackerCraneTaskCommand != null)
			{
			sendFlag = getStackerObject.SendCommand(stackerCraneTaskCommand); //åéå åæºä»»å¡
			if (sendFlag)
			{
			speStackerCrane.SetValue(StackerCraneDBName.CommandSend, 1);//å¯å¨å½ä»¤
			speStackerCrane.LastTaskType = task.TaskType;
			task.Dispatchertime = DateTime.Now;
			task.ExceptionMessage = "";

			WebResponseContent webResponseContent = _taskService.UpdateTaskStatusToNext(task.TaskNum);
			//å»¶æ¶1s
			Thread.Sleep(1000);
			}
			}
			}
			}
			}
			}
			}
			catch (Exception)
			{

			throw;
			}
			return Task.CompletedTask;
			}


			private void CommonStackerCrane_StackerCraneTaskCompletedEventHandler(object? sender, StackerCraneTaskCompletedEventArgs e)
			{
			@@ -111,74 +120,21 @@
			{
			if (speStackerCrane.GetValue<StackerCraneDBName, short>(StackerCraneDBName.WorkType) != 5)
			{
			StackerCraneTaskCompleted(e.TaskNum, speStackerCrane.DeviceCode);
			speStackerCrane.SetValue(StackerCraneDBName.WorkType, 5);
			var TaskNum = speStackerCrane.GetValue<StackerCraneDBName, Int32>(StackerCraneDBName.CurrentTaskNum);
			WriteInfo("å åæºä»»å¡å®æ", $"ä»»å¡å·:{TaskNum}");
			bool res = _taskService.StackCraneTaskCompleted(e.TaskNum);
			if(res == true)
			{
			speStackerCrane.SetValue(StackerCraneDBName.WorkType, 5);

			}
			WriteInfo("å åæºä»»å¡å®æåé¦ä»»å¡å·", $"ä»»å¡ä¿¡æ¯,ä»»å¡å·:{e.TaskNum}");
			return;
			//SCres=true;
			}
			}
			}
			public WebResponseContent StackerCraneTaskCompleted(int taskNum, string deviceCode)
			{
			try
			{
			Dt_Task task = _taskRepository.QueryFirst(x => x.TaskNum == taskNum);
			if (task != null)
			{
			if (task.TaskType.GetTaskTypeGroup() == TaskTypeGroup.OutbondGroup)
			{
			Dt_StationManger stationManger = _stationMangerRepository.QueryFirst(x => x.StackerCraneStationCode == task.NextAddress && x.StackerCraneCode == deviceCode);
			if (stationManger == null)
			{
			//_taskExecuteDetailService.AddTaskExecuteDetail(taskNum, $"è¾éçº¿åºåºç«ç¹æªéç½®,{task.NextAddress}");
			_taskService.UpdateTaskExceptionMessage(taskNum, $"è¾éçº¿åºåºç«ç¹æªéç½®,{task.NextAddress}");
			WriteError(deviceCode, $"è¾éçº¿åºåºç«ç¹æªéç½®,{task.NextAddress}");
			return WebResponseContent.Instance.Error($"è¾éçº¿åºåºç«ç¹æªéç½®,{task.NextAddress}");
			}
			Dt_Router router = _routerRepository.QueryFirst(x => x.InOutType == task.TaskType && x.StartPosi == stationManger.StationCode);
			if (router == null)
			{
			router = _routerRepository.QueryFirst(x => x.ChildPosi == deviceCode && x.ChildPosiDeviceCode == stationManger.StationDeviceCode && x.NextPosi == stationManger.StationCode && x.InOutType == task.TaskType && x.IsEnd);
			if (router != null && router.IsEnd)
			{
			_taskService.TaskCompleted(taskNum);
			}
			else
			{
			_taskService.UpdateTaskExceptionMessage(taskNum, $"æªæ¾å°è·¯ç±ä¿¡æ¯,{task.NextAddress}");
			WriteError(deviceCode, $"æªæ¾å°è·¯ç±ä¿¡æ¯,{task.NextAddress}");
			return WebResponseContent.Instance.Error($"æªæ¾å°è·¯ç±ä¿¡æ¯,{task.NextAddress}");
			}
			}
			if (task.TargetAddress.Contains("1030") \|\| task.TargetAddress.Contains("1026")) //èªå¨ä¸çº¿
			{
			_taskService.UpdateTask(task, TaskStatusEnum.Line_Execute, deviceCode: stationManger.StationDeviceCode, currentAddress: router.NextPosi);
			}

			}
			else if (task.TaskType.GetTaskTypeGroup() == TaskTypeGroup.InboundGroup \|\| task.TaskType.GetTaskTypeGroup() == TaskTypeGroup.RelocationGroup)
			{
			_taskService.TaskCompleted(taskNum);
			}
			else
			{
			WriteError(deviceCode, $"æªæ¾å°è¯¥ä»»å¡ç±»ååè°WMSä»»å¡å®ææ¥å£,{task.TaskType}");
			_taskService.UpdateTaskExceptionMessage(taskNum, $"æªæ¾å°è¯¥ä»»å¡ç±»ååè°WMSä»»å¡å®ææ¥å£,{task.TaskType}");
			}

			}
			else
			{
			WriteError(deviceCode, $"æªæ¾å°ä»»å¡ä¿¡æ¯,ä»»å¡å·:{taskNum}");
			return WebResponseContent.Instance.Error($"æªæ¾å°ä»»å¡ä¿¡æ¯,ä»»å¡å·:{taskNum}");
			}

			return WebResponseContent.Instance.OK();
			}
			catch (Exception ex)
			{
			WriteError(deviceCode, $"ä»»å¡å®æéè¯¯", ex);
			return WebResponseContent.Instance.Error(ex.Message);
			}
			}

			/// <summary>
			/// è·åä»»å¡
			/// </summary>
			@@ -187,48 +143,116 @@
			private Dt_Task? GetTasks(SpeStackerCrane commonStackerCrane)
			{
			Dt_Task? task;

			if (commonStackerCrane.LastTaskType.GetValueOrDefault().GetTaskTypeGroup() == TaskTypeGroup.OutbondGroup)
			// PLCç¶ææ£æ¥ï¼WorkTypeå¿é¡»ä¸º0ï¼ç©ºé²ç¶æï¼
			var workType = commonStackerCrane.GetValue<StackerCraneDBName, byte>(StackerCraneDBName.StackerCraneWorkStatus);
			//var workType = commonStackerCrane.GetValue<StackerCraneDBName, byte>(StackerCraneDBName.StackerCraneWorkStatus);
			if (workType != 0)
			{
			task = _taskService.QueryStackerCraneInTask(commonStackerCrane.DeviceCode);
			if (task == null)
			return null;
			}

			//å åæºæ§è¡ä¸
			if (_taskRepository.QueryFirst(x => x.DeviceCode == commonStackerCrane.DeviceCode && x.TaskState == TaskStatusEnum.SC_Executing.ObjToInt()) != null)
			{
			return null;
			}

			task = _taskService.QueryStackerCraneInTask(commonStackerCrane.DeviceCode); //è·åå¥åºä»»å¡
			List<Dt_Task> YKtasks = _taskService.QueryStackerCraneYKTasks(commonStackerCrane.DeviceCode);


			if (task != null)
			{

			if (task.Roadway == "SC02") return task; //å¦ææä»»å¡åç´æ¥ä¸åç»å åæº
			if (task.Depth == 1) return task;
			//2æ·±ä½è¿è¡å¤ææ¯å¦è¦ç§»åº
			Dt_Task dt_Task = _taskService.RequestWMSTaskMovelibrary(task);
			if (dt_Task != null) return dt_Task;
			}
			else if (YKtasks.Count > 0) //åºä½è°æ¨
			{
			foreach (var item in YKtasks)
			{
			task = _taskService.QueryStackerCraneOutTask(commonStackerCrane.DeviceCode);
			if (item.Roadway == "SC01")
			{
			if (item.Depth == 1) return item;
			//è°åWMSæ¥å£è¿è¡å¤ææ¯å¦éè¦è¿è¡ç§»åº
			Dt_Task dt_Task = OutTaskMovelibrary(item);
			if (dt_Task != null) return dt_Task;

			else
			{
			return item;
			}
			}
			}

			}
			else
			{
			task = _taskService.QueryStackerCraneOutTask(commonStackerCrane.DeviceCode);
			if (task == null)
			{
			task = _taskService.QueryStackerCraneInTask(commonStackerCrane.DeviceCode);
			}
			}
			//è¿è¡è·åå åæºåºåºä»»å¡
			List<Dt_Task> tasks = _taskService.QueryStackerCraneOutTasks(commonStackerCrane.DeviceCode);


			if (task != null && task.TaskType.GetTaskTypeGroup() == TaskTypeGroup.OutbondGroup)
			{
			if (OutTaskStationIsOccupied(task) != null \|\| true)
			{
			return task;
			}
			else
			{
			List<string> otherOutStaionCodes = _routerService.QueryNextRoutes(commonStackerCrane.DeviceCode, task.NextAddress).Select(x => x.ChildPosi).ToList();
			List<Dt_Task> tasks = _taskService.QueryStackerCraneOutTasks(commonStackerCrane.DeviceCode, otherOutStaionCodes);
			foreach (var item in tasks)
			{
			if (OutTaskStationIsOccupied(task) != null)
			//if (item.TargetAddress == "2021"\|\|item.TargetAddress == "2020")
			//{
			// ////bool IsOccupied = _lineJob.GetPick();

			// //if (!IsOccupied)
			// //{
			// // return null;
			// //}
			//}
			if (OutTaskStationIsOccupied(item) != null)
			{
			return task;
			if (item.Roadway == "SC01")
			{
			if (item.Depth == 1) return item;
			//è°åWMSæ¥å£è¿è¡å¤ææ¯å¦éè¦è¿è¡ç§»åº
			Dt_Task dt_Task = OutTaskMovelibrary(item);
			if (dt_Task != null) return dt_Task;

			}
			else
			{
			return item;
			}
			}
			}
			task = _taskService.QueryStackerCraneInTask(commonStackerCrane.DeviceCode);

			}
			}


			return task;
			}

			private Dt_Task? OutTaskMovelibrary([NotNull] Dt_Task task)
			{
			string[] targetCodes = task.SourceAddress.Split("-");
			if (targetCodes[1] == "001")
			{
			targetCodes[1] = "002";

			}
			else if (targetCodes[1] == "004")
			{
			targetCodes[1] = "003";
			}
			targetCodes[4] = "01";
			string SourceAddress = string.Join("-", targetCodes); //ç»è£æµåºä½å°å
			Dt_Task? tasks = _taskService.QueryStationIsOccupiedOutTasks(task.Roadway, SourceAddress); //æ¾æµåºä½æ¯å¦æä»»å¡
			if (tasks != null) return tasks;
			//åwmsç³è¯·å¤ææµåºä½æ¯å¦æè´§ï¼æ¯å¦éè¦è¿è¡ç§»åº
			Dt_Task? taskst = _taskService.RequestWMSTaskMovelibrary(task);
			if (taskst != null) return taskst;
			return null;
			}




			/// <summary>
			/// åºåºä»»å¡å¤æåºåºç«å°æ¯å¦è¢«å ç¨
			/// </summary>
			@@ -236,26 +260,48 @@
			/// <returns>å¦ææªè¢«å ç¨ï¼è¿åä¼ å¥çä»»å¡ä¿¡æ¯ï¼å¦åï¼è¿ånull</returns>
			private Dt_Task? OutTaskStationIsOccupied([NotNull] Dt_Task task)
			{
			Dt_Router? router = _routerService.QueryNextRoutes(task.Roadway, task.NextAddress).FirstOrDefault();
			if (router != null)
			try
			{
			IDevice? device = Storage.Devices.FirstOrDefault(x => x.DeviceCode == router.ChildPosiDeviceCode);
			IDevice? device = Storage.Devices.FirstOrDefault(x => x.DeviceCode == "CL01");
			if (device != null)
			{
			CommonConveyorLine conveyorLine = (CommonConveyorLine)device;
			if (conveyorLine.IsOccupied(router.ChildPosi))//åºåºç«å°æªè¢«å ç¨
			OtherDevice conveyorLine = (OtherDevice)device;
			DeviceProDTO? deviceProDTO = conveyorLine.DeviceProDTOs.FirstOrDefault(x => x.DeviceChildCode == task.NextAddress && x.DeviceProParamName == "IsOccupied"); //æ ¹æ®å åæºå°åï¼å°ååç§°æ¾åè®®
			if (deviceProDTO != null)
			{
			return task;
			bool B_Event_Test = conveyorLine.Communicator.Read<bool>(deviceProDTO.DeviceProAddress); //å¤æè¾éçº¿æ¯å¦åè®¸æ¾è´§ä¿¡å·
			if (!B_Event_Test)
			{
			return task;
			}
			}
			}
			else
			{
			_taskService.UpdateTaskExceptionMessage(task.TaskNum, $"æªæ¾å°åºåºç«å°ã{router.ChildPosiDeviceCode}ãå¯¹åºçéè®¯å¯¹è±¡ï¼æ æ³å¤æåºåºç«å°æ¯å¦è¢«å ç¨");
			//if (task.NextAddress == "2021" \|\| task.NextAddress == "2020")
			//{
			// DeviceProDTO? deviceProDTO1 = conveyorLine.DeviceProDTOs.FirstOrDefault(x => x.DeviceChildCode == "2008" \|\| x.DeviceChildCode == "2009" \|\| x.DeviceChildCode == "2015" \|\| x.DeviceChildCode == "2016" && x.DeviceProParamName == "IsOccupied"); //æ ¹æ®å åæºå°åï¼å°ååç§°æ¾åè®®
			// if (deviceProDTO != null)
			// {
			// bool IsOccupied2008 = conveyorLine.GetValue<W_ConveyorLineDB, bool>(W_ConveyorLineDB.IsOccupied, "2008");
			// bool IsOccupied2009 = conveyorLine.GetValue<W_ConveyorLineDB, bool>(W_ConveyorLineDB.IsOccupied, "2009");
			// bool IsOccupied2015 = conveyorLine.GetValue<W_ConveyorLineDB, bool>(W_ConveyorLineDB.IsOccupied, "2015");
			// bool IsOccupied2016 = conveyorLine.GetValue<W_ConveyorLineDB, bool>(W_ConveyorLineDB.IsOccupied, "2016");

			// //å¤ææ¯å¦æç«
			// if (IsOccupied2008 && IsOccupied2009 && IsOccupied2015 && IsOccupied2016)
			// {
			// return null;
			// }
			// else
			// {
			// return task;
			// }
			// }
			//}
			}
			}
			else
			catch (Exception ex)
			{
			_taskService.UpdateTaskExceptionMessage(task.TaskNum, $"æªæ¾å°ç«å°ã{task.NextAddress}ãä¿¡æ¯ï¼æ æ³æ ¡éªç«å°");

			throw;
			}
			return null;
			}
			@@ -274,10 +320,13 @@
			stackerCraneTaskCommand.TaskNum = task.TaskNum;
			stackerCraneTaskCommand.WorkType = 1;
			stackerCraneTaskCommand.TrayType = 1;
			if (task.TaskType.GetTaskTypeGroup() == TaskTypeGroup.InboundGroup)//å¤ææ¯å¦æ¯å¥åºä»»å¡
			if (task.TaskType == (int)TaskInboundTypeEnum.Inbound)//å¤ææ¯å¦æ¯å¥åºä»»å¡
			{

			string[] startCodes = task.SourceAddress.Split("-");
			Dt_StationManger dt_StationManger = _stationMangerRepository.QueryFirst(x => x.StationCode == task.SourceAddress);


			string[] startCodes = dt_StationManger.StackerCraneStationCode.Split("-");
			if (startCodes.Length == 3)
			{
			stackerCraneTaskCommand.StartRow = Convert.ToInt16(startCodes[0]);
			@@ -301,21 +350,22 @@
			}

			}
			else if (task.TaskType.GetTaskTypeGroup() == TaskTypeGroup.OutbondGroup)
			else if (task.TaskType == (int)TaskOutboundTypeEnum.Outbound)
			{
			Dt_StationManger dt_StationManger = _stationMangerRepository.QueryFirst(x => x.StationCode == task.TargetAddress);

			string[] targetCodes = task.TargetAddress.Split("-");
			string[] targetCodes = dt_StationManger.StackerCraneStationCode.Split("-");

			stackerCraneTaskCommand.EndRow = Convert.ToInt16(targetCodes[0]);
			stackerCraneTaskCommand.EndColumn = Convert.ToInt16(targetCodes[1]);
			stackerCraneTaskCommand.EndLayer = Convert.ToInt16(targetCodes[2]);

			string[] sourceCodes = task.SourceAddress.Split("-");
			if (sourceCodes.Length == 3)
			if (sourceCodes.Length == 5)
			{
			stackerCraneTaskCommand.StartRow = Convert.ToInt16(sourceCodes[0]);
			stackerCraneTaskCommand.StartColumn = Convert.ToInt16(sourceCodes[1]);
			stackerCraneTaskCommand.StartLayer = Convert.ToInt16(sourceCodes[2]);
			stackerCraneTaskCommand.StartRow = Convert.ToInt16(sourceCodes[1]);
			stackerCraneTaskCommand.StartColumn = Convert.ToInt16(sourceCodes[2]);
			stackerCraneTaskCommand.StartLayer = Convert.ToInt16(sourceCodes[3]);
			}
			else
			{
			@@ -325,14 +375,14 @@
			}

			}
			else if (task.TaskType.GetTaskTypeGroup() == TaskTypeGroup.RelocationGroup)
			else if (task.TaskType == (int)TaskRelocationTypeEnum.Relocation) //å¤æç§»åºä»»å¡
			{
			string[] targetCodes = task.NextAddress.Split("-");
			if (targetCodes.Length == 3)
			if (targetCodes.Length == 5)
			{
			stackerCraneTaskCommand.EndRow = Convert.ToInt16(targetCodes[0]);
			stackerCraneTaskCommand.EndColumn = Convert.ToInt16(targetCodes[1]);
			stackerCraneTaskCommand.EndLayer = Convert.ToInt16(targetCodes[2]);
			stackerCraneTaskCommand.EndRow = Convert.ToInt16(targetCodes[1]);
			stackerCraneTaskCommand.EndColumn = Convert.ToInt16(targetCodes[2]);
			stackerCraneTaskCommand.EndLayer = Convert.ToInt16(targetCodes[3]);
			}
			else
			{
			@@ -341,11 +391,11 @@
			return null;
			}
			string[] sourceCodes = task.CurrentAddress.Split("-");
			if (sourceCodes.Length == 3)
			if (sourceCodes.Length == 5)
			{
			stackerCraneTaskCommand.StartRow = Convert.ToInt16(sourceCodes[0]);
			stackerCraneTaskCommand.StartColumn = Convert.ToInt16(sourceCodes[1]);
			stackerCraneTaskCommand.StartLayer = Convert.ToInt16(sourceCodes[2]);
			stackerCraneTaskCommand.StartRow = Convert.ToInt16(sourceCodes[1]);
			stackerCraneTaskCommand.StartColumn = Convert.ToInt16(sourceCodes[2]);
			stackerCraneTaskCommand.StartLayer = Convert.ToInt16(sourceCodes[3]);
			}
			else
			{