//FB 32926 Old location of this file is DataPRO\DataPRO\DataModel\Classes\TestTemplate\TestTemplateList.cs
using DTS.SensorDB;
using System;
using System.Collections.Generic;
using System.Data;
using System.Data.SqlClient;
using System.Linq;
using DTS.Common.Base;
using DTS.Common.Enums;
using DTS.Common.Utilities.Logging;
using DTS.Common.ISO;
using DTS.Common.Storage;
using DTS.Slice.Users.UserSettings;
using DTS.Common.Enums.Sensors;
using DTS.Common.Events;
using Prism.Ioc;
using DTS.Common.Events.TestSetups.TestSetupsList;
using DTS.Common.Classes.Sensors;
using System.Threading.Tasks;
using DTS.Common.Interface.TestSetups.TestSetupsList;
using DTS.Common.SharedResource.Strings;
using DTS.Common.DataModel;
using DTS.Common.DataModel.Common;
using Prism.Events;
using System.Windows.Threading;
using System.Windows;
// ReSharper disable GenericEnumeratorNotDisposed

namespace DataPROWin7.DataModel
{
    public class TestTemplateList : BasePropertyChanged
    {
        /// <summary>
        /// this property is to hold a template in memory temporarily
        /// without committing it to the db, but to still act as if it is in the db
        /// </summary>
        public TestTemplate TemporaryTemplate { get; set; }
        protected TestTemplateList() { }

        private IReadOnlyDictionary<string, CustomerDetails> _cachedCustomerDetails = null;
        public IReadOnlyDictionary<string, CustomerDetails> CachedCustomerDetails
        {
            get => _cachedCustomerDetails;
            set => _cachedCustomerDetails = value;
        }

        private IReadOnlyDictionary<string, LabratoryDetails> _cachedLaboratoryDetails = null;
        public IReadOnlyDictionary<string, LabratoryDetails> CachedLaboratoryDetails
        {
            get => _cachedLaboratoryDetails;
            set => _cachedLaboratoryDetails = value;
        }

        private IReadOnlyDictionary<string, TestEngineerDetails> _cachedTestEngineerDetails = null;
        public IReadOnlyDictionary<string, TestEngineerDetails> CachedTestEngineerDetails
        {
            get => _cachedTestEngineerDetails;
            set => _cachedTestEngineerDetails = value;
        }

        public enum Tags
        {
            TestTemplates,
            CurrentTest,
            SavedCurrentTest
        }
        public TestTemplate GetTemplate(string name, bool bLoad = true)
        {
            if (name == StringResources.QuickSensorCheck_DefaultTestName)
            {
                return TemporaryTemplate;
            }
            if (string.IsNullOrWhiteSpace(name)) { return null; }

            TestTemplate[] templates = GetTemplates(name);
            TestTemplate testTemplate = templates.Length > 0 ? templates[0] : null;
            if (null != testTemplate && bLoad)
            {
                testTemplate.Load();
            }

            return testTemplate;
        }

        public TestTemplate[] GetTemplates(string[] names, bool bLoad = true)
        {
            var templates = new List<TestTemplate>();
            foreach (string name in names)
            {
                var template = GetTemplate(name, bLoad);
                if (null != template)
                {
                    templates.Add(template);
                }
            }
            return templates.ToArray();
        }

        /// <summary>
        /// returns a lookup of customer detail name to customer detail
        /// 28273 Calspan Centralized db performance needs to be improved
        /// </summary>
        /// <returns></returns>
        private IReadOnlyDictionary<string, CustomerDetails> GetCustomerDetailsLookup()
        {
            var lookup = new Dictionary<string, CustomerDetails>();
            try
            {
                var details = CustomerDetailsList.GetAllCustomers();
                foreach (var detail in details) { lookup[detail.Name] = detail; }
            }
            catch (Exception ex) { APILogger.Log(ex); }
            return lookup;
        }

        /// <summary>
        /// returns a lookup of lab detail name to lab detail
        /// 28273 Calspan Centralized db performance needs to be improved
        /// </summary>
        /// <returns></returns>
        private IReadOnlyDictionary<string, LabratoryDetails> GetLabDetailsLookup()
        {
            var lookup = new Dictionary<string, LabratoryDetails>();
            try
            {
                var details = LabratoryDetailsList.GetAllLabs();
                foreach (var detail in details) { lookup[detail.Name] = detail; }
            }
            catch (Exception ex) { APILogger.Log(ex); }
            return lookup;
        }

        private IReadOnlyDictionary<string, TestEngineerDetails> GetTestEngineerDetailsLookup()
        {
            var lookup = new Dictionary<string, TestEngineerDetails>();
            try
            {
                var details = TestEngineerDetailsList.GetAllTestEngineers();
                foreach (var detail in details) { lookup[detail.Name] = detail; }
            }
            catch (Exception ex) { APILogger.Log(ex); }
            return lookup;
        }

