SOMS/Yunda.SOMS.DataMonitoringServer.Service/DataAnalysis/AlarmQueue/AlarmQueueDataPublish.cs

using Abp.Dependency;
using System.Collections.Concurrent;
using System.Threading.Tasks.Dataflow;
using ToolLibrary.LogHelper;
using Yunda.ISAS.DataMonitoringServer.DataAnalysis.Model;
using Yunda.ISAS.DataMonitoringServer.DataCenter;
using Yunda.ISAS.DataMonitoringServer.WebSocket;
using Yunda.ISAS.DataMonitoringServer.WebSocket.Model;
using YunDa.ISAS.DataTransferObject.DataMonitoring.LinkageExecuteActivityDto;
using YunDa.ISAS.DataTransferObject.DataMonitoring.TelemeteringAlarmStrategyDto;
using YunDa.ISAS.DataTransferObject.EquipmentLiveData;
using YunDa.ISAS.DataTransferObject.VideoSurveillance.VideoDevDto;
using YunDa.ISAS.Redis.Entities.AlarmCategory;

namespace Yunda.ISAS.DataMonitoringServer.DataAnalysis.AlarmQueue
{
    public class AlarmQueueDataPublish : ISingletonDependency
    {
        private ActionBlock<AlarmListRedis> _alarmListRedisBlock;
        private readonly RedisDataRepository _redisDataRepository;
        private readonly WebApiRequest _webApiRequest;
        private readonly WebSocketServer _webSocketServer;

        public AlarmQueueDataPublish(RedisDataRepository redisDataRepository
            , WebApiRequest webApiRequest
            , WebSocketServer webSocketServer)
        {
            _webSocketServer = webSocketServer;
            _redisDataRepository = redisDataRepository;
            _webApiRequest = webApiRequest;
            _alarmListRedisBlock = new ActionBlock<AlarmListRedis>(async t =>
            {
                try
                {
                    var dic = _redisDataRepository.AlarmListRedis.HashSetGetDicAll(nameof(AlarmListRedis));
                    if (dic.ContainsKey(t.Id.ToString()))
                    {
                        t.IsClear = dic[t.Id.ToString()].IsClear;
                    }
                    else
                    {
                        dic.Add(t.Id.ToString(), t);
                    }
                    await _redisDataRepository.AlarmListRedis.HashSetUpdateOneAsync(nameof(AlarmListRedis), t.Id.ToString(), t);
                    var orders = dic.Values.OrderByDescending(t => DateTime.Parse(t.AlarmDateTime));
                    var msg = new DataMonitorMessageModel()
                    {
                        MessageType = MessgeTypeEnum.AlarmQueue,
                        Content = orders,
                        GroupType = GroupTypeEnum.All
                    };
                    _webSocketServer.SendMsg(msg);
                }
                catch (Exception ex)
                {
                    Log4Helper.Error(this.GetType(), "处理报警队列发生错误", ex);
                }
            }, new ExecutionDataflowBlockOptions() { MaxDegreeOfParallelism = 1 });
        }

        public bool IsClearAlarm(Guid id)
        {
            var alarmStra = _redisDataRepository.AlarmListRedis.HashSetGetOne(nameof(AlarmListRedis), id);
            if (alarmStra != null)
            {
                return alarmStra.IsClear;
            }
            return false;
        }
        /// <summary>
        /// 处理联动报警
        /// </summary>
        /// <param name="linkageStrategyModel"></param>
        /// <param name="configurationId"></param>
        /// <param name="resStr"></param>
        /// <param name="_cameraActives"></param>
        public Task LinkageAlarmAsync(LinkageStrategyModel linkageStrategyModel,
            //Guid configurationId,
            string resStr,
            ConcurrentDictionary<Guid, List<LinkageExecuteActivityOutput>> _cameraActives)
        {
            return Task.Run(() =>
            {
                AlarmListRedis alarmListRedis = new AlarmListRedis()
                {
                    Id = linkageStrategyModel.Id,
                    IsRecord = false,
                    DMAlarmCategory = linkageStrategyModel.DMAlarmCategory,
                    IsClear = false,
                    AlarmContent = "",
                    AlarmDateTime = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"),
                    AlarmLevelName = linkageStrategyModel.DMAlarmCategory.Name,
                    VideoDevs = null,
                    Professional = linkageStrategyModel.Professional,
                };
                if (_cameraActives.Count > 0)
                {
                    alarmListRedis.IsRecord = true;
                    var videoDevids = _cameraActives.Keys;
                    alarmListRedis.VideoDevs = new List<VideoDevProperty>();
                    foreach (var cameraId in _cameraActives.Keys)
                    {
                        var video = _webApiRequest.GetVideoDevDataByCameraId(cameraId);
                        alarmListRedis.VideoDevs.Add(video);
                    }
                }
                else
                {
                    alarmListRedis.IsRecord = false;
                    alarmListRedis.VideoDevs = null;
                }
                alarmListRedis.AlarmContent = $"{linkageStrategyModel.Name}_{resStr}数据触发报警联动";
                _alarmListRedisBlock.Post(alarmListRedis);
            });
        }
        /// <summary>
        /// 处理遥信报警
        /// </summary>
        /// <param name="e"></param>
        /// <param name="selesignal"></param>
        public Task TelesignalAlarmAsync(EquipmentDataModel e, TelesignalisationModel selesignal)
        {
            return Task.Run(() =>
            {
                try
                {
                    AlarmListRedis alarmListRedis = new AlarmListRedis()
                    {
                        Id = selesignal.Id,
                        IsRecord = false,
                        DMAlarmCategory = selesignal.DMAlarmCategory,
                        IsClear = false,
                        AlarmContent = "",
                        AlarmDateTime = selesignal.ResultTime.ToString("yyyy-MM-dd HH:mm:ss"),
                        AlarmLevelName = selesignal.DMAlarmCategory.Name,
                        VideoDevs = null,
                        Professional = e.EquipmentTypeTypeName
                    };
                    alarmListRedis.AlarmContent = $"{e.EquipmentInfoName} {selesignal.Name} {selesignal.ResultValueStr}";
                    _alarmListRedisBlock.Post(alarmListRedis);
                }
                catch (Exception ex)
                {
                    Log4Helper.Error(this.GetType(), ex);
                }

            });
        }
        /// <summary>
        /// 处理遥测报警
        /// </summary>
        /// <param name="e"></param>
        /// <param name="telemetering"></param>
        public Task TelemeteringAlarmAsync(EquipmentDataModel e,
            TelemeteringModel telemetering,
            TelemeteringAlarmStrategyProperty alarm)
        {
            return Task.Run(() =>
            {
                try
                {
                    AlarmListRedis alarmListRedis = new AlarmListRedis()
                    {
                        Id = alarm.Id,
                        IsRecord = false,
                        DMAlarmCategory = alarm.DMAlarmCategory,
                        IsClear = false,
                        AlarmContent = "",
                        AlarmDateTime = telemetering.ResultTime.ToString("yyyy-MM-dd HH:mm:ss"),
                        AlarmLevelName = alarm.DMAlarmCategory.Name,
                        VideoDevs = null,
                        Professional= e.EquipmentTypeTypeName
                    };
                    alarmListRedis.AlarmContent = $"{e.EquipmentInfoName} {telemetering.Name}:{telemetering.ResultValue}{telemetering.Unit} 数值异常";
                    _alarmListRedisBlock.Post(alarmListRedis);
                }
                catch (Exception ex)
                {
                    Log4Helper.Error(this.GetType(), ex);
                }

            });
        }


    }
}