HightWay_AirPot_WCS/SlnMesnac.Business/base/BaseTaskInfoBusiness.cs

using Microsoft.Extensions.Logging;
using SlnMesnac.Repository.service;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Threading.Tasks;
using SlnMesnac.Repository;
using SlnMesnac.Repository.service.Impl;
using TouchSocket.Sockets;
using SlnMesnac.Model.domain;
using SlnMesnac.TouchSocket;
using System.Timers;
using SlnMesnac.Model.Enum;
using HslCommunication.Enthernet;
using System.Threading;
using SlnMesnac.TouchSocket.Entity;
using SlnMesnac.Model.AirportApiEntity;
using System.Linq;

namespace SlnMesnac.Business.@base
{
    public class BaseTaskInfoBusiness
    {
        private TcpServer _tcpServer = null;
        public Action<AirportTask> _Taskaction;
        public Action<string> _RefreshLogMessageAction;
        private static BaseTaskInfoBusiness instance;
        private ILogger<BaseTaskInfoBusiness> _logger;
        private IAirportTaskService _Taskservice;
        private IAGVStateService _AGVStateService;
        private AirPorthttpClient _airpttpClient;
        public BaseTaskInfoBusiness(
            ILogger<BaseTaskInfoBusiness> logger,
            IAirportTaskService Taskservice,
            IAGVStateService agvService,
            TcpServer tcpServer,
            AirPorthttpClient airPorthttpClient)
        {
            _logger = logger;
            _tcpServer = tcpServer;
            _Taskservice = Taskservice;
            _AGVStateService = agvService;
            _airpttpClient = airPorthttpClient;
            InitClearTimer();
            //doWhileGetAGVTaskInfo();
        }

        public static BaseTaskInfoBusiness GetInstance(
            ILogger<BaseTaskInfoBusiness> logger,
            IAirportTaskService Taskservice,
            IAGVStateService agvService,
            TcpServer tcpServer,
            AirPorthttpClient airPorthttpClient)
        {
            if (instance == null)
            {
                instance = new BaseTaskInfoBusiness(logger, Taskservice, agvService, tcpServer, airPorthttpClient);
            }
            return instance;
        }

        /// <summary>
        /// 从航班接口获取到新任务插入数据库
        /// </summary>
        /// <returns></returns>
        public async Task<bool> NewTaskInfo(string taskNo, string conveyNo, string flightNo, int totalCount)
        {
            var task = new AirportTask()
            {
                taskno = taskNo,
                conveyorno = conveyNo,
                flightno = flightNo,
                amragvno = string.Empty,
                amragvisarrive = string.Empty,
                deliveragvno = string.Empty,
                deliveragvisarrive = string.Empty,
                totalcount = totalCount,
                loadcount = 0,
                taskstate = "新任务待分配",
                starttime = DateTime.Now,
                finishtime = null,
                deliveragvTaskNo = string.Empty,
                amragvTaskNo = string.Empty,
            };

            try
            {
                return await _Taskservice.AddTaskAsync(task);
            }
            catch (Exception ex)
            {
                _logger.LogError("航班任务新建失败");
                return false;
            }
        }



        /// <summary>
        /// 获取任务列表，向待执行任务派发AGV （定期执行）
        /// </summary>
        private void GetAGVTaskInfo(object source, ElapsedEventArgs e)
        {
            try
            {
                //获取任务列表
                List<AirportTask> Task = _Taskservice.GetAGVTaskInfos();
                if (Task != null && Task.Count > 0)
                {
                    //更新前端
                    _RefreshLogMessageAction?.Invoke("任务数量:" + Task.Count);
                    foreach (AirportTask taskItem in Task)
                    {
                        //判断任务是否未完成
                        if (taskItem.totalcount < taskItem.loadcount && taskItem.finishtime == null && taskItem.taskstate != "已完成")
                        {
                            //判断任务是否有小车正在执行
                            if (!string.IsNullOrEmpty(taskItem.deliveragvno) && !string.IsNullOrEmpty(taskItem.amragvno))
                            {
                                continue;
                            }
                            else
                            {
                                //Deliver未派发，AMR未派发
                                if (string.IsNullOrEmpty(taskItem.deliveragvno) && string.IsNullOrEmpty(taskItem.amragvno))
                                {
                                    _RefreshLogMessageAction?.Invoke($"正在为AGV，AMR分配任务...");
                                    _logger.LogInformation($"正在为AGV，AMR分配任务");

                                    //查询AGV设备状态及AMR设备状态
                                    //这里要看AGV是否会立刻更新状态
                                    CreateAGVTask(taskItem);
                                    //查询机械臂状态
                                }
                                //Deliver已派发，AMR未派发
                                if (!string.IsNullOrEmpty(taskItem.deliveragvno) && string.IsNullOrEmpty(taskItem.amragvno))
                                {
                                    _RefreshLogMessageAction?.Invoke($"正在为AMR分配任务...");
                                    _logger.LogInformation($"正在为AMR分配任务");
                                    //查询AMR状态
                                    CreateAMRTask(taskItem);
                                }
                                //Deliver未派发，AMR已派发
                                if (string.IsNullOrEmpty(taskItem.deliveragvno) && !string.IsNullOrEmpty(taskItem.amragvno))
                                {
                                    _RefreshLogMessageAction?.Invoke($"正在为AGV分配任务...");
                                    _logger.LogInformation($"正在为AGV分配任务");
                                }
                            }
                            
                            _Taskaction?.Invoke(taskItem);
                        }
                    }
                }
            }
            catch (Exception ex)
            {

            }
        }