        private TestTemplate[] GetTemplates(string name, TestSetupDefaults settings = null, bool bIgnoreUserTags = false)
        {
            if (null == settings)
            {
                settings = TestSetupDefaults.GetUserSettings(ApplicationProperties.CurrentUser.Id);
            }
            //fixes an error in cmdline import when servicelocator is null
            IEventAggregator eventAggregator = null;
            try
            {
                if (Application.Current.Dispatcher.CheckAccess())
                {
                    eventAggregator = ContainerLocator.Container.Resolve<IEventAggregator>();
                }
            }
            catch (Exception)
            {
                return new TestTemplate[0];
            }


            var testTemplates = new List<TestTemplate>(1000);
            IReadOnlyDictionary<string, CustomerDetails> customerLookup = null;
            if (RunTestVariables.InRunTest &&
                CachedCustomerDetails != null &&
                CachedCustomerDetails.Count() > 0)
            {
                customerLookup = CachedCustomerDetails;
            }
            else
            {
                customerLookup = GetCustomerDetailsLookup();
                if (RunTestVariables.InRunTest)
                {
                    CachedCustomerDetails = customerLookup;
                }
                else
                {
                    CachedCustomerDetails = null;
                }
            }

            IReadOnlyDictionary<string, LabratoryDetails> labLookup = null;
            if (RunTestVariables.InRunTest &&
                CachedLaboratoryDetails != null &&
                CachedLaboratoryDetails.Count() > 0)
            {
                labLookup = CachedLaboratoryDetails;
            }
            else
            {
                labLookup = GetLabDetailsLookup();
                if (RunTestVariables.InRunTest)
                {
                    CachedLaboratoryDetails = labLookup;
                }
                else
                {
                    CachedLaboratoryDetails = null;
                }
            }

            IReadOnlyDictionary<string, TestEngineerDetails> testEngineerLookup = null;
            if (RunTestVariables.InRunTest &&
                CachedTestEngineerDetails != null &&
                CachedTestEngineerDetails.Count() > 0)
            {
                testEngineerLookup = CachedTestEngineerDetails;
            }
            else
            {
                testEngineerLookup = GetTestEngineerDetailsLookup();
                if (RunTestVariables.InRunTest)
                {
                    CachedTestEngineerDetails = testEngineerLookup;
                }
                else
                {
                    CachedTestEngineerDetails = null;
                }
            }

            try
            {
                var hardware = TestTemplate.GetSimpleHardwares();
                var hr = DbOperations.TestSetupsGet(null, name, settings.DefaultROIStart, settings.DefaultROIEnd,
                    settings.DefaultIgnoreShortedStart, settings.DefaultIgnoreShortedTrigger, out var records, out var errors);
                if (0 == hr && null != records && records.Any())
                {
                    foreach (var record in records)
                    {
                        var tt = new TestTemplate(settings, false, hardware, record);
                        tt._bIsLoaded = false;

                        eventAggregator?.GetEvent<ProgressBarEvent>().Publish(new ProgressBarEventArg()
                        { SetText = true, ProgressBarText = $"{StringResources.GettingTestSetup} {tt.Name}" });

                        if (customerLookup.ContainsKey(record.CustomerDetails)) { tt.CustomerDetails = customerLookup[record.CustomerDetails]; }
                        else { tt.CustomerDetails = CustomerDetailsList.GetCustomerDetail(record.CustomerDetails); }

                        if (testEngineerLookup.ContainsKey(record.TestEngineerDetails)) { tt.TestEngineerDetails = testEngineerLookup[record.TestEngineerDetails]; }
                        else { tt.TestEngineerDetails = TestEngineerDetailsList.TestEngineerList.GetTestEngineerDetail(record.TestEngineerDetails); }

                        tt.DownloadFolder = DataModelSettings.DownloadFolder;
                        tt.ExportFolder = DataModelSettings.DownloadFolder;

                        if (labLookup.ContainsKey(record.LabDetails)) { tt.LabDetails = labLookup[record.LabDetails]; }
                        else { tt.LabDetails = LabratoryDetailsList.GetLab(record.LabDetails); }


                        switch (ApplicationProperties.CurrentUser.Role)
                        {
                            case DTS.Slice.Users.User.DefaultRoles.Administrator:
                                break;
                            case DTS.Slice.Users.User.DefaultRoles.Guest:
                            case DTS.Slice.Users.User.DefaultRoles.PowerUser:
                            case DTS.Slice.Users.User.DefaultRoles.User:
                                if (!bIgnoreUserTags && !ApplicationProperties.CurrentUser.TagCompatible(tt.GetTagIDs()))
                                {
                                    continue;
                                }

                                break;
                        }
                        if (string.IsNullOrEmpty(name) && tt.Name.Equals(DTS.Common.DataModel.Classes.TestTemplate.TSRAIRGoTestSetup.TEST_NAME))
                        {
                            //only return this template if we request it specifically ...
                            continue;
                        }
                        testTemplates.Add(tt);
                    }
                }
                if (null != eventAggregator && null != errors && errors.Any())
                {
                    try
                    {
                        eventAggregator.GetEvent<PageErrorEvent>().Publish(new PageErrorArg(errors, null));
                    }
                    catch (Exception) { }
                }
            }
            catch (Exception ex) { APILogger.Log("failed to retrieve test templates", ex); }
            eventAggregator?.GetEvent<ProgressBarEvent>().Publish(new ProgressBarEventArg()
            { SetText = true, ProgressBarText = string.Empty });
            return testTemplates.ToArray();
        }

        private async Task<TestTemplate[]> GetTemplatesAync(string name, TestSetupDefaults settings = null, bool bIgnoreUserTags = false)
        {
            //fixes an error in cmdline import when servicelocator is null
            IEventAggregator eventAggregator = null;
            try
            {
                if (Application.Current.Dispatcher.CheckAccess())
                {
                    eventAggregator = ContainerLocator.Container.Resolve<IEventAggregator>();
                }
            }
            catch (Exception)
            {
                return new TestTemplate[0];
            }

            var testTemplates = new List<TestTemplate>(100);
            try
            {
                var hardware = TestTemplate.GetSimpleHardwares();
                if (null == settings) { settings = TestSetupDefaults.GetUserSettings(ApplicationProperties.CurrentView.Id); }
                var hr = DbOperations.TestSetupsGet(null, name, settings.DefaultROIStart, settings.DefaultROIEnd,
                    settings.DefaultIgnoreShortedStart, settings.DefaultIgnoreShortedTrigger, out var records, out var errors);
                if (0 == hr && null != records && records.Any())
                {
                    foreach (var record in records)
                    {
                        var tt = new TestTemplate(settings, false, hardware, record);
                        eventAggregator?.GetEvent<ProgressBarEvent>().Publish(new ProgressBarEventArg()
                        { SetText = true, ProgressBarText = $"{StringResources.GettingTestSetup} {tt.Name}" });
                        tt.CustomerDetails = CustomerDetailsList.GetCustomerDetail(record.CustomerDetails);
                        tt.TestEngineerDetails = TestEngineerDetailsList.TestEngineerList.GetTestEngineerDetail(record.TestEngineerDetails);
                        tt.DownloadFolder = DataModelSettings.DownloadFolder;
                        tt.ExportFolder = DataModelSettings.DownloadFolder;
                        tt.LabDetails = LabratoryDetailsList.GetLab(record.LabDetails);

                        switch (ApplicationProperties.CurrentUser.Role)
                        {
                            case DTS.Slice.Users.User.DefaultRoles.Administrator:
                                break;
                            case DTS.Slice.Users.User.DefaultRoles.Guest:
                            case DTS.Slice.Users.User.DefaultRoles.PowerUser:
                            case DTS.Slice.Users.User.DefaultRoles.User:
                                if (!bIgnoreUserTags && !ApplicationProperties.CurrentUser.TagCompatible(tt.GetTagIDs()))
                                {
                                    continue;
                                }

                                break;
                        }
                        testTemplates.Add(tt);
                    }
                }
                if (null != eventAggregator && null != errors && errors.Any())
                {
                    try
                    {
                        eventAggregator.GetEvent<PageErrorEvent>().Publish(new PageErrorArg(errors, null));
                    }
                    catch (Exception) { }
                }
            }
            catch (Exception ex) { APILogger.Log("failed to retrieve test templates", ex); }
            eventAggregator?.GetEvent<ProgressBarEvent>().Publish(new ProgressBarEventArg()
            { SetText = true, ProgressBarText = string.Empty });
            return testTemplates.ToArray();
        }
        private void Commit(TestTemplate template, string user, bool bNotify, bool bUpdateTestSetupList = true)
        {
            TestSetupUpdate(user, template, bNotify);
            template.MarkIsCompleteUnchecked();
        }

