FCCLite/Edge.Core/Processor/UniversalApi/UniversalApiHub.cs

using AutoMapper;
using Edge.Core.Configuration;
using Edge.Core.Database;
using Edge.Core.Database.Models;
using Edge.Core.Processor;
using Edge.Core.Processor.Dispatcher.Attributes;
using Edge.Core.UniversalApi.Auditing;
using Microsoft.Extensions.DependencyInjection;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Text.Json;
using System.Threading;
using System.Threading.Tasks;
namespace Edge.Core.UniversalApi
{
    public class UniversalApiHub
    {
        private IEnumerable<IProcessor> processors;
        private IEnumerable<IAuditingStore> auditingStores;
        private IServiceProvider services;
        private bool config_DisableApiAuditing = false;
        private bool config_EnableApiInputAndOutputAuditing = false;

        public event EventHandler<UniversalGenericAlarmEventFiredEventArg> OnUniversalGenericAlarmEventFired;
        public async Task InitAsync(IEnumerable<IProcessor> processors)
        {
            this.processors = processors;
            foreach (var p in this.CommunicationProviders)
            {
                await p.SetupAsync(this.processors);
            }
        }

        public IEnumerable<ICommunicationProvider> CommunicationProviders { get; }

        public UniversalApiHub(IEnumerable<ICommunicationProvider> communicationProviders, IServiceProvider services)
        {
            this.CommunicationProviders = communicationProviders;

            this.services = services;
            var configurator = services.GetService<Configurator>();
            this.config_DisableApiAuditing = bool.Parse(configurator.MetaConfiguration.Parameter
                ?.FirstOrDefault(p => p.Name.Equals("disableUniversalApiAuditing", StringComparison.OrdinalIgnoreCase))?.Value ?? "false");
            this.config_EnableApiInputAndOutputAuditing = bool.Parse(configurator.MetaConfiguration.Parameter
                ?.FirstOrDefault(p => p.Name.Equals("enableUniversalApiInputAndOutputAuditing", StringComparison.OrdinalIgnoreCase))?.Value ?? "false");

            this.auditingStores = services.GetRequiredService<IEnumerable<IAuditingStore>>();

            configurator.OnConfigFileChanged += (_, __) =>
            {
                this.config_DisableApiAuditing = bool.Parse(configurator.MetaConfiguration.Parameter
                    ?.FirstOrDefault(p => p.Name.Equals("disableUniversalApiAuditing", StringComparison.OrdinalIgnoreCase))?.Value ?? "false");
                this.config_EnableApiInputAndOutputAuditing = bool.Parse(configurator.MetaConfiguration.Parameter
                    ?.FirstOrDefault(p => p.Name.Equals("enableUniversalApiInputAndOutputAuditing", StringComparison.OrdinalIgnoreCase))?.Value ?? "false");
            };
        }

        /// <summary>
        /// Fire an event to all underlying CommunicationProviders.
        ///     Make sure class Attribute of `Event UniversalApi` declared in App or DeviceHandler.
        /// </summary>
        /// <param name="source"></param>
        /// <param name="eventName"></param>
        /// <param name="eventData"></param>
        /// <returns></returns>
        public async Task FireEvent(IProcessor source, string eventName, object eventData)
        {

            #region

            AuditLogInfo auditLogInfo = null;
            if (!this.config_DisableApiAuditing)
            {
                auditLogInfo = new AuditLogInfo()
                {
                    ClientIdentity = "",
                    DeviceHandlerOrAppName = source.SelectHandlerOrAppThenCast<object>().GetType().FullName,
                    ExecutionTime = DateTime.Now,
                };
                auditLogInfo.Actions.Add(new AuditLogActionInfo()
                {
                    ApiName = "event : " + eventName,
                    InputParameters =
                        this.config_EnableApiInputAndOutputAuditing ?
                            JsonSerializer.Serialize(eventData) : null,
                });
                auditLogInfo.Prepare();
            }

            #endregion

            try
            {
                if (this.CommunicationProviders == null) return;
                foreach (var provider in this.CommunicationProviders)
                {
                    try
                    {
                        var executeResult = await provider.RouteEventAsync(source,
                             new EventDescriptor() { Name = eventName, Data = eventData });
                    }
                    catch (Exception exxx)
                    {

                        #region 

                        //if (!this.config_DisableApiAuditing)
                        //{ auditLogInfo.CommitWithExceptions(new Exception[] { exxx }); }

                        #endregion

                    }
                }
            }
            finally
            {
                if (!this.config_DisableApiAuditing)
                {
                    auditLogInfo.CommitWithExeResult(true);
                    Task.WaitAll(this.auditingStores.Select(s => s.SaveAsync(auditLogInfo)).ToArray());
                }
            }
        }