        /// <summary>
        /// 调用接口更新指定的任务状态
        /// </summary>
        /// <param name="request"></param>
        public void RefreshTaskStateForResopnse(AGVRequestTaskStateDetailEntity request)
        {
            AGVResponseEntity<ResponseTaskStateDetailDataEntity> response = _airpttpClient.AGVGetTaskStateDetailRequest(request);
            if (response.code == 1)
            {
                _logger.LogError("返回错误：" + response.message);
                return;
            }
            if (response.code == 0)
            {
                AirportTask record = new AirportTask();
                List<AirportTask> list = _Taskservice.GetTaskInfos();
                //list.Where(x => x.taskno == response.Data
            }
        }

        /// <summary>
        /// 持续读取AGV状态信息
        /// </summary>
        private void doWhileGetAGVTaskInfo()
        {
            try
            {
                Task.Run((() =>
                {
                    while (true)
                    {
                        GetAGVTaskInfo(null, null);
                        Task.Delay(1000);
                    }

                }));

            }
            catch (Exception ex)
            {

            }
        }

        /// <summary>
        /// 清理Timer
        /// </summary>
        private void InitClearTimer()
        {
            System.Timers.Timer timer = new System.Timers.Timer
            {
                Interval = 1000, // 每天执行一次
                AutoReset = true,

            };
            timer.Elapsed += GetAGVTaskInfo;
            timer.Start();

        }
        

        /// <summary>
        /// 向AMR派发任务
        /// </summary>
        /// <param name="AirportTask"></param>
        /// <returns></returns>
        private bool CreateAMRTask(AirportTask AirportTask)
        {
            bool iflag = false;
            try
            {
                iflag = true;
                //获取AMR设备状态
                List<AGVState> State = _AGVStateService.GetAgvState(AgvType.AMR);
                foreach (var AgvItem in State)
                {
                    //根据规则筛选最优AGV
                    if (AgvItem.agvworkstate == "任务空闲")
                    {
                        _logger.LogInformation($"获取空闲AMR列表");
                        _RefreshLogMessageAction?.Invoke("执行站台[" + AirportTask.conveyorno + "]，下发" + "[" + AirportTask.taskno + "]任务");
                        //调用派发任务接口,向任务状态为任务空闲的AGV派发任务
                        bool iTaskflag = true;
                        if (iTaskflag)
                        {
                            _RefreshLogMessageAction?.Invoke("[" + AgvItem.agvno + "]AMR，执行任务[" + AirportTask.taskno + "]");
                            AgvItem.taskno = AirportTask.taskno;
                            AgvItem.agvworkstate = "任务执行中";
                            AgvItem.refreshtime = DateTime.Now;
                            _AGVStateService.UpdateAsync(AgvItem);

                            //更新任务信息表状态为执行中
                            AirportTask.amragvno = AgvItem.agvno;
                            AirportTask.taskstate = "执行中";
                            _Taskservice.UpdateTaskAsync(AirportTask);
                            break;
                        }
                    }
                }
                return iflag;
            }
            catch (Exception ex)
            {
                return iflag;
            }
        }

        /// <summary>
        /// 向DeliverAGV派发任务
        /// </summary>
        /// <returns></returns>
        private bool CreateAGVTask(AirportTask AirportTask)
        {
            bool iflag = false;
            try
            {
                iflag = true;
                //获取DeliverAGV设备状态
                List<AGVState> State = _AGVStateService.GetAgvState(AgvType.Deliver);
                foreach (var AgvItem in State)
                {
                    //根据规则筛选最优AGV
                    if (AgvItem.agvworkstate == "任务空闲")
                    {
                        _logger.LogInformation($"获取空闲AGV列表");
                        _RefreshLogMessageAction?.Invoke("执行站台[" + AirportTask.conveyorno + "]，下发" + "[" + AirportTask.taskno + "]任务");
                        //调用派发任务接口,向任务状态为任务空闲的AGV派发任务
                        bool iTaskflag = true;
                        if (iTaskflag)
                        {
                            _RefreshLogMessageAction?.Invoke("[" + AgvItem.agvno + "]AGV，执行任务[" + AirportTask.taskno + "]");
                            AgvItem.taskno = AirportTask.taskno;
                            AgvItem.agvworkstate = "任务执行中";
                            AgvItem.refreshtime = DateTime.Now;
                            _AGVStateService.UpdateAsync(AgvItem);

                            //更新任务信息表状态为执行中
                            AirportTask.deliveragvno = AgvItem.agvno;
                            AirportTask.taskstate = "执行中";
                            _Taskservice.UpdateTaskAsync(AirportTask);
                            break;
                        }
                    }
                }
                return iflag;
            }
            catch (Exception ex)
            {
                return iflag;
            }
        }

        /// <summary>
        /// 获取任务状态详情
        /// </summary>
        private void GetTaskStateDetail()
        {
            try
            {
                Task.Run(() =>
                {
                    List<AirportTask> Task = _Taskservice.GetAGVTaskInfos();
                    if (Task.Count > 0)
                    {
                        // 设置计时器
                        Stopwatch stopwatch = new Stopwatch();
                        stopwatch.Start();
                        //通过任务编号查询agv任务



                        // 检查是否超过两秒
                        if (stopwatch.ElapsedMilliseconds > 2000)
                        {
                            _logger.LogError("超时");
                        }
                        Thread.Sleep(100);
                    }

                });
            }
            catch (Exception ex)
            {

            }
        }

    }
}