        /// <summary>
        /// FB 15880 Delete multiple tests 
        /// </summary>
        /// <param name="testSetupIds">the list of the tests which should be deleted</param>
        /// <param name="updateTestSetupList"></param>
        private void DeleteMultipleTestSetups(List<int> testSetupIds, bool updateTestSetupList = true)
        {
            if (!testSetupIds.Any()) { return; }

            testSetupIds.Sort();
            _ = DbOperations.TestSetupsDeleteById(testSetupIds.ToArray());
            /// 15877 deleting multiple test setups takes too much time.
            /// 15880 it should not take much time to delete multiple test setups , we can always pass true now
            if (updateTestSetupList)
            {
                TestSetupCollection.UpdateTestSetupList();
                OnPropertyChanged(Tags.TestTemplates.ToString());
            }
        }
        /// <summary>
        /// FB 15880 Delete multiple tests 
        /// </summary>
        /// <param name="testSetupNames">the list of the tests which should be deleted</param>
        /// <param name="updateTestSetupList"></param>
        private void DeleteMultipleTestSetups(List<string> testSetupNames, bool updateTestSetupList = true)
        {
            if (!testSetupNames.Any()) { return; }

            testSetupNames.Sort();
            _ = DbOperations.TestSetupsDeleteByName(testSetupNames.ToArray());

            /// 15877 deleting multiple test setups takes too much time.
            /// 15880 it should not take much time to delete multiple test setups , we can always pass true now
            if (updateTestSetupList)
            {
                TestSetupCollection.UpdateTestSetupList();
                OnPropertyChanged(Tags.TestTemplates.ToString());
            }
        }
        /// <summary>
        /// this function directly updates the template name in the database
        /// this was done during testing of 13563 Copy a test, save (get warning about name). Change the name and save, but get same warning the next time I make a change
        /// I noticed that renaming a test setup was no longer resulting in a delete and an insert but 
        /// inserting a new test and pointing it to the objects used by the old one
        /// I'm not sure when this broke, but a solution to this is update the template name in the database, this way you'll be updating
        /// the existing test setup rather than creating a new one.
        /// </summary>
        /// <param name="template"></param>
        private void UpdateTemplateNameIfNeeded(TestTemplate template)
        {
            //it was creating new test setups when you renamed a test setup.  this is unintentional and changed at some point in the past
            //to fix this, if we have a positive id we have to update the name first
            //however we need to make sure the name doesn't already belong to a different test setup
            if (template.Id > 0)
            {
                bool bFound = false;
                using (var sql = DbOperations.GetSQLCommand(true))
                {
                    try
                    {
                        sql.CommandType = CommandType.Text;
                        sql.CommandText = "SELECT [TestSetupId] FROM [TestSetups] WHERE [TestSetupName]=@1";
                        sql.Parameters.Add(new SqlParameter("@1", SqlDbType.NVarChar) { Value = template.Name });

                        using (var reader = sql.ExecuteReader())
                        {
                            while (reader.Read())
                            {
                                var id = Convert.ToInt32(reader["TestSetupId"]);
                                if (id != template.Id)
                                {
                                    throw new Exception("Test setup name already belongs to a different test setup");
                                }
                                bFound = true;
                            }
                        }
                    }
                    finally
                    {
                        sql.Connection.Dispose();
                    }
                }
                if (!bFound)
                {
                    using (var sql = DbOperations.GetSQLCommand(true))
                    {
                        try
                        {
                            sql.CommandType = CommandType.Text;
                            sql.CommandText = "UPDATE [TestSetups] SET [TestSetupName]=@1 WHERE [TestSetupId]=@2";
                            sql.Parameters.Add(new SqlParameter("@1", SqlDbType.NVarChar, 255) { Value = template.Name });
                            sql.Parameters.Add(new SqlParameter("@2", SqlDbType.BigInt) { Value = template.Id });
                            sql.ExecuteNonQuery();
                        }
                        finally
                        {
                            sql.Connection.Dispose();
                        }
                    }
                }
            }
        }
        /// <summary>
        /// Update or insert Test Setup and related records
        /// </summary>
        /// <param name="user"></param>
        /// <param name="template"></param>
        /// <param name="bNotify"></param>
        public void TestSetupUpdate(string user, TestTemplate template, bool bNotify)
        {
            var testSetupId = 0;

            UpdateTemplateNameIfNeeded(template);
            #region Insert into TestSetups table

            template.LastModified = DateTime.Now;
            template.LastModifiedBy = user;
            template.IsDirty = false;
            var record = (ITestSetupRecord)template;
            if (null != template.CustomerDetails)
            {
                record.CustomerDetails = template.CustomerDetails.Name;
            }
            if (null != template.TestEngineerDetails)
            {
                record.TestEngineerDetails = template.TestEngineerDetails.Name;
            }
            if (null != template.LabDetails)
            {
                record.LabDetails = template.LabDetails.Name;
            }
            record.AlignUDPToPPS = template.AlignUDPToPPS;
            template.Settings = template.GetSettings();
            var hr = DbOperations.TestSetupsUpdateInsert(ref record);
            if (0 != hr)
            {
                APILogger.Log($"TestSetupUpdate failed: {hr}");
                return;
            }
            testSetupId = record.Id;
            #endregion Test Setups Table

            template.SaveHardware();

            template.SetTestSetupChannelOrder();
            //25620 Exception thrown when TSR AIR with a level trigger is removed from a Test Setup
            //SaveGroups can cause channels to be deleted, but level trigger has a constraint on channel id
            //so those have to be removed before channels are saved
            //note that level triggers were ordinarily deleted and inserted as needed later on
            DeleteLevelTriggers(template.Name);

            template.SaveGroups();

            #region Graphs table
            //14796 Cannot remove graph from test setup
            //ALWAYS update graphs, there may be existing graphs we need to remove
            template.Id = testSetupId;
            UpdateGraphs(template);
            #endregion Graphs table

            UpdateCalculatedChannels(testSetupId, template);

            #region Insert object meta data

            DeleteTestObjectMetaData(testSetupId, template.Name);
            UpdateTestObjectMetaData(testSetupId, template);

            #endregion Meta data

            #region Test meta data

            //DeleteTestMetaData(testSetupId, template.Name);
            var testMetaData = UpdateTestMetaData(testSetupId, template);

            #endregion Test meta data

            #region Insert Level Triggers

            UpdateLevelTriggers(testSetupId, template);

            #endregion LevelTriggers

            #region UpdateROIs

            var dbVersion = DbOperations.GetConnectionDbVersion();

            if (dbVersion >= DTS.Common.Constants.ROITables_DB_VERSION)
            {
                UpdateROIs(testSetupId, template);
            }

            #endregion UpdateROIs

        }
        #region TestSetupUpdate related functions        

