TEAMModelOS/TEAMModelOS.Extension/HTEX.Complex/Controllers/ScreenController.cs

using Microsoft.AspNetCore.Mvc;
using TEAMModelOS.SDK.DI;
using TEAMModelOS.SDK;
using Microsoft.AspNetCore.SignalR;
using HTEX.Complex.Services;
using System.Text.Json;
using TEAMModelOS.SDK.Extension;
using TEAMModelOS.SDK.DI.Device;
using Microsoft.Azure.Amqp.Framing;

namespace HTEX.Complex.Controllers
{
    [ApiController]
    [Route("api/screen")]
    public class ScreenController : ControllerBase
    {
        private readonly DingDing _dingDing;
        private readonly IHttpClientFactory _httpClient;
        private readonly IConfiguration _configuration;
        private readonly AzureStorageFactory _azureStorage;
        private readonly AzureRedisFactory _azureRedis;
        private readonly IHubContext<SignalRScreenServerHub> _screenServerHub;
        private readonly ILogger<ScreenController> _logger;
        private readonly CoreDevice _device;

        public ScreenController(AzureRedisFactory azureRedis,  IHttpClientFactory httpClient, IConfiguration configuration, AzureStorageFactory azureStorage,
            DingDing dingDing, IHubContext<SignalRScreenServerHub> screenServerHub , ILogger<ScreenController> logger, CoreDevice device)
        {
            _httpClient = httpClient;
            _configuration = configuration;
            _azureStorage = azureStorage;
            _dingDing = dingDing;
            _azureRedis=azureRedis;
            _screenServerHub = screenServerHub;
            _logger = logger;
            _device = device;
        }
        /// <summary>
        /// 添加任务
        /// </summary>
        /// <returns></returns>
        [HttpPost("push-task")]
        public async Task<IActionResult> AddTask(JsonElement json) 
        {
            GenPDFData  genPDFData = json.ToObject<GenPDFData>();
            ClientDevice serverDevice =  await _device.GetCoreDevice();
            var addData = await GenPDFService.AddGenPdfQueue(_azureRedis, genPDFData, serverDevice);
            await ManualSendTask();
            return Ok(new { add= addData .add ,total= addData .total});
        }
        /// <summary>
        /// 外部触发任务发送
        /// </summary>
        /// <returns></returns>
        [HttpPost("send-task")]
        public async Task<IActionResult> SendTask(JsonElement json)
        {
            await ManualSendTask(); 
            return Ok();
        }

        private async Task ManualSendTask()
        {
            ClientDevice serverDevice = await _device.GetCoreDevice();
            var values = await _azureRedis.GetRedisClient(8).HashGetAllAsync($"ScreenApi:clients:{serverDevice.deviceId}");
            if (values!=null)
            {
                foreach (var value in values)
                {
                    ScreenClient screenClient = value.Value.ToString().ToObject<ScreenClient>();
                    //先检查状态是否是在忙碌，在时间戳范围里，如果不在时间戳范围，强制free。
                    if (!screenClient.status!.Equals(ScreenConstant.idle) && screenClient.last_time  + screenClient.timeout+ screenClient.delay + ScreenConstant.time_excess < DateTimeOffset.UtcNow.ToUnixTimeMilliseconds())
                    {
                        screenClient.status = ScreenConstant.idle;
                    }
                    if (screenClient.status!.Equals(ScreenConstant.idle) && !string.IsNullOrWhiteSpace(screenClient.connid))
                    {
                        ////////////////////
                        ///检擦是否在线
                        //var cts = new CancellationTokenSource();
                        //try
                        //{
                        //    await _screenServerHub.Clients.Client(screenClient.connid!).SendAsync("ReceiveConnection", new ConnectionMessage
                        //    {
                        //        connid=screenClient.connid!,
                        //        clientid = screenClient.clientid,
                        //        status = screenClient.status,
                        //        grant_type = screenClient.grant_type,
                        //        message_type= MessageType.conn_success,
                        //        content = $"检查连接！"
                        //    }, cts);
                        //}
                        //catch (OperationCanceledException)
                        //{
                        //    Console.WriteLine("Operation was canceled.");
                        //}
                        //catch (HubException ex) 
                        //{
                        //    if (ex.Message.Contains("disconnected"))
                        //    {
                        //        _logger.LogInformation($"客户端连接异常=>{screenClient.name}，{screenClient.region},{screenClient.clientid},连接失败......{ex.Message},{ex.StackTrace}");  // 客户端不在线
                        //    }
                        //    _logger.LogInformation($"客户端连接异常=>{screenClient.name}，{screenClient.region},{screenClient.clientid},连接失败......{ex.Message},{ex.StackTrace}");
                        //}
                        //catch (Exception ex)
                        //{
                        //    _logger.LogInformation($"客户端连接异常=>{screenClient.name}，{screenClient.region},{screenClient.clientid},连接失败......{ex.Message},{ex.StackTrace}");
                        //}
                        _logger.LogInformation($"客户端当前空闲=>{screenClient.name}，{screenClient.region},{screenClient.clientid},分发任务......");
                        //连接成功，马上分发任务。
                        var task = await TaskService.SentTask(_azureRedis, _azureStorage, _logger, serverDevice);
                        if (task.genQueue!=null && task.genRedis!=null  && !string.IsNullOrWhiteSpace(task.genQueue.cntName))
                        {
                            screenClient.status =  ScreenConstant.busy;
                            screenClient.last_time = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
                            await _screenServerHub.Clients.Client(screenClient.connid!).SendAsync("ReceiveMessage", new ScreenProcessMessage
                            {
                                connid = screenClient.connid,
                                clientid =screenClient.clientid,
                                status = ScreenConstant.busy,
                                grant_type =screenClient.grant_type,
                                message_type= MessageType.task_send_success,
                                content =$"{task.genQueue.ToJsonString()}",//从Redis中获取任务信息
                            });
                            _logger.LogInformation($"分发任务：{task.genQueue.ToJsonString()}");
                        }
                        else
                        {
                            //_logger.LogInformation($"客户端当前空闲=>{screenClient.name}，{screenClient.region},{screenClient.clientid},暂无任务可领取的任务......");
                            if (task.genRedis!=null)
                            {
                                string msgError = $"分发任务异常原因=>{screenClient.name}，{screenClient.region},{screenClient.clientid}：{task.msg}\ngenQueue:{task.genQueue?.ToJsonString()}\ngenRedis:{task.genRedis?.ToJsonString()}";
                                _logger.LogInformation(msgError);
                                await _dingDing.SendBotMsg(msgError, GroupNames.成都开发測試群組);
                            }
                            else
                            {
                                _logger.LogInformation($"分发任务异常原因=>{screenClient.name}，{screenClient.region},{screenClient.clientid}：{task.msg}\n");
                            }
                            await _screenServerHub.Clients.Client(screenClient.connid!).SendAsync("ReceiveMessage", new ScreenProcessMessage
                            {
                                connid = screenClient.connid,
                                clientid = screenClient.clientid,
                                status = ScreenConstant.idle,
                                grant_type = screenClient.grant_type,
                                message_type= MessageType.task_send_error,
                                content = task.msg
                            });
                        }
                    }
                    await _azureRedis.GetRedisClient(8).HashSetAsync($"ScreenApi:clients:{serverDevice.deviceId}", screenClient.clientid, screenClient.ToJsonString());
                }
            }
        }
    }
}