//******************************************************************************************************//  SecurityHub.cs - Gbtc////  Copyright © 2016, Grid Protection Alliance.  All Rights Reserved.////  Licensed to the Grid Protection Alliance (GPA) under one or more contributor license agreements. See//  the NOTICE file distributed with this work for additional information regarding copyright ownership.//  The GPA licenses this file to you under the MIT License (MIT), the "License"; you may not use this//  file except in compliance with the License. You may obtain a copy of the License at:////      http://opensource.org/licenses/MIT////  Unless agreed to in writing, the subject software distributed under the License is distributed on an//  "AS-IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. Refer to the//  License for the specific language governing permissions and limitations.////  Code Modification History://  ----------------------------------------------------------------------------------------------------//  03/03/2016 - Ritchie Carroll//       Generated original version of source code.////****************************************************************************************************** using System;using System.Collections.Generic;using System.Linq;using GSF.Data.Model;using GSF.Security;using GSF.Web.Hubs;using GSF.Web.Model;using GSF.Web.Security;using System.Threading.Tasks;using GSF.Collections;using GSF.Data;using GSF.Diagnostics;using GSF.TimeSeries.Statistics;using GSF.Web.Shared.Model;using Newtonsoft.Json.Linq; namespace GSF.Web.Shared{    /// <summary>    /// Defines a SignalR security hub for managing users, groups and SID management.    /// </summary>    [AuthorizeHubRole]    public class SharedHub : RecordOperationsHub<SharedHub>    {        #region [ Constructors ]         /// <summary>        /// Creates a new <see cref="SharedHub"/>.        /// </summary>        public SharedHub() :             this(null, null, null)        {        }         /// <summary>        /// Creates a new <see cref="SharedHub"/> with the specified logging functions.        /// </summary>        /// <param name="logStatusMessageFunction">Delegate to use to log status messages, if any.</param>        /// <param name="logExceptionFunction">Delegate to use to log exceptions, if any.</param>        public SharedHub(Action<string, UpdateType> logStatusMessageFunction, Action<Exception> logExceptionFunction) :            this(null, logStatusMessageFunction, logExceptionFunction)        {        }         /// <summary>        /// Creates a new <see cref="SharedHub"/> with the specified <see cref="DataContext"/> and logging functions.        /// </summary>        /// <param name="settingsCategory">Setting category that contains the connection settings. Defaults to "securityProvider".</param>        /// <param name="logStatusMessageFunction">Delegate to use to log status messages, if any.</param>        /// <param name="logExceptionFunction">Delegate to use to log exceptions, if any.</param>        public SharedHub(string settingsCategory, Action<string, UpdateType> logStatusMessageFunction, Action<Exception> logExceptionFunction) :             this(settingsCategory, logStatusMessageFunction, logExceptionFunction, true)        {            // Capture initial defaults            if ((object)logStatusMessageFunction != null && (object)s_logStatusMessageFunction == null)                s_logStatusMessageFunction = logStatusMessageFunction;             if ((object)logExceptionFunction != null && (object)s_logExceptionFunction == null)                s_logExceptionFunction = logExceptionFunction;        }         // ReSharper disable once UnusedParameter.Local        private SharedHub(string settingsCategory, Action<string, UpdateType> logStatusMessageFunction, Action<Exception> logExceptionFunction, bool overload) :            base(settingsCategory ?? "systemSettings", logStatusMessageFunction ?? s_logStatusMessageFunction, logExceptionFunction ?? s_logExceptionFunction)        {        }         #endregion         #region [ Methods ]         /// <summary>        /// Overrides base OnConnected method to provide logging        /// </summary>        /// <returns></returns>        public override Task OnConnected()        {            LogStatusMessage($"SharedHub connect by {Context.User?.Identity?.Name ?? "Undefined User"} [{Context.ConnectionId}] - count = {ConnectionCount}", UpdateType.Information, false);            return base.OnConnected();        }         /// <summary>        /// Overrides base OnDisconnected method to provide logging        /// </summary>        /// <param name="stopCalled"></param>        /// <returns></returns>        public override Task OnDisconnected(bool stopCalled)        {            if (stopCalled)            {                // Dispose any associated hub operations associated with current SignalR client                LogStatusMessage($"SharedHub disconnect by {Context.User?.Identity?.Name ?? "Undefined User"} [{Context.ConnectionId}] - count = {ConnectionCount}", UpdateType.Information, false);            }             return base.OnDisconnected(stopCalled);        }         #endregion         #region [ Static ]         // Static Fields        private static Action<string, UpdateType> s_logStatusMessageFunction;        private static Action<Exception> s_logExceptionFunction;        private static readonly LogPublisher s_log;        private static readonly Dictionary<Guid, Statistic> s_statisticReferences;        private static Statistic[] s_statistics;                // Static Constructor        static SharedHub()        {            s_log = Logger.CreatePublisher(typeof(SharedHub), MessageClass.Component);            s_statisticReferences = new Dictionary<Guid, Statistic>();        }         // Static Properties         /// <summary>        /// Gets current default Node ID for security.        /// </summary>        public static readonly Guid DefaultNodeID = AdoSecurityProvider.DefaultNodeID;         // Static Methods         private void InitializeStatistics()        {            if (s_statistics?.Length > 0)                return;             try            {                using (AdoDataConnection connection = new AdoDataConnection("systemSettings"))                {                    TableOperations<Statistic> statistics = new TableOperations<Statistic>(connection);                    s_statistics = statistics.QueryRecords().ToArray();                }            }            catch (Exception ex)            {                s_log.Publish(MessageLevel.Error, "InitializeStatistics", exception: ex);            }        }         #endregion         // Client-side script functionality         #region [ Company Table Operations ]         /// <summary>        /// Queries company table counts        /// </summary>        /// <param name="filterText">Text to filter search down to.</param>        /// <returns>The count of the rows in the table matching the query.</returns>        [RecordOperation(typeof(Company), RecordOperation.QueryRecordCount)]        public int QueryCompanyCount(string filterText)        {            return DataContext.Table<Company>().QueryRecordCount(filterText);        }         /// <summary>        /// Queries company table.        /// </summary>        /// <param name="sortField">Table field label to sort on.</param>        /// <param name="ascending">Boolean denoting direction of sort.</param>        /// <param name="page">The page number to return.</param>        /// <param name="pageSize">The size of the page.</param>        /// <param name="filterText">Text to filter search down to.</param>        /// <returns>The rows in the table matching the query.</returns>        [RecordOperation(typeof(Company), RecordOperation.QueryRecords)]        public IEnumerable<Company> QueryCompanies(string sortField, bool ascending, int page, int pageSize, string filterText)        {            return DataContext.Table<Company>().QueryRecords(sortField, ascending, page, pageSize, filterText);        }         /// <summary>        /// Deletes record from company table.        /// </summary>        /// <param name="id">The id of the record to delete.</param>        [AuthorizeHubRole("Administrator, Editor")]        [RecordOperation(typeof(Company), RecordOperation.DeleteRecord)]        public void DeleteCompany(int id)        {            DataContext.Table<Company>().DeleteRecord(id);        }         /// <summary>        /// Creates a new Company object.        /// </summary>        /// <returns>A new company instance</returns>        [RecordOperation(typeof(Company), RecordOperation.CreateNewRecord)]        public Company NewCompany()        {            return DataContext.Table<Company>().NewRecord();        }         /// <summary>        /// Adds new record to company table.        /// </summary>        /// <param name="company">The record to add.</param>        [AuthorizeHubRole("Administrator, Editor")]        [RecordOperation(typeof(Company), RecordOperation.AddNewRecord)]        public void AddNewCompany(Company company)        {            DataContext.Table<Company>().AddNewRecord(company);        }         /// <summary>        /// Updates a record in company table.        /// </summary>        /// <param name="company">The record to update.</param>        [AuthorizeHubRole("Administrator, Editor")]        [RecordOperation(typeof(Company), RecordOperation.UpdateRecord)]        public void UpdateCompany(Company company)        {            DataContext.Table<Company>().UpdateRecord(company);        }         #endregion         #region [ Vendor Table Operations ]         /// <summary>        /// Queries vendor table count.        /// </summary>        /// <param name="filterText">Text to filter search down to.</param>        /// <returns>The count of the rows in the table matching the query.</returns>        [RecordOperation(typeof(Vendor), RecordOperation.QueryRecordCount)]        public int QueryVendorCount(string filterText)        {            return DataContext.Table<Vendor>().QueryRecordCount(filterText);        }         /// <summary>        /// Queries vendor table records.        /// </summary>        /// <param name="sortField">Table field label to sort on.</param>        /// <param name="ascending">Boolean denoting direction of sort.</param>        /// <param name="page">The page number to return.</param>        /// <param name="pageSize">The size of the page.</param>        /// <param name="filterText">Text to filter search down to.</param>        /// <returns>The rows in the table matching the query.</returns>        [RecordOperation(typeof(Vendor), RecordOperation.QueryRecords)]        public IEnumerable<Vendor> QueryVendors(string sortField, bool ascending, int page, int pageSize, string filterText)        {            return DataContext.Table<Vendor>().QueryRecords(sortField, ascending, page, pageSize, filterText);        }         /// <summary>        /// Deletes vendor table record.        /// </summary>        /// <param name="id">The id of the record to delete.</param>        [AuthorizeHubRole("Administrator, Editor")]        [RecordOperation(typeof(Vendor), RecordOperation.DeleteRecord)]        public void DeleteVendor(int id)        {            DataContext.Table<Vendor>().DeleteRecord(id);        }         /// <summary>        /// Creates new vendor object.        /// </summary>        /// <returns>A new Vendor model instance.</returns>        [RecordOperation(typeof(Vendor), RecordOperation.CreateNewRecord)]        public Vendor NewVendor()        {            return DataContext.Table<Vendor>().NewRecord();        }         /// <summary>        /// Adds new vendor record to table.        /// </summary>        /// <param name="vendor">The record to add.</param>        [AuthorizeHubRole("Administrator, Editor")]        [RecordOperation(typeof(Vendor), RecordOperation.AddNewRecord)]        public void AddNewVendor(Vendor vendor)        {            DataContext.Table<Vendor>().AddNewRecord(vendor);        }         /// <summary>        /// Updates record in vendor table.        /// </summary>        /// <param name="vendor">The record to update.</param>        [AuthorizeHubRole("Administrator, Editor")]        [RecordOperation(typeof(Vendor), RecordOperation.UpdateRecord)]        public void UpdateVendor(Vendor vendor)        {            DataContext.Table<Vendor>().UpdateRecord(vendor);        }         #endregion         #region [ VendorDevice Table Operations ]         /// <summary>        /// Queries vendor device table count.        /// </summary>        /// <param name="filterText">Text to filter search down to.</param>        /// <returns>The count of the rows in the table matching the query.</returns>        [RecordOperation(typeof(VendorDevice), RecordOperation.QueryRecordCount)]        public int QueryVendorDeviceCount(string filterText)        {            return DataContext.Table<VendorDevice>().QueryRecordCount(filterText);        }         /// <summary>        /// Queries vendor device table records.        /// </summary>        /// <param name="sortField">Table field label to sort on.</param>        /// <param name="ascending">Boolean denoting direction of sort.</param>        /// <param name="page">The page number to return.</param>        /// <param name="pageSize">The size of the page.</param>        /// <param name="filterText">Text to filter search down to.</param>        /// <returns>The rows in the table matching the query.</returns>        [RecordOperation(typeof(VendorDevice), RecordOperation.QueryRecords)]        public IEnumerable<VendorDevice> QueryVendorDevices(string sortField, bool ascending, int page, int pageSize, string filterText)        {            return DataContext.Table<VendorDevice>().QueryRecords(sortField, ascending, page, pageSize, filterText);        }         /// <summary>        /// Deletes record from vendor device table.        /// </summary>        /// <param name="id">The id of the record to delete.</param>        [AuthorizeHubRole("Administrator, Editor")]        [RecordOperation(typeof(VendorDevice), RecordOperation.DeleteRecord)]        public void DeleteVendorDevice(int id)        {            DataContext.Table<VendorDevice>().DeleteRecord(id);        }         /// <summary>        /// Creates new VendorDevice object.        /// </summary>        /// <returns>A new VendorDevice model instance.</returns>        [RecordOperation(typeof(VendorDevice), RecordOperation.CreateNewRecord)]        public VendorDevice NewVendorDevice()        {            return DataContext.Table<VendorDevice>().NewRecord();        }         /// <summary>        /// Adds new record to vendor device table.        /// </summary>        /// <param name="vendorDevice">The record to add.</param>        [AuthorizeHubRole("Administrator, Editor")]        [RecordOperation(typeof(VendorDevice), RecordOperation.AddNewRecord)]        public void AddNewVendorDevice(VendorDevice vendorDevice)        {            DataContext.Table<VendorDevice>().AddNewRecord(vendorDevice);        }         /// <summary>        /// Updates record in vendor device table.        /// </summary>        /// <param name="vendorDevice">The record to update.</param>        [AuthorizeHubRole("Administrator, Editor")]        [RecordOperation(typeof(VendorDevice), RecordOperation.UpdateRecord)]        public void UpdateVendorDevice(VendorDevice vendorDevice)        {            DataContext.Table<VendorDevice>().UpdateRecord(vendorDevice);        }         #endregion         #region [ Statistic Formatting Operations ]         /// <summary>        /// If measurement is a statistic, returns the associated Statistic record; otherwise, returns <c>null</c>.        /// </summary>        /// <param name="metadataRecord">Record of measurement metadata used to lookup Statistic record.</param>        /// <returns>Associated Statistic record, if measurement is a statistic; otherwise, returns <c>null</c>.</returns>        /// <remarks>        /// For best results, this function should be called after all statistic engine sources have been registered.        /// <paramref name="metadataRecord"/> object expected to contain a "signalid" and "signalreference" property.        /// </remarks>        public Statistic GetStatistic(dynamic metadataRecord)        {            Guid signalID = metadataRecord.signalid;             return s_statisticReferences.GetOrAdd(signalID, _ =>            {                string signalReference = metadataRecord.signalreference;                 if (string.IsNullOrWhiteSpace(signalReference))                    return null;                 if (!StatisticsEngine.TryLookupStatisticSource(signalReference, out string source, out int signalIndex))                    return null;                 InitializeStatistics();                 foreach (Statistic statistic in s_statistics)                {                    if (statistic.Source.Equals(source, StringComparison.OrdinalIgnoreCase) && statistic.SignalIndex == signalIndex)                        return statistic;                }                 return null;            });        }         /// <summary>        /// Gets the format records for statistics associated with the <paramref name="metadata"/>.        /// </summary>        /// <param name="metadata">Collection of measurement metadata.</param>        /// <returns>Array of statistical records for the <paramref name="metadata"/>.</returns>        /// <remarks>        /// This is usually used in conjunction with a call to <see cref="SubscriberHub.SetMeasurementFormats"/>        /// or applied to the "FormatRecords" property of a Json <c>subscriptionInfo</c> object.        /// Records in <paramref name="metadata"/> array expected to contain a "SignalID" and "SignalReference" property.        /// </remarks>        public IEnumerable<object> GetStatisticFormatRecords(IEnumerable<dynamic> metadata)        {            return metadata.Select(ToJsonFormatRecord).ToArray();        }         private object ToJsonFormatRecord(dynamic metadataRecord)        {            Statistic statistic = GetStatistic(metadataRecord);            Guid signalID = metadataRecord.signalid;            dynamic obj = new JObject();             obj.signalID = signalID;            obj.format = statistic?.DisplayFormat ?? "{0:N3}";            obj.dataType = statistic?.DataType;             return obj;        }         #endregion    }}