        private void UpdateROIs(int testSetupId, TestTemplate template)
        {
            var hresult = DbOperations.RegionsOfInterestDelete(testSetupId);

            foreach (var regionOfInterest in template.RegionsOfInterest)
            {
                hresult = DbOperations.RegionsOfInterestInsert(testSetupId, regionOfInterest);
            }
        }

        private void DeleteLevelTriggers(string testSetupName)
        {
            using (var cmd = DbOperations.GetSQLCommand(true))
            {
                try
                {
                    cmd.CommandType = CommandType.StoredProcedure;
                    cmd.CommandText = DbOperationsEnum.StoredProcedure.sp_LevelTriggersDelete.ToString();

                    #region params

                    cmd.Parameters.Add(
                        new SqlParameter("@TestSetupName", SqlDbType.NVarChar, 255) { Value = testSetupName });
                    cmd.Parameters.Add(
                        new SqlParameter("@Id", SqlDbType.Int) { Value = DBNull.Value });
                    cmd.Parameters.Add(
                        new SqlParameter("@ChannelId", SqlDbType.Int) { Value = DBNull.Value });
                    cmd.Parameters.Add(
                        new SqlParameter("@TestSetupId", SqlDbType.Int) { Value = DBNull.Value });
                    var errorNumberParam =
                        new SqlParameter("@errorNumber", SqlDbType.Int) { Direction = ParameterDirection.Output };
                    cmd.Parameters.Add(errorNumberParam);
                    var errorMessageParam =
                        new SqlParameter("@errorMessage", SqlDbType.NVarChar, 250)
                        {
                            Direction = ParameterDirection.Output
                        };
                    cmd.Parameters.Add(errorMessageParam);

                    #endregion params

                    cmd.ExecuteNonQuery();
                    if (int.Parse(errorNumberParam.Value.ToString()) != 0)
                    {
                        APILogger.Log(errorMessageParam.Value.ToString());
                    }
                }
                finally { cmd.Connection.Dispose(); }
            }
        }

        /// <summary>
        /// Update Level Triggers
        /// </summary>
        /// <param name="testSetupId"></param>
        /// <param name="template"></param>
        private void UpdateLevelTriggers(int testSetupId, TestTemplate template)
        {
            //eliminate any invalid level triggers
            template.RemoveImpossibleLevelTriggers();
            DeleteLevelTriggers(template.Name);
            try
            {
                if (template.LevelTriggerChannels.Count <= 0) return;
                var e = template.LevelTriggerChannels.GetEnumerator();
                while (e.MoveNext())
                {
                    var lt = e.Current.Value;
                    using (var cmd = DbOperations.GetSQLCommand(true))
                    {
                        try
                        {
                            cmd.CommandType = CommandType.StoredProcedure;
                            cmd.CommandText = DbOperationsEnum.StoredProcedure.sp_LevelTriggersInsert.ToString();

                            #region params
                            cmd.Parameters.Add(
                                new SqlParameter("@TestSetupId", SqlDbType.Int) { Value = DBNull.Value });
                            cmd.Parameters.Add(
                                new SqlParameter("@TestSetupName", SqlDbType.NVarChar, 255) { Value = template.Name });
                            cmd.Parameters.Add(
                                new SqlParameter("@ChannelId", SqlDbType.BigInt) { Value = lt.GroupChannel.Id });
                            //cmd.Parameters.Add(
                            //    new SqlParameter("@GroupSerialNumber", SqlDbType.NVarChar, 255)
                            //    {
                            //        Value = lt.GroupSerialNumber
                            //    });
                            //cmd.Parameters.Add(
                            //    new SqlParameter("@TestObjectChannelId", SqlDbType.NVarChar, 255)
                            //    {
                            //        Value = lt.TestObjectChannelId
                            //    });
                            //cmd.Parameters.Add(
                            //    new SqlParameter("@HardwareChannelId", SqlDbType.NVarChar, 255)
                            //    {
                            //        Value = lt.HardwareChannelId
                            //    });
                            //cmd.Parameters.Add(
                            //    new SqlParameter("@SensorSerialNumber", SqlDbType.NVarChar, 255)
                            //    {
                            //        Value = lt.SensorSerialNumber
                            //    }); /* TODO: remove later*/

                            cmd.Parameters.Add(
                                new SqlParameter("@GreaterThanEnabled", SqlDbType.Bit) { Value = lt.GreaterThanEnabled });
                            cmd.Parameters.Add(
                                new SqlParameter("@GreaterThanEU", SqlDbType.Float)
                                {
                                    Value = lt.GreaterThanThresholdEU
                                });
                            cmd.Parameters.Add(
                                new SqlParameter("@LessThanEnabled", SqlDbType.Bit) { Value = lt.LessThanEnabled });
                            cmd.Parameters.Add(
                                new SqlParameter("@LessThanEU", SqlDbType.Float) { Value = lt.LessThanThresholdEU });
                            cmd.Parameters.Add(
                                new SqlParameter("@InsideUpperEU", SqlDbType.Float) { Value = lt.InsideUpperLevelEU });
                            cmd.Parameters.Add(
                                new SqlParameter("@InsideLowerEU", SqlDbType.Float) { Value = lt.InsideLowerLevelEU });
                            cmd.Parameters.Add(
                                new SqlParameter("@OutsideUpperEU", SqlDbType.Float) { Value = lt.OutsideUpperLevelEU });
                            cmd.Parameters.Add(
                                new SqlParameter("@OutsideLowerEU", SqlDbType.Float) { Value = lt.OutsideLowerLevelEU });
                            cmd.Parameters.Add(
                                new SqlParameter("@InsideEnabled", SqlDbType.Bit) { Value = lt.TriggerBetweenBounds });
                            cmd.Parameters.Add(
                                new SqlParameter("@OutsideEnabled", SqlDbType.Bit) { Value = lt.TriggerOutsideBounds });
                            //cmd.Parameters.Add(
                            //    new SqlParameter("@TriggerInside", SqlDbType.Bit) { Value = lt.TriggerBetweenBounds });
                            //cmd.Parameters.Add(
                            //    new SqlParameter("@TriggerOutside", SqlDbType.Bit) { Value = lt.TriggerOutsideBounds });
                            var newIdParam =
                                new SqlParameter("@new_id", SqlDbType.Int) { Direction = ParameterDirection.Output };
                            cmd.Parameters.Add(newIdParam);
                            var errorNumberParam =
                                new SqlParameter("@errorNumber", SqlDbType.Int) { Direction = ParameterDirection.Output };
                            cmd.Parameters.Add(errorNumberParam);
                            var errorMessageParam =
                                new SqlParameter("@errorMessage", SqlDbType.NVarChar, 250)
                                {
                                    Direction = ParameterDirection.Output
                                };
                            cmd.Parameters.Add(errorMessageParam);

                            #endregion params

                            cmd.ExecuteNonQuery();
                            if (int.Parse(errorNumberParam.Value.ToString()) != 0)
                            {
                                APILogger.Log(errorMessageParam.Value.ToString());
                            }
                        }
                        finally { cmd.Connection.Dispose(); }
                    }

                }
            }
            catch (Exception ex)
            {
                APILogger.Log(ex);
            }
            //throw new Exception("");
        }