        /// <summary>
        /// Fire generic event without persist it(like fire and forget).
        ///     the UI component would receive it at the moment and only for onetime, to showing a message to user.
        /// </summary>
        /// <param name="source"></param>
        /// <param name="genericAlarm"></param>
        /// <returns></returns>
        public Task FireGenericAlarm(IProcessor source, GenericAlarm genericAlarm)
        {
            return this.FireGenericAlarm(source, genericAlarm, false, null);
        }

        /// <summary>
        /// Fire generic event and persist it.
        ///     the UI component would receive it at the moment and can retrieve it anytime later, to showing a message to user.
        /// </summary>
        /// <param name="source"></param>
        /// <param name="genericAlarm"></param>
        /// <param name="hiddenDataSelector">any custom data to persist together with this alarm, used for searching.</param>
        /// <returns>the persist record id, use it for retrieve back the record.</returns>
        public Task<int?> FirePersistGenericAlarm(IProcessor source, GenericAlarm genericAlarm, Func<GenericAlarm, string> hiddenDataSelector)
        {
            return this.FireGenericAlarm(source, genericAlarm, true, hiddenDataSelector(genericAlarm));
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="source"></param>
        /// <param name="genericAlarm"></param>
        /// <param name="persist">if true, the alarm will be persist</param>
        /// <param name="hiddenData"></param>
        /// <param name="muteFiring">not firing the event, used for scenario that refresh the persist alarm without re-firing it.</param>
        /// <returns></returns>
        private async Task<int?> FireGenericAlarm(IProcessor source, GenericAlarm genericAlarm, bool persist, string hiddenData, bool muteFiring = false)
        {
            int? persistAlarmDbRecordKey = null;
            if (!persist)
            {
            }
            else
            {
                var mapper = this.services.GetRequiredService<IMapper>();
                using (var scope = this.services.CreateScope())
                {

                }
            }

            if (!muteFiring)
                this.OnUniversalGenericAlarmEventFired?.Invoke(this, new UniversalGenericAlarmEventFiredEventArg(source, genericAlarm, persistAlarmDbRecordKey));
            //await this.FireEvent(source, GenericAlarm.UniversalApiEventName, genericAlarm);
            return persistAlarmDbRecordKey;
        }

        /// <summary>
        /// Mark several Opening state alarms to Closed state, and fill with close reason for each.
        /// </summary>
        /// <param name="alarmIdAndCloseReasons">list of opening state alarm id and close reason.</param>
        /// <returns></returns>
        public async Task ClosePersistGenericAlarms(IEnumerable<Tuple<int, string>> alarmIdAndCloseReasons)
        {
            using (var scope = this.services.CreateScope())
            {

                //await dbContext.SaveChangesAsync();
            }
        }

        public async Task AckPersistGenericAlarms(IEnumerable<Tuple<int, string>> alarmIdAndAckReasons, bool isForUnAck = false)
        {
            using (var scope = this.services.CreateScope())
            {
             
               // await dbContext.SaveChangesAsync();
            }
        }

        /// <summary>
        /// Mark all Opening state alarms to Closed state, and fill with the same close reason, for a specific processor.
        /// </summary>
        /// <param name="source">all alarms for this processor will be closed.</param>
        /// <param name="closeReason">all target alarms will set with this close reason</param>
        /// <returns></returns>
        public Task<int> ClosePersistGenericAlarms(IProcessor source, string closeReason)
        {
            return this.ClosePersistGenericAlarms(source, null, closeReason);
        }

        /// <summary>
        /// Mark all Opening state alarms to Closed state, and fill with the same close reason.
        /// </summary>
        /// <param name="source"></param>
        /// <param name="hiddenDataHint">the searching criteria, the hidden data fields contains this value will be matched.</param>
        /// <param name="closeReason">all target alarms will set with this close reason</param>
        /// <returns></returns>
        public async Task<int> ClosePersistGenericAlarms(IProcessor source, string hiddenDataHint, string closeReason)
        {
            var originator = source.ProcessorDescriptor()?.DeviceHandlerOrApp?.GetType()
                     ?.GetCustomAttributes<MetaPartsDescriptor>()?.FirstOrDefault()?.DisplayName;
            if (string.IsNullOrEmpty(originator))
                originator = source.ProcessorDescriptor()?.DeviceHandlerOrApp?.GetType().FullName;
            using (var scope = this.services.CreateScope())
            {
              

                //var effectRowCount = await dbContext.SaveChangesAsync();
                return 1;
            }
        }

        /// <summary>
        /// Query the persist generic alarms by search conditions.
        /// </summary>
        /// <param name="source">only alarms from this processor are returned, leave null to ignore this constrait.</param>
        /// <param name="originators">null to ignore this constrait.</param>
        /// <param name="alarmCategories">null to ignore this constrait.</param>
        /// <param name="alarmSubCategories">null to ignore this constrait.</param>
        /// <param name="alarmHiddenData">null to ignore this constrait.</param>
        /// <param name="alarmOpeningDateTimeFrom">null to ignore this constrait.</param>
        /// <param name="alarmOpeningDateTimeTo">null to ignore this constrait.</param>
        /// <param name="severity">null to ignore this constrait.</param>
        /// <param name="includeAckedStateAlarm"></param>
        /// <param name="includeClosedStateAlarm"></param>
        /// <param name="pageIndex"></param>
        /// <param name="pageRowCount"></param>
        /// <returns></returns>
        public async Task<IEnumerable<GenericAlarmDbModel>> GetPersistGenericAlarms(
            IProcessor source,
            string[] originators,
            string[] alarmCategories,
            string[] alarmSubCategories,
            string alarmHiddenData,
            DateTime? alarmOpeningDateTimeFrom, DateTime? alarmOpeningDateTimeTo,
            GenericAlarmSeverity? severity,
            bool includeAckedStateAlarm,
            bool includeClosedStateAlarm,
            int pageIndex, int pageRowCount)
        {
            using (var scope = this.services.CreateScope())
            {
                return null;
                //return r.Select(d => new
                //{
                //    d.Id,
                //    d.Originator,
                //    d.Severity,
                //    d.Category,
                //    d.SubCategory,
                //    d.Title,
                //    d.Detail,
                //    d.ClosedTimestamp,
                //    d.ClosedReason,
                //    d.Action,
                //});
            }
        }

        /// <summary>
        /// Close the alarms by match its hidden data, and create a new persist generic alarm.
        /// </summary>
        /// <param name="source"></param>
        /// <param name="closingAlarmsHiddenDataPredicate">predictor for hidden data match for test with all exist alarms, the matched ones will be all closed.</param>
        /// <param name="closeReason"></param>
        /// <param name="newAlarm"></param>
        /// <param name="newAlarmHiddenDataSelector">generator for hidden data that will be used for create a new alarm.</param>
        /// <param name="muteNewAlarmFiring">if true, then new alarm event will not be fired, used for scenario that create an alarm but not firing event to gain user attention.</param>
        /// <returns></returns>
        public async Task<int?> CloseAndFirePersistGenericAlarm(IProcessor source, GenericAlarm newAlarm,
            Func<GenericAlarm, string> closingAlarmsHiddenDataPredicate, string closeReason,
            Func<GenericAlarm, string> newAlarmHiddenDataSelector, bool muteNewAlarmFiring = false)
        {
            if (source == null) throw new ArgumentNullException(nameof(source));
            bool lockTaken = false;
            try
            {
                this.spinLock_GuardTwoStageOperation.Enter(ref lockTaken);
                var alarmsForClosing = await GetPersistGenericAlarms(source, null, null, null, closingAlarmsHiddenDataPredicate(newAlarm), null, null, null, true, false, 0, 100);
                if (alarmsForClosing.Any())
                    await this.ClosePersistGenericAlarms(alarmsForClosing.Select(c => new Tuple<int, string>(c.Id, closeReason)));
                var r = await this.FireGenericAlarm(source, newAlarm, true, newAlarmHiddenDataSelector(newAlarm), muteNewAlarmFiring);
                return r;
            }
            finally
            {
                if (lockTaken) this.spinLock_GuardTwoStageOperation.Exit(false);
            }
        }

        private SpinLock spinLock_GuardTwoStageOperation = new SpinLock();
        /// <summary>
        /// Clear(remove from db) the alarms by match its hidden data, and create a new persist generic alarm.
        /// </summary>
        /// <param name="source"></param>
        /// <param name="newAlarm"></param>
        /// <param name="clearingAlarmsHiddenDataPredicate">predictor for hidden data match for test with all exist alarms, the matched ones will be all cleared.</param>
        /// <param name="newAlarmHiddenDataSelector"></param>
        /// <param name="muteNewAlarmFiring">if true, then new alarm event will not be fired, used for scenario that create an alarm but not firing event to gain user attention.</param>
        /// <returns></returns>
        public async Task<int?> ClearAndFirePersistGenericAlarm(IProcessor source, GenericAlarm newAlarm,
            Func<GenericAlarm, string> clearingAlarmsHiddenDataPredicate,
            Func<GenericAlarm, string> newAlarmHiddenDataSelector, bool muteNewAlarmFiring = false)
        {
            if (source == null) throw new ArgumentNullException(nameof(source));
            bool lockTaken = false;
            try
            {
                this.spinLock_GuardTwoStageOperation.Enter(ref lockTaken);
                using (var scope = this.services.CreateScope())
                {
              
                }

                var r = await this.FireGenericAlarm(source, newAlarm, true, newAlarmHiddenDataSelector(newAlarm), muteNewAlarmFiring);
                return r;
            }
            finally
            {
                if (lockTaken) this.spinLock_GuardTwoStageOperation.Exit(false);
            }
        }

        /// <summary>
        /// Try firing an alarm by only there's no matched opened alarm in db.
        /// </summary>
        /// <param name="source"></param>
        /// <param name="newAlarm"></param>
        /// <param name="existsAlarmsHiddenDataPredicate">predictor for hidden data match for test with all exist alarms, any matched ones will be considered as EXISTS, and then will not firing anymore.</param>
        /// <param name="newAlarmHiddenDataSelector"></param>
        /// <returns></returns>
        public async Task<int?> FirePersistGenericAlarmIfNotExists(IProcessor source, GenericAlarm newAlarm,
            Func<GenericAlarm, string> existsAlarmsHiddenDataPredicate,
            Func<GenericAlarm, string> newAlarmHiddenDataSelector)
        {
            if (source == null) throw new ArgumentNullException(nameof(source));
            bool lockTaken = false;
            try
            {
                this.spinLock_GuardTwoStageOperation.Enter(ref lockTaken);
                using (var scope = this.services.CreateScope())
                {
                 
                    return null;
                }
            }
            finally
            {
                if (lockTaken) this.spinLock_GuardTwoStageOperation.Exit(false);
            }
        }
    }

    public class UniversalGenericAlarmEventFiredEventArg : System.EventArgs
    {
        public IProcessor Originator { get; }
        public GenericAlarm GenericAlarm { get; }
        public int? PersistId { get; }
        public UniversalGenericAlarmEventFiredEventArg(IProcessor originator, GenericAlarm genericAlarm, int? persistId)
        {
            this.Originator = originator;
            this.GenericAlarm = genericAlarm;
            this.PersistId = persistId;
        }
    }
}