iot/projects/IoTCenter/Services/IoTCenterEventHandler.cs

using Application.Domain.Entities;
using CSScriptLib;
using Hangfire;
using Infrastructure.Events;
using Infrastructure.Extensions;
using Microsoft.AspNetCore.SignalR;
using Microsoft.Extensions.DependencyInjection;
using System;
using System.Collections.Concurrent;
using System.Threading.Tasks;

namespace IoTCenter.Services
{
    public class IoTCenterEventHandler :
        IEventHander<EntityInsertedEvent<IoTTimer>>,
        IEventHander<EntityUpdatedEvent<IoTTimer>>,
        IEventHander<EntityDeletedEvent<IoTTimer>>,
        IEventHander<EntityInsertedEvent<IoTTigger>>,
        IEventHander<EntityUpdatedEvent<IoTTigger>>,
        IEventHander<EntityDeletedEvent<IoTTigger>>,
        IEventHander<EntityInsertedEvent<Node>>,
        IEventHander<EntityUpdatedEvent<Node>>,
        IEventHander<EntityDeletedEvent<Node>>,
        IEventHander<EntityInsertedEvent<Product>>,
        IEventHander<EntityUpdatedEvent<Product>>,
        IEventHander<EntityDeletedEvent<Product>>,
        IEventHander<EntityInsertedEvent<Device>>,
        IEventHander<EntityUpdatedEvent<Device>>,
        IEventHander<EntityDeletedEvent<Device>>,
        IEventHander<EntityInsertedEvent<Data>>,
        IEventHander<EntityUpdatedEvent<Data>>,
        IEventHander<EntityDeletedEvent<Data>>,
        IEventHander<EntityInsertedEvent<Command>>,
        IEventHander<EntityUpdatedEvent<Command>>,
        IEventHander<EntityDeletedEvent<Command>>,
        IEventHander<EntityInsertedEvent<Scene>>,
        IEventHander<EntityUpdatedEvent<Scene>>,
        IEventHander<EntityDeletedEvent<Scene>>
    {
        public static ConcurrentDictionary<Guid, IoTTigger> Tiggers = new ConcurrentDictionary<Guid, IoTTigger>();
        private readonly IServiceProvider _sp;

        public IoTCenterEventHandler(IServiceProvider sp)
        {
            this._sp = sp;
        }

        #region timer

        public void Handle(EntityInsertedEvent<IoTTimer> message)
        {
            var timer = message.Data;
            if (timer.NodeId == null)
            {
                RecurringJob.AddOrUpdate<IoTCenterJob>(timer.Id.ToString(), o => o.TimerHanle(timer.Id), timer.Cron);
            }
        }

        public void Handle(EntityUpdatedEvent<IoTTimer> message)
        {
            var timer = message.Data;
            if (timer.NodeId == null)
            {
                RecurringJob.AddOrUpdate<IoTCenterJob>(timer.Id.ToString(), o => o.TimerHanle(timer.Id), timer.Cron);
            }
        }

        public void Handle(EntityDeletedEvent<IoTTimer> message)
        {
            var timer = message.Data;
            if (timer.NodeId == null)
            {
                RecurringJob.RemoveIfExists(timer.Id.ToString());
            }
        }

        #endregion timer

        #region tigger

        public void Handle(EntityInsertedEvent<IoTTigger> message)
        {
            var tigger = message.Data;
            if (tigger.NodeId == null)
            {
                Tiggers.TryRemove(message.Data.Id, out IoTTigger iotTigger);
                Tiggers.TryAdd(tigger.Id, tigger);
            }
        }

        public void Handle(EntityUpdatedEvent<IoTTigger> message)
        {
            var tigger = message.Data;
            if (tigger.NodeId == null)
            {
                Tiggers.TryRemove(message.Data.Id, out IoTTigger iotTigger);
                Tiggers.TryAdd(tigger.Id, tigger);
            }
        }

        public void Handle(EntityDeletedEvent<IoTTigger> message)
        {
            var tigger = message.Data;
            if (tigger.NodeId == null)
            {
                Tiggers.TryRemove(tigger.Id, out IoTTigger iotTigger);
            }
        }

        #endregion tigger

        #region Product

        public void Handle(EntityInsertedEvent<Product> message)
        {
            this.Notify(message);
        }

        public void Handle(EntityUpdatedEvent<Product> message)
        {
            this.Notify(message);
        }

        public void Handle(EntityDeletedEvent<Product> message)
        {
            this.Notify(message);
        }

        #endregion Product

        #region Node

        public void Handle(EntityInsertedEvent<Node> message)
        {
            this.Notify(message);
        }

        public void Handle(EntityUpdatedEvent<Node> message)
        {
            this.Notify(message);
        }

        public void Handle(EntityDeletedEvent<Node> message)
        {
            this.Notify(message);
        }

        #endregion Node

        #region Device

        public void Handle(EntityInsertedEvent<Device> message)
        {
            this.Notify(message);
        }

        public void Handle(EntityUpdatedEvent<Device> message)
        {
            this.Notify(message);
        }

        public void Handle(EntityDeletedEvent<Device> message)
        {
            this.Notify(message);
        }

        #endregion Device

        #region Data

        public void Handle(EntityInsertedEvent<Data> message)
        {
            this.Notify(message);
            this.TiggerHandle(message);
        }

        public void Handle(EntityUpdatedEvent<Data> message)
        {
            this.Notify(message);
            this.TiggerHandle(message);
        }

        public void Handle(EntityDeletedEvent<Data> message)
        {
            this.Notify(message);
        }

        #endregion Data

        #region Command

        public void Handle(EntityInsertedEvent<Command> message)
        {
            this.Notify(message);
        }

        public void Handle(EntityUpdatedEvent<Command> message)
        {
            this.Notify(message);
        }

        public void Handle(EntityDeletedEvent<Command> message)
        {
            this.Notify(message);
        }

        #endregion Command

        #region Scene

        public void Handle(EntityInsertedEvent<Scene> message)
        {
            this.Notify(message);
        }

        public void Handle(EntityUpdatedEvent<Scene> message)
        {
            this.Notify(message);
        }

        public void Handle(EntityDeletedEvent<Scene> message)
        {
            this.Notify(message);
        }

        #endregion Scene

        private void TiggerHandle(BaseEvent<Data> message)
        {
            try
            {
                using var scope = this._sp.CreateScope();
                var job = scope.ServiceProvider.GetService<IoTCenterJob>();
                foreach (var item in Tiggers)
                {
                    var data = message.Data;
                    var tigger = item.Value;
                    if (tigger.DataId == data.Id)
                    {
                        var methodText = $"bool Valid(string name,string key,{data.Type.ToString().ToLower()} value,string description){{ return {tigger.Condition};}}";
                        try
                        {
                            dynamic method = CSScript.Evaluator.LoadMethod(methodText);
                            dynamic value = data.GetValue();
                            var result = method.Valid(data.Name, data.Key, value, data.Description);
                            if (result)
                            {
                                job.TiggerHandle(tigger.Id);
                            }
                        }
                        catch (Exception ex)
                        {
                            ex.PrintStack();
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                ex.PrintStack();
            }
        }

        private void Notify<T>(BaseEvent<T> message)
        {
            using var scope = this._sp.CreateScope();
            var hub = scope.ServiceProvider.GetRequiredService<IHubContext<IoTCenterHub>>();
            Task.Run(() =>
            {
                try
                {
                    hub.ServerToClient($"{typeof(T).Name}{message.Arg}", message.Data, "page", null);
                }
                catch (Exception ex)
                {
                    ex.PrintStack();
                }
            });
        }
    }
}