        /// <summary>
        /// Update Test Setup Calculated Channels
        /// </summary>
        /// <param name="testSetupId"></param>
        /// <param name="template"></param>
        private void UpdateCalculatedChannels(int testSetupId, TestTemplate template)
        {
            //remap the -1 in input channel id for any input channels which were new (but are now in the db and have a valid id)
            template.UpdateCalculatedChannelInputIds();
            //step 1, get all existing calcualted channels
            var presentIds = new HashSet<int>();
            foreach (var cc in template.CalculatedChannels)
            {
                if (cc.Id > 0)
                {
                    presentIds.Add(cc.Id);
                }
            }
            var existingCalculatedChannelIds = GetExistingCalculatedChannelIds(template.Name);
            //step 2, remove no longer needed channels
            var toRemove = new List<int>();
            foreach (var id in existingCalculatedChannelIds)
            {
                if (!presentIds.Contains(id))
                {
                    toRemove.Add(id);
                }
            }

            foreach (var id in toRemove)
            {
                DeleteCalculatedChannel(id);
            }
            //step 3, update existing channels
            foreach (var cc in template.CalculatedChannels)
            {
                if (cc.Id > 0)
                {
                    //if the Calculated channel has an id, but that's not an id in the db for the test, well
                    //updating it won't work, insert it instead
                    if (!existingCalculatedChannelIds.Contains(cc.Id)) { cc.Id = -1; }
                    else { UpdateCalculatedChannel(cc, template.Name); }
                }
            }
            //step 4, add new calculated channels
            foreach (var cc in template.CalculatedChannels)
            {
                if (cc.Id <= 0)
                {
                    InsertCalculatedChannel(cc, template.Name);
                }
            }
        }

        private void InsertCalculatedChannel(CalculatedValueClass cc, string testSetupName)
        {
            cc.TestSetupName = testSetupName;
            _ = DbOperations.CalculatedChannelsInsert(cc);
        }
        private void UpdateCalculatedChannel(CalculatedValueClass cc, string testSetupName)
        {
            cc.TestSetupName = testSetupName;
            _ = DbOperations.CalculatedChannelsUpdate(cc);
        }
        private void DeleteCalculatedChannel(int id)
        {
            _ = DbOperations.CalculatedChannelsDelete(id);
        }
        private int[] GetExistingCalculatedChannelIds(string testName)
        {
            var list = new List<int>();

            var hr = DbOperations.CalculatedChannelsGet(null, testName, out var records);
            if (0 == hr && null != records && records.Any())
            {
                foreach (var record in records)
                {
                    if (!list.Contains(record.Id))
                    {
                        list.Add(record.Id);
                    }
                }
            }

            return list.ToArray();
        }

        /// <summary>
        /// Update Test Meta Data
        /// </summary>
        /// <param name="testSetupId"></param>
        /// <param name="template"></param>
        /// <returns></returns>
        private TestSetupMetaData UpdateTestMetaData(int testSetupId, TestTemplate template)
        {
            var testMeta = template.GetTestMetaData();
            // FB 17951 Prevent empty TestObject entry 
            if (string.IsNullOrWhiteSpace(testMeta.TestObject.ToString()))
            {
                return testMeta;
            }
            foreach (var prop in testMeta.Properties)
            {

                using (var cmd = DbOperations.GetSQLCommand(true))
                {
                    try
                    {
                        cmd.CommandType = CommandType.StoredProcedure;
                        cmd.CommandText = DbOperationsEnum.StoredProcedure.sp_TestSetupObjectMetaDataInsert.ToString();

                        #region params

                        cmd.Parameters.Add(new SqlParameter("@TestSetupId", SqlDbType.Int) { Value = testSetupId });
                        cmd.Parameters.Add(
                            new SqlParameter("@TestSetupName", SqlDbType.NVarChar, 50) { Value = template.Name });
                        cmd.Parameters.Add(
                            new SqlParameter("@ISOTestObject", SqlDbType.NVarChar, 1) { Value = testMeta.TestObject });
                        cmd.Parameters.Add(new SqlParameter("@PropName", SqlDbType.NVarChar, 255) { Value = prop.Name });
                        cmd.Parameters.Add(
                            new SqlParameter("@PropValue", SqlDbType.NVarChar, 255) { Value = prop.Value ?? "" });
                        cmd.Parameters.Add(new SqlParameter("@Optional", SqlDbType.Bit) { Value = prop.IsOptional });
                        cmd.Parameters.Add(new SqlParameter("@Version", SqlDbType.Float) { Value = prop.Version });
                        var newIdParam =
                            new SqlParameter("@new_id", SqlDbType.Int) { Direction = ParameterDirection.Output };
                        cmd.Parameters.Add(newIdParam);
                        var errorNumberParam =
                            new SqlParameter("@errorNumber", SqlDbType.Int) { Direction = ParameterDirection.Output };
                        cmd.Parameters.Add(errorNumberParam);
                        var errorMessageParam =
                            new SqlParameter("@errorMessage", SqlDbType.NVarChar, 250)
                            {
                                Direction = ParameterDirection.Output
                            };
                        cmd.Parameters.Add(errorMessageParam);

                        #endregion params

                        cmd.ExecuteNonQuery();
                        if (int.Parse(errorNumberParam.Value.ToString()) != 0)
                        {
                            APILogger.Log(errorMessageParam.Value.ToString());
                        }
                    }
                    finally { cmd.Connection.Dispose(); }
                }
            }
            return testMeta;
        }

