//******************************************************************************************************//  IndependentAdapterManagerExtensions.cs - Gbtc////  Copyright © 2020, 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://  ----------------------------------------------------------------------------------------------------//  02/13/2020 - J. Ritchie Carroll//       Generated original version of source code.////****************************************************************************************************** using System;using System.Data;using System.Linq;using GSF.Data;using GSF.Data.Model;using GSF.TimeSeries.Data;using GSF.TimeSeries.Model;using DeviceRecord = GSF.TimeSeries.Model.Device;using MeasurementRecord = GSF.TimeSeries.Model.Measurement;using SignalTypeRecord = GSF.TimeSeries.Model.SignalType;using HistorianRecord = GSF.TimeSeries.Model.Historian;using SignalType = GSF.Units.EE.SignalType; namespace GSF.TimeSeries.Adapters{    /// <summary>    /// Represents an adapter base class that provides functionality to manage and distribute measurements to a collection of action adapters.    /// </summary>    public static class IndependentAdapterManagerExtensions    {        /// <summary>        /// Defines the default value for the <see cref="IIndependentAdapterManager.ConfigurationReloadWaitTimeout"/>.        /// </summary>        public const int DefaultConfigurationReloadWaitTimeout = 10000;         /// <summary>        /// Defines the default value for the <see cref="IIndependentAdapterManager.ConfigurationReloadWaitAttempts"/>.        /// </summary>        public const int DefaultConfigurationReloadWaitAttempts = 2;         /// <summary>        /// Defines the default value for the <see cref="IIndependentAdapterManager.DatabaseConnectionString"/>.        /// </summary>        public const string DefaultDatabaseConnectionString = "";         /// <summary>        /// Defines the default value for the <see cref="IIndependentAdapterManager.DatabaseProviderString"/>.        /// </summary>        public const string DefaultDatabaseProviderString = "AssemblyName={System.Data, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089}; ConnectionType=System.Data.SqlClient.SqlConnection; AdapterType=System.Data.SqlClient.SqlDataAdapter";         /// <summary>        /// Defines the default value for the <see cref="IIndependentAdapterManager.PointTagTemplate"/>.        /// </summary>        public const string DefaultPointTagTemplate = "IAM!{0}";         /// <summary>        /// Defines the default value for the <see cref="IIndependentAdapterManager.AlternateTagTemplate"/>.        /// </summary>        public const string DefaultAlternateTagTemplate = "";         /// <summary>        /// Defines the default value for the <see cref="IIndependentAdapterManager.SignalReferenceTemplate"/>.        /// </summary>        public const string DefaultSignalReferenceTemplate = DefaultPointTagTemplate + "-CV";         /// <summary>        /// Defines the default value for the <see cref="IIndependentAdapterManager.DescriptionTemplate"/>.        /// </summary>        public const string DefaultDescriptionTemplate = "{0} [{1}] measurement created for {2} [{3}].";         /// <summary>        /// Defines the default value for the <see cref="IIndependentAdapterManager.ParentDeviceAcronymTemplate"/>.        /// </summary>        public const string DefaultParentDeviceAcronymTemplate = "IAM!{0}";         /// <summary>        /// Defines the default value for the <see cref="IIndependentAdapterManager.SignalType"/>.        /// </summary>        public const string DefaultSignalType = "CALC";         /// <summary>        /// Defines the default value for the <see cref="IIndependentAdapterManager.TargetHistorianAcronym"/>.        /// </summary>        public const string DefaultTargetHistorianAcronym = "PPA";         /// <summary>        /// Defines the default value for the <see cref="IIndependentAdapterManager.SourceMeasurementTable"/>.        /// </summary>        public const string DefaultSourceMeasurementTable = "ActiveMeasurements";         /// <summary>        /// Finds child adapter with specified <paramref name="adapterName"/>.        /// </summary>        /// <param name="instance">Target <see cref="IIndependentAdapterManager"/> instance.</param>        /// <param name="adapterName">Adapter name to find.</param>        /// <returns><see cref="IAdapter"/> instance with <paramref name="adapterName"/>, if found; otherwise, <c>null</c>.</returns>        public static IAdapter FindAdapter(this IIndependentAdapterManager instance, string adapterName) => instance.FirstOrDefault(adapter => adapterName.Equals(adapter.Name));         /// <summary>        /// Lookups up point tag name from provided <paramref name="signalID"/>.        /// </summary>        /// <param name="instance">Target <see cref="IIndependentAdapterManager"/> instance.</param>        /// <param name="signalID"><see cref="Guid"/> signal ID to lookup.</param>        /// <param name="measurementTable">Measurement table name used for meta-data lookup.</param>        /// <returns>Point tag name, if found; otherwise, string representation of provided signal ID.</returns>        public static string LookupPointTag(this IIndependentAdapterManager instance, Guid signalID, string measurementTable = "ActiveMeasurements")        {            DataRow record = instance.DataSource.LookupMetadata(signalID, measurementTable);            string pointTag = null;             if (record != null)                pointTag = record["PointTag"].ToString();             if (string.IsNullOrWhiteSpace(pointTag))                pointTag = signalID.ToString();             return pointTag.ToUpper();        }         /// <summary>        /// Lookups up associated device name from provided <paramref name="signalID"/>.        /// </summary>        /// <param name="instance">Target <see cref="IIndependentAdapterManager"/> instance.</param>        /// <param name="signalID"><see cref="Guid"/> signal ID to lookup.</param>        /// <param name="measurementTable">Measurement table name used for meta-data lookup.</param>        /// <returns>Device name, if found; otherwise, string representation of associated point tag.</returns>        public static string LookupDevice(this IIndependentAdapterManager instance, Guid signalID, string measurementTable = "ActiveMeasurements")        {            DataRow record = instance.DataSource.LookupMetadata(signalID, measurementTable);            string device = null;             if (record != null)                device = record["Device"].ToString();             if (string.IsNullOrWhiteSpace(device))                device = instance.LookupPointTag(signalID, measurementTable);             return device.ToUpper();        }         /// <summary>        /// Lookups up associated phasor label from provided <paramref name="signalID"/>.        /// </summary>        /// <param name="instance">Target <see cref="IIndependentAdapterManager"/> instance.</param>        /// <param name="signalID"><see cref="Guid"/> signal ID to lookup.</param>        /// <param name="measurementTable">Measurement table name used for meta-data lookup.</param>        /// <returns>Phasor label name, if found; otherwise, string representation associated point tag.</returns>        public static string LookupPhasorLabel(this IIndependentAdapterManager instance, Guid signalID, string measurementTable = "ActiveMeasurements")        {            DataRow record = instance.DataSource.LookupMetadata(signalID, measurementTable);            int phasorID = 0;             if (record != null)                phasorID = record.ConvertNullableField<int>("PhasorID") ?? 0;             if (phasorID == 0)                return instance.LookupPointTag(signalID, measurementTable);             using (AdoDataConnection connection = instance.HandleGetConfiguredConnection())            {                TableOperations<Phasor> phasorTable = new TableOperations<Phasor>(connection);                Phasor phasorRecord = phasorTable.QueryRecordWhere("ID = {0}", phasorID);                return phasorRecord is null ? instance.LookupPointTag(signalID, measurementTable) : phasorRecord.Label.Trim().ToUpper();            }        }         /// <summary>        /// Determines if <paramref name="signalID"/> exists in local configuration.        /// </summary>        /// <param name="instance">Target <see cref="IIndependentAdapterManager"/> instance.</param>        /// <param name="signalID">Signal ID to find.</param>        /// <param name="measurementTable">Measurement table name used for meta-data lookup.</param>        /// <returns><c>true</c>, if <paramref name="signalID"/> is found; otherwise, <c>false</c>.</returns>        public static bool SignalIDExists(this IIndependentAdapterManager instance, Guid signalID, string measurementTable = "ActiveMeasurements") => instance.DataSource.LookupMetadata(signalID, measurementTable) != null;         /// <summary>        /// Gets measurement record, creating it if needed.        /// </summary>        /// <param name="instance">Target <see cref="IIndependentAdapterManager"/> instance.</param>        /// <param name="currentDeviceID">Device ID associated with current adapter, or zero if none.</param>        /// <param name="pointTag">Point tag of measurement.</param>        /// <param name="alternateTag">Alternate tag of measurement.</param>        /// <param name="signalReference">Signal reference of measurement.</param>        /// <param name="description">Description of measurement.</param>        /// <param name="signalType">Signal type of measurement.</param>        /// <param name="targetHistorianAcronym">Acronym of target historian for measurement.</param>        /// <returns>Measurement record.</returns>        public static MeasurementRecord GetMeasurementRecord(this IIndependentAdapterManager instance, int currentDeviceID, string pointTag, string alternateTag, string signalReference, string description, SignalType signalType = SignalType.CALC, string targetHistorianAcronym = "PPA")        {            // Open database connection as defined in configuration file "systemSettings" category            using (AdoDataConnection connection = instance.GetConfiguredConnection())            {                TableOperations<DeviceRecord> deviceTable = new TableOperations<DeviceRecord>(connection);                TableOperations<MeasurementRecord> measurementTable = new TableOperations<MeasurementRecord>(connection);                TableOperations<HistorianRecord> historianTable = new TableOperations<HistorianRecord>(connection);                TableOperations<SignalTypeRecord> signalTypeTable = new TableOperations<SignalTypeRecord>(connection);                 // Lookup target device ID                int? deviceID = currentDeviceID > 0 ? currentDeviceID : deviceTable.QueryRecordWhere("Acronym = {0}", instance.Name)?.ID;                 // Lookup target historian ID                int? historianID = historianTable.QueryRecordWhere("Acronym = {0}", targetHistorianAcronym)?.ID;                 // Lookup signal type ID                int signalTypeID = signalTypeTable.QueryRecordWhere("Acronym = {0}", signalType.ToString())?.ID ?? 1;                 // Lookup measurement record by point tag, creating a new record if one does not exist                MeasurementRecord measurement = measurementTable.QueryRecordWhere("SignalReference = {0}", signalReference) ?? measurementTable.NewRecord();                 // Update record fields                measurement.DeviceID = deviceID;                measurement.HistorianID = historianID;                measurement.PointTag = pointTag;                measurement.AlternateTag = alternateTag;                measurement.SignalReference = signalReference;                measurement.SignalTypeID = signalTypeID;                measurement.Description = description;                 // Save record updates                measurementTable.AddNewOrUpdateRecord(measurement);                 // Re-query new records to get any database assigned information, e.g., unique Guid-based signal ID                if (measurement.PointID == 0)                    measurement = measurementTable.QueryRecordWhere("SignalReference = {0}", signalReference);                 // Notify host system of configuration changes                instance.OnConfigurationChanged();                 return measurement;            }        }         /// <summary>        /// Waits for <paramref name="signalIDs"/> to be loaded in system configuration.        /// </summary>        /// <param name="instance">Target <see cref="IIndependentAdapterManager"/> instance.</param>        /// <param name="signalIDs">Signal IDs to wait for.</param>        /// <param name="measurementTable">Measurement table name used for meta-data lookup.</param>        public static void WaitForSignalsToLoad(this IIndependentAdapterManager instance, Guid[] signalIDs, string measurementTable = "ActiveMeasurements")        {            int attempts = 0;             bool signalExists(Guid signalID) => instance.SignalIDExists(signalID, measurementTable);             while (attempts++ < instance.ConfigurationReloadWaitAttempts)            {                instance.ConfigurationReloadedWaitHandle.Reset();                 if (signalIDs.All(signalExists))                    break;                 instance.ConfigurationReloadedWaitHandle.Wait(instance.ConfigurationReloadWaitTimeout);            }        }    }}