        private void DeleteTestObjectMetaData(int testSetupId, string testSetupName)
        {
            using (var cmd = DbOperations.GetSQLCommand(true))
            {
                try
                {
                    cmd.CommandType = CommandType.StoredProcedure;
                    cmd.CommandText = DbOperationsEnum.StoredProcedure.sp_TestSetupObjectMetaDataDelete.ToString();

                    #region params

                    cmd.Parameters.Add(new SqlParameter("@TestSetupId", SqlDbType.Int) { Value = testSetupId });
                    cmd.Parameters.Add(
                        new SqlParameter("@TestSetupName", SqlDbType.NVarChar, 50) { Value = testSetupName });
                    var errorNumberParam =
                        new SqlParameter("@errorNumber", SqlDbType.Int) { Direction = ParameterDirection.Output };
                    cmd.Parameters.Add(errorNumberParam);
                    var errorMessageParam =
                        new SqlParameter("@errorMessage", SqlDbType.NVarChar, 250)
                        {
                            Direction = ParameterDirection.Output
                        };
                    cmd.Parameters.Add(errorMessageParam);

                    #endregion params

                    cmd.ExecuteNonQuery();
                    if (int.Parse(errorNumberParam.Value.ToString()) != 0)
                    {
                        APILogger.Log(errorMessageParam.Value.ToString());
                    }
                }
                finally { cmd.Connection.Dispose(); }
            }
        }
        /// <summary>
        /// Update Test Object Meta Data
        /// </summary>
        /// <param name="testSetupId"></param>
        /// <param name="template"></param>
        private void UpdateTestObjectMetaData(int testSetupId, TestTemplate template)
        {
            foreach (var metadata in template.GetMetaData())
            {
                // FB 17951 Prevent empty TestObject entry 
                if (string.IsNullOrWhiteSpace(metadata.TestObject.ToString()))
                {
                    continue;
                }
                foreach (var prop in metadata.Properties)
                {

                    using (var cmd = DbOperations.GetSQLCommand(true))
                    {
                        try
                        {
                            cmd.CommandType = CommandType.StoredProcedure;
                            cmd.CommandText =
                                DbOperationsEnum.StoredProcedure.sp_TestSetupObjectMetaDataInsert.ToString();

                            #region params

                            cmd.Parameters.Add(new SqlParameter("@TestSetupId", SqlDbType.Int) { Value = testSetupId });
                            cmd.Parameters.Add(
                                new SqlParameter("@TestSetupName", SqlDbType.NVarChar, 50) { Value = template.Name });
                            cmd.Parameters.Add(
                                new SqlParameter("@ISOTestObject", SqlDbType.NVarChar, 1)
                                {
                                    Value = metadata.TestObject
                                });
                            cmd.Parameters.Add(
                                new SqlParameter("@PropName", SqlDbType.NVarChar, 255) { Value = prop.Name });
                            cmd.Parameters.Add(
                                new SqlParameter("@PropValue", SqlDbType.NVarChar, 255) { Value = prop.Value });
                            cmd.Parameters.Add(new SqlParameter("@Optional", SqlDbType.Bit) { Value = prop.IsOptional });
                            cmd.Parameters.Add(new SqlParameter("@Version", SqlDbType.Float) { Value = prop.Version });
                            var newIdParam =
                                new SqlParameter("@new_id", SqlDbType.Int) { Direction = ParameterDirection.Output };
                            cmd.Parameters.Add(newIdParam);
                            var errorNumberParam =
                                new SqlParameter("@errorNumber", SqlDbType.Int) { Direction = ParameterDirection.Output };
                            cmd.Parameters.Add(errorNumberParam);
                            var errorMessageParam =
                                new SqlParameter("@errorMessage", SqlDbType.NVarChar, 250)
                                {
                                    Direction = ParameterDirection.Output
                                };
                            cmd.Parameters.Add(errorMessageParam);

                            #endregion params

                            cmd.ExecuteNonQuery();
                            if (int.Parse(errorNumberParam.Value.ToString()) != 0)
                            {
                                APILogger.Log(errorMessageParam.Value.ToString());
                            }
                        }
                        finally { cmd.Connection.Dispose(); }
                    }
                }
            }
        }

        private void UpdateGraphs(TestTemplate test)
        {
            //1, get list of existing graphs for test setup
            var existingIds = GetExistingGraphIds(test.Id);
            //2, delete any graphs no longer needed
            var existing = new HashSet<int>();
            foreach (var graph in test.TestGraphs)
            {
                existing.Add(graph.GraphId);
            }
            var toDelete = new List<int>();
            foreach (var id in existingIds)
            {
                if (!existing.Contains(id))
                {
                    toDelete.Add(id);
                }
            }

            foreach (var id in toDelete)
            {
                DeleteGraph(id);
            }
            //3, update
            foreach (var graph in test.TestGraphs)
            {
                if (graph.GraphId > 0)
                {
                    graph.TestSetupId = test.Id;
                    UpdateGraph(graph);
                }
            }
            //4, add any new ones
            foreach (var graph in test.TestGraphs)
            {
                if (graph.GraphId <= 0)
                {
                    graph.TestSetupId = test.Id;
                    InsertGraph(graph);
                }
            }
        }

        private void UpdateGraph(TestGraph graph)
        {
            graph.UpdateChannelAndThresholdStrings();
            _ = DbOperations.TestGraphsUpdate(graph);
        }

        private void InsertGraph(TestGraph graph)
        {
            graph.UpdateChannelAndThresholdStrings();
            _ = DbOperations.TestGraphsInsert(graph);
        }
        private void DeleteGraph(int id)
        {
            _ = DbOperations.TestGraphsDelete(id);
        }
        private int[] GetExistingGraphIds(int testSetupId)
        {
            var list = new List<int>();
            var hr = DbOperations.TestGraphsGet(null, testSetupId, out var records);
            if (0 == hr && null != records && records.Any())
            {
                foreach (var record in records)
                {
                    list.Add(record.GraphId);
                }
            }

            return list.ToArray();
        }

        #endregion TestSetupUpdate related functions

        public static SensorData GetSensorFromSettings(string settings, string serial, Dictionary<string, SensorData> lookup)
        {
            SensorData sd = null;
            if (null != lookup && lookup.ContainsKey(serial)) { sd = lookup[serial]; }
            if (null == sd) { sd = SensorsCollection.SensorsList.GetSensorBySerialNumber(serial); }

            if (string.IsNullOrWhiteSpace(serial))
            {
                sd = new SensorData { SerialNumber = "" };
            }
            if (null == sd) { return null; }
            sd = new SensorData(sd);
            var tokens = settings.Split(',');
            foreach (var token in tokens)
            {
                var subtokens = token.Split('=');
                var setting = (SensorConstants.SensorSettings)int.Parse(subtokens[0]);
                switch (setting)
                {
                    case SensorConstants.SensorSettings.CFC:
                        sd.FilterClassIso = subtokens[1];
                        break;
                    //FB 13120 filter class setting;
                    case SensorConstants.SensorSettings.FilterClass:
                        sd.FilterClass = FilterClass.GetFilterClassFromFilterClassSetting(subtokens[1]);
                        break;
                    case SensorConstants.SensorSettings.Position:
                        sd.Position = subtokens[1];
                        break;
                    case SensorConstants.SensorSettings.Polarity:
                        sd.Invert = subtokens[1] == "-";
                        break;
                    case SensorConstants.SensorSettings.Range:
                        sd.Capacity = double.Parse(subtokens[1], System.Globalization.CultureInfo.InvariantCulture);
                        break;
                    case SensorConstants.SensorSettings.Delay:
                        if (!string.IsNullOrWhiteSpace(subtokens[1])) { sd.DelayMS = double.Parse(subtokens[1], System.Globalization.CultureInfo.InvariantCulture); sd.DigitalOutputDelayMS = sd.DelayMS; }
                        break;
                    case SensorConstants.SensorSettings.Duration:
                        if (!string.IsNullOrWhiteSpace(subtokens[1])) { sd.DurationMS = double.Parse(subtokens[1], System.Globalization.CultureInfo.InvariantCulture); sd.DigitalOutputDurationMS = sd.DurationMS; }
                        break;
                    case SensorConstants.SensorSettings.OutputMode:
                        if (!string.IsNullOrWhiteSpace(subtokens[1])) { sd.DigitalOutputMode = (DigitalOutputModes)Convert.ToInt32(subtokens[1]); }
                        break;
                    case SensorConstants.SensorSettings.SQMode:
                        if (!string.IsNullOrWhiteSpace(subtokens[1])) { sd.SquibFireMode = (SquibFireMode)Convert.ToInt32(subtokens[1]); }
                        break;
                    case SensorConstants.SensorSettings.DIMode:
                        if (!string.IsNullOrWhiteSpace(subtokens[1])) { sd.InputMode = (DigitalInputModes)Convert.ToInt32(subtokens[1]); }
                        break;
                    case SensorConstants.SensorSettings.LimitDuration:
                        if (!string.IsNullOrWhiteSpace(subtokens[1])) { sd.LimitDuration = bool.Parse(subtokens[1]); }
                        break;
                    case SensorConstants.SensorSettings.ActiveValue:
                        if (!string.IsNullOrWhiteSpace(subtokens[1])) { sd.ScaleMultiplier.ActiveValue = Convert.ToDouble(subtokens[1]); }
                        break;
                    case SensorConstants.SensorSettings.DefaultValue:
                        if (!string.IsNullOrWhiteSpace(subtokens[1])) { sd.ScaleMultiplier.DefaultValue = Convert.ToDouble(subtokens[1]); }
                        break;
                    case SensorConstants.SensorSettings.DigitalOutDelay:
                        if (!string.IsNullOrWhiteSpace(subtokens[1])) { sd.DigitalOutputDelayMS = Convert.ToDouble(subtokens[1], System.Globalization.CultureInfo.InvariantCulture); }
                        break;
                    case SensorConstants.SensorSettings.DigitalOutDuration:
                        if (!string.IsNullOrWhiteSpace(subtokens[1])) { sd.DigitalOutputDurationMS = Convert.ToDouble(subtokens[1], System.Globalization.CultureInfo.InvariantCulture); }
                        break;
                    case SensorConstants.SensorSettings.DigitalOutLimitDuration:
                        if (!string.IsNullOrWhiteSpace(subtokens[1])) { sd.DigitalOutputLimitDuration = Convert.ToBoolean(subtokens[1]); }
                        break;
                    case SensorConstants.SensorSettings.SquibDelay:
                        if (!string.IsNullOrWhiteSpace(subtokens[1])) { sd.SquibFireDelayMS = Convert.ToDouble(subtokens[1], System.Globalization.CultureInfo.InvariantCulture); }
                        break;
                    case SensorConstants.SensorSettings.SquibDuration:
                        if (!string.IsNullOrWhiteSpace(subtokens[1])) { sd.SquibFireDurationMS = Convert.ToDouble(subtokens[1], System.Globalization.CultureInfo.InvariantCulture); }
                        break;
                    case SensorConstants.SensorSettings.SquibLimitDuration:
                        if (!string.IsNullOrWhiteSpace(subtokens[1])) { sd.LimitSquibFireDuration = Convert.ToBoolean(subtokens[1]); }
                        break;
                }
            }
            return sd;
        }
        public static SensorData GetSensorFromSettings(string settings, string serial)
        {
            return GetSensorFromSettings(settings, serial, null);
        }
        public static string GetSensorSettings(SensorData sd)
        {
            var list = new List<string>();
            switch (sd.Bridge)
            {
                case SensorConstants.BridgeType.RTC:
                case SensorConstants.BridgeType.IEPE:
                case SensorConstants.BridgeType.QuarterBridge:
                case SensorConstants.BridgeType.HalfBridge:
                case SensorConstants.BridgeType.FullBridge:
                case SensorConstants.BridgeType.HalfBridge_SigPlus:
                    list.Add($"{(int)SensorConstants.SensorSettings.CFC}={sd.FilterClassIso}");
                    //FB 13120 filter class setting
                    list.Add($"{(int)SensorConstants.SensorSettings.FilterClass}={$"{sd.FilterClass.FClass},{sd.FilterClass.Frequency}"}");
                    list.Add($"{(int)SensorConstants.SensorSettings.Polarity}={(sd.Invert ? "-" : "+")}");
                    list.Add($"{(int)SensorConstants.SensorSettings.Position}={sd.Position}");
                    list.Add($"{(int)SensorConstants.SensorSettings.Range}={sd.Capacity.ToString(System.Globalization.CultureInfo.InvariantCulture)}");
                    break;
                case SensorConstants.BridgeType.DigitalInput:
                    list.Add($"{(int)SensorConstants.SensorSettings.DIMode}={(int)sd.InputMode}");
                    list.Add($"{(int)SensorConstants.SensorSettings.ActiveValue}={sd.ScaleMultiplier.ActiveValue.ToString(System.Globalization.CultureInfo.InvariantCulture)}");
                    list.Add($"{(int)SensorConstants.SensorSettings.DefaultValue}={sd.ScaleMultiplier.DefaultValue.ToString(System.Globalization.CultureInfo.InvariantCulture)}");
                    break;
                case SensorConstants.BridgeType.SQUIB:
                    list.Add($"{(int)SensorConstants.SensorSettings.SQMode}={(int)sd.SquibFireMode}");
                    list.Add($"{(int)SensorConstants.SensorSettings.SquibDelay}={sd.SquibFireDelayMS.ToString(System.Globalization.CultureInfo.InvariantCulture)}");
                    list.Add($"{(int)SensorConstants.SensorSettings.SquibDuration}={sd.SquibFireDurationMS.ToString(System.Globalization.CultureInfo.InvariantCulture)}");
                    list.Add($"{(int)SensorConstants.SensorSettings.SquibLimitDuration}={sd.LimitSquibFireDuration.ToString()}");
                    break;
                case SensorConstants.BridgeType.TOMDigital:
                    list.Add($"{(int)SensorConstants.SensorSettings.OutputMode}={(int)sd.DigitalOutputMode}");
                    list.Add($"{(int)SensorConstants.SensorSettings.DigitalOutDelay}={sd.DigitalOutputDelayMS.ToString(System.Globalization.CultureInfo.InvariantCulture)}");
                    list.Add($"{(int)SensorConstants.SensorSettings.DigitalOutDuration}={sd.DigitalOutputDurationMS.ToString(System.Globalization.CultureInfo.InvariantCulture)}");
                    list.Add($"{(int)SensorConstants.SensorSettings.DigitalOutLimitDuration}={sd.DigitalOutputLimitDuration.ToString()}");
                    break;
            }

            return string.Join(",", list.ToArray());
        }
        public void CommitGroupOfTemplates(TestTemplate[] templates, bool bNotify)
        {
            foreach (var template in templates)
            {
                Commit(template, ApplicationProperties.CurrentUser.UserName, bNotify, false);
                template.MarkIsCompleteUnchecked();
            }
            if (1 == templates.Length)
            {
                TestSetupCollection.UpdateTestSetupList(templates.FirstOrDefault());
            }
            else { TestSetupCollection.UpdateTestSetupList(); }
            OnPropertyChanged(Tags.TestTemplates.ToString());
        }
        public void Commit(TestTemplate template) { Commit(template, true); }
        public void Commit(TestTemplate template, bool bNotify)
        {
            CommitGroupOfTemplates(new[] { template }, bNotify);
        }
        private TestTemplate _currentTest;
        public TestTemplate CurrentTest
        {
            get => _currentTest;
            set
            {
                SetProperty(ref _currentTest, value, Tags.CurrentTest.ToString());
                //FB14483 "Should not include calculated channel when running test if Calculated Channel UI is not enabled either"
                if (!Common.SerializedSettings.AllowCalculatedChannels) CurrentTest?.CalculatedChannels.Clear();
                var eventAggregator = ContainerLocator.Container.Resolve<IEventAggregator>();
                eventAggregator.GetEvent<CurrentTestChangedEvent>().Publish(value?.Name ?? string.Empty);
            }
        }

        private TestTemplate _savedCurrentTest;
        public TestTemplate SavedCurrentTest
        {
            get => _savedCurrentTest;
            set => SetProperty(ref _savedCurrentTest, value, Tags.SavedCurrentTest.ToString());
        }

        private static TestTemplateList _list;
        private static readonly object ObjectLock = new object();
        public static TestTemplateList TestTemplatesList
        {
            get
            {
                lock (ObjectLock)
                {
                    if (null == _list) { _list = new TestTemplateList(); }
                }
                return _list;
            }
        }

        /// <summary>
        /// delete templates from the db and remove them from the list of templates
        /// </summary>
        /// <param name="testSetupIds">test id of templates to delete</param>
        /// <param name="user"></param>
        public void DeleteTestSetups(List<int> testSetupIds, string user)
        {
            DeleteMultipleTestSetups(testSetupIds);
            OnPropertyChanged(Tags.TestTemplates.ToString());
        }


        /// <summary>
        /// delete templates from the db and remove them from the list of templates
        /// </summary>
        /// <param name="testSetupIds">test id of templates to delete</param>
        /// <param name="user"></param>
        public void DeleteTestSetups(List<string> testSetupNames, string user)
        {
            DeleteMultipleTestSetups(testSetupNames);
            OnPropertyChanged(Tags.TestTemplates.ToString());
        }

        public TestTemplate[] TestTemplates
        {
            get
            {
                var templates = new List<TestTemplate>(GetAllTemplates());
                for (var i = templates.Count - 1; i >= 0; i--)
                {
                    if (!templates[i].IsComplete) { templates.RemoveAt(i); }
                }
                templates.Sort();
                return templates.ToArray();
            }
        }

        public TestTemplate[] AllTemplates
        {
            get
            {
                var templates = new List<TestTemplate>(GetAllTemplates());

                templates.Sort();
                return templates.ToArray();
            }
        }

        public async Task<TestTemplate[]> GetAllTemplatesAync()
        {
            var unsortedTemplates = await GetAllTemplatesForUserAsync(false);
            var templates = new List<TestTemplate>(unsortedTemplates);

            templates.Sort();
            return templates.ToArray();
        }

        private TestTemplate[] GetAllTemplates()
        {
            return GetAllTemplatesForUser(false);
        }


        public TestTemplate[] GetAllTemplatesForUser(bool bIgnoreUserTags = false)
        {
            var settings = TestSetupDefaults.GetUserSettings(ApplicationProperties.CurrentUser.Id);
            return GetTemplates(null, settings, bIgnoreUserTags);
        }

        public async Task<TestTemplate[]> GetAllTemplatesForUserAsync(bool bIgnoreUserTags = false)
        {
            var settings = TestSetupDefaults.GetUserSettings(ApplicationProperties.CurrentUser.Id);
            return await GetTemplatesAync(null, settings, bIgnoreUserTags);
        }
        public static void ConvertToDictionary(IDataReader reader, ref Dictionary<string, List<Dictionary<string, object>>> lookup, string key)
        {
            var count = reader.FieldCount;
            var names = new string[count];
            for (var i = 0; i < names.Length; i++)
            {
                names[i] = reader.GetName(i);
            }
            while (reader.Read())
            {
                var thiskey = Convert.ToString(reader[key]);
                if (!lookup.ContainsKey(thiskey)) { lookup.Add(thiskey, new List<Dictionary<string, object>>()); }
                var properties = new Dictionary<string, object>(count);
                foreach (var column in names)
                {
                    properties[column] = reader[column];
                }
                lookup[thiskey].Add(properties);
            }
        }
    }
}