init

Common/DTS.Common/.svn/pristine/60/601370fdb343d0bf1cf89e63eae8a1b4aeea41e9.svn-base

@@ -0,0 +1,15 @@
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Reflection;
+using DataPro.Common.Base;
+
+namespace DataPro.Common.Interface
+{
+    public interface ITileViewModel : IBaseViewModel
+    {
+        ITileView View { get; set; }
+
+        string GroupName { get; set; }
+        List<AssemblyNameImage> AssemblyList { get; set; }
+    }
+}

Common/DTS.Common/.svn/pristine/60/602c12629768d1d6fe9f1dd148e950186e33ae96.svn-base

@@ -0,0 +1,25 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using System.Windows.Controls;
+using DTS.Common.Events;
+using Prism.Ioc;
+using Prism.Events;
+
+namespace DTS.Common.Resources
+{
+    public partial class MainTabControlResource
+    {
+        public void ToolTipEventHandler(object sender, System.Windows.Controls.ToolTipEventArgs e)
+        {
+            e.Handled = true;
+
+            var eventAggregator = ContainerLocator.Container.Resolve<IEventAggregator>();
+
+            eventAggregator.GetEvent<HelpTextEvent>().Publish(new HelpTextEventArg()
+            { Sender = sender, E = e });
+        }
+    }
+}

Common/DTS.Common/.svn/pristine/60/60551de72270333ce762a815fa8359ef638f3ca0.svn-base

@@ -0,0 +1,152 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using DTS.Common.Base;
+using DTS.Common.Classes.DSP;
+using DTS.Common.Classes.Hardware;
+using DTS.Common.Enums;
+using DTS.Common.Interface.Pagination;
+using DTS.Common.Interface.TestSetups.TestSetupsList;
+
+namespace DTS.Common.Interface.DASFactory.Diagnostics.HardwareList
+{
+    public interface IHardwareListViewModel : IBaseViewModel, IFilterableListView
+    {
+        /// <summary>
+        /// a user selected slice6
+        /// </summary>
+        ISLICE6TreeNode SelectedSLICE6 { get; set; }
+        /// <summary>
+        /// all slice6 which are not associated with a given S6DB
+        /// </summary>
+        ISLICE6TreeNode[] AvailableSLICE6 { get; set; }
+        /// <summary>
+        /// currently selected SLICE6DB
+        /// </summary>
+        IHardware SelectedSLICE6DB { get; set; }
+        /// <summary>
+        /// all available SLICE6DB
+        /// </summary>
+        IHardware[] AvailableSLICE6DB { get; set; }
+
+        bool IsEdit { get; set; }
+        int TDASCalPeriod { get; set; }
+        int G5CalPeriod { get; set; }
+        int SLICE1CalPeriod { get; set; }
+        int SLICE1_5CalPeriod { get; set; }
+        int SLICE2_CalPeriod { get; set; }
+        int SLICE6_CalPeriod { get; set; }
+        int POWERPRO_CalPeriod { get; set; }
+        int SLICE6Air_CalPeriod { get; set; }
+        int SLICE6DB_CalPeriod { get; set; }
+        int TSRAir_CalPeriod { get; set; }
+        IStreamingFilterProfile StreamingDSPProfile { get;set; }
+        /// <summary>
+        /// the hardware replacement view
+        /// </summary>
+        IHardwareListReplaceView ReplaceView { get; set; }
+        IHardwareListView View { get; set; }
+        IHardwareListOverdueView OverdueView { get; set; }
+        IHardwareListSelectView SelectView { get; set; }
+        ISLICE6TreeView SLICE6TreeView { get; set; }
+        IHardware[] Hardware { get; set; }
+        IHardware[] OverdueHardware { get; set; }
+        /// <summary>
+        /// the hardware in the test (replacementview)
+        /// </summary>
+        IHardware[] HardwareInTest { get; set; }
+        /// <summary>
+        /// the hardware to replace
+        /// </summary>
+        IHardware HardwareToReplace { get; set; }
+        /// <summary>
+        /// the hardware that is available to replace with
+        /// </summary>
+        IHardware[] AvailableHardware { get; set; }
+        /// <summary>
+        /// initializes the replacement view given a test id
+        /// </summary>
+        void InitializeReplace(ITestSetup setup, IsoViewMode viewMode);
+        void GetHardware(bool bIncludeModules, bool bIncludeOverdue, bool bIncludeBridges, int? testId, int? groupId);
+        void GetAvailableSampleRates(int[] availableSampleRates);
+        void SetTestSampleRates(Dictionary<string, double> testSampleRates);
+        void SetHasIncludedChildren();
+        void UpdateTestSampleRate(string childSerialNumber, double testSampleRate);
+        int TestAAFRateHzColumnWidth { get; set; }
+        void SetTestAAFRates(Dictionary<string, float> testAAFRates);
+        void UpdateTestAAFilterRate(string childSerialNumber, float testAAFilterRate);
+        Func<SerializableAAF.DAS_TYPE, int, float> GetAAFForHardwareFunc { get; set; }
+        void CheckForMixedDAS(string nonParentSerialNumber, double testSampleRate);
+        void SetParentMixedRates(string parentDAS, bool mixedRates);
+        int TestSampleRateColumnWidth { get; set; }
+        int TestClockMasterColumnWidth { get; set; }
+        int PTPDomainColumnWidth { get; set; }
+        void SetTestClockProfiles(DTS.Common.ClockSyncProfile masterProfile, DTS.Common.ClockSyncProfile slaveProfile);
+        void SetTestClockMasters(Dictionary<string, bool> testClockMasters);
+        void UpdateTestClockMaster(string childSerialNumber, bool testClockMaster);
+        void SetTestPTPDomainIDs(Dictionary<string, byte> testPTPDomainIDs);
+        void UpdateTestPTPDomainID(string childSerialNumber, byte ptpDomainId);
+        void Unset();
+        void Sort(object o, bool columnClick);
+        void SortOverdue(object o, bool columnClick);
+        void SetIncluded(string[] serialNumbers, bool included);
+        void SetIncluded(int[] dasId);
+        void Filter(string term);
+        void MouseDoubleClick(int index);
+
+        void SetCache(IISOHardware[] hardware);
+        /// <summary>
+        /// whether to show a compact view (no rack modules) or
+        /// expanded (show rack modules)
+        /// </summary>
+        bool ShowCompact { get; set; }
+        /// <summary>
+        /// loads tree for given hardware
+        /// </summary>
+        /// <param name="serialNumber"></param>
+        void LoadTreeView(string serialNumber);
+
+        /// <summary>
+        /// all the SLICE6 associated with a S6DB
+        /// (LoadTreeView will set this)
+        /// </summary>
+        ISLICE6TreeNode[] SLICE6TreeNodes { get; set; }
+
+        /// <summary>
+        /// associates a SLICE6 with a SLICE6DB
+        /// [does not commit]
+        /// </summary>
+        /// <param name="node"></param>
+        void Associate(ISLICE6TreeNode node);
+
+        /// <summary>
+        /// associates units from one SLICE6DB
+        /// with another
+        /// [does not commit]
+        /// </summary>
+        /// <param name="node"></param>
+        void Associate(IHardware node);
+        /// <summary>
+        /// removes the association of a SLICE6 with a SLICE6DB
+        /// [does not commit]
+        /// </summary>
+        /// <param name="node"></param>
+        void UnAssociate(ISLICE6TreeNode node);
+        /// <summary>
+        /// associates or de-associates SLICE6 from a SLICE6DB
+        /// </summary>
+        void SaveSLICE6Associations(string serialNumber);
+
+        IHardware[] GetSelectedItems();
+        /// <summary>
+        /// Replaces HardwareToReplace with ReplacementHardware
+        /// </summary>
+        void Replace();
+        /// <summary>
+        /// the selected hardware to replace with
+        /// </summary>
+        IHardware ReplacementHardware { get; set; }
+        void SetCalPeriods(int g5CalPeriod, int slice1CalPeriod, int slice1_5CalPeriod, int slice2_CalPeriod, int slice6_CalPeriod, int tdasCalPeriod,
+            int powerpro_CalPeriod, int slice6Air_CalPeriod, int slice6DB_CalPeriod, int tsrAir_CalPeriod, int slice6AirBridge_CalPeriod, int sliceTcCalPeriod);
+    }
+}

Common/DTS.Common/.svn/pristine/60/606448e2951747df4b420eb3fc5648d1c668500e.svn-base

@@ -0,0 +1,28 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Data;
+using System.Windows.Documents;
+using System.Windows.Input;
+using System.Windows.Media;
+using System.Windows.Media.Imaging;
+using System.Windows.Navigation;
+using System.Windows.Shapes;
+
+namespace DTS.Common.Controls
+{
+    /// <summary>
+    /// Interaction logic for TestIDView.xaml
+    /// </summary>
+    public partial class TestIDView : UserControl
+    {
+        public TestIDView()
+        {
+            InitializeComponent();
+        }
+    }
+}

Common/DTS.Common/.svn/pristine/60/60b52627710f420f3ece1fc6bb22987ca45ee96d.svn-base

@@ -0,0 +1,689 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Threading.Tasks;
+using System.Xml.Linq;
+using DTS.Common.Base;
+using DTS.Common.Enums;
+using DTS.Common.Enums.Sensors;
+using DTS.Common.Enums.Viewer;
+using DTS.Common.Interface;
+using DTS.Common.Interface.TestDefinition;
+using DTS.Common.Utilities;
+using DTS.Common.Utils;
+using DTS.Common.XMLUtils;
+using Prism.Events;
+using Prism.Ioc;
+// ReSharper disable UnusedVariable
+// ReSharper disable UnusedMember.Local
+// ReSharper disable SuggestBaseTypeForParameter
+// ReSharper disable RedundantAssignment
+// ReSharper disable CheckNamespace
+
+namespace DTS.Common.Classes.Viewer.TestMetadata
+{
+    public class TestMetadataList
+    {
+#pragma warning disable 1998
+        public async Task<ObservableCollection<ITestSummary>> GetTestSummaryListAsync(IBaseViewModel parent, string path, string file, string pattern = "")
+#pragma warning restore 1998
+        {
+            return GetTestSummaryList(parent, path, file, pattern);
+        }
+        public ObservableCollection<ITestSummary> GetTestSummaryList(IBaseViewModel parent, string path, string file = "", string pattern = "")
+        {
+            return new ObservableCollection<ITestSummary>(BuildITestSummary(GetTestMetadataList(TestMetadataXml.GetTestMetadataXml(path, file, string.IsNullOrEmpty(pattern) ? ".dts" : pattern), path, file), parent));
+        }
+        public ObservableCollection<ITestSummary> GetTestSummaryList(string path, string file = "", string pattern = "")
+        {
+            return new ObservableCollection<ITestSummary>(BuildITestSummary(GetTestMetadataList(TestMetadataXml.GetTestMetadataXml(path, file, string.IsNullOrEmpty(pattern) ? ".dts" : pattern), path, file)));
+        }
+        private static string ParseEventNumber(string path)
+        {
+            var segments = path.Split('\\');
+            return Array.Find(segments, p => p.StartsWith($"{DTS.Common.Constants.EventNumber}"));
+        }
+        private static List<ITestSummary> BuildITestSummary(IEnumerable<ITestMetadata> metadata, IBaseViewModel parent)
+        {
+            List<ITestSummary> ts;
+            try
+            {
+                ts = metadata.Select(md => new TestSummary
+                {
+                    TestMetadata = md,
+                    SetupName = md.TestSetup.SetupName,
+                    Id = md.TestRun.Id + ParseEventNumber(md.TestRun.FilePath),
+                    Description = md.TestRun.Description,
+                    FileDate = md.TestRun.FileDate,
+                    TimeStamp = GetTimestamp(md),
+                    ChannelCount = md.TestRun.Channels.Count,
+                    DataType = md.TestRun.DataType,
+                    IsSelected = false,
+                    Parent = parent,
+                    Graphs = md.TestSetup.TestGraphs,
+                    Channels = md.TestRun.Channels,
+                    CalculatedChannels = md.TestRun.CalculatedChannels,
+                    CalibrationBehavior = md.TestSetup.CalibrationBehavior
+                }).Cast<ITestSummary>().OrderByDescending(x => x.TimeStamp.Ticks).ToList();
+            }
+            catch (Exception ex)
+            {
+                var error = ex.Message;
+                ts = new List<ITestSummary>();
+            }
+            return ts;
+        }
+        //FB 29410 Get DateTime with milli seconds if the date is before 1/1/1990 then use the TimeStamp from testsetup 
+        private static DateTime GetTimestamp(ITestMetadata md)
+        {
+            var basemodules = md.TestRun.Modules.GroupBy(module => module.BaseSerialNumber).Select(group => group.First());
+
+            List<TestModuleTimeStamp> testModuleTimeStamps = new List<TestModuleTimeStamp>();
+            foreach (var module in basemodules)
+            {
+                TestModuleTimeStamp testModuleTimeStamp =
+                    new TestModuleTimeStamp { TriggerTimestampSec = module.TriggerTimestampSec, TriggerTimestampNanoSec = module.TriggerTimestampNanoSec };
+
+                testModuleTimeStamps.Add(testModuleTimeStamp);
+            }
+
+            var tuplesTime = TestUtils.MinUnixTime(testModuleTimeStamps);
+            if (null != tuplesTime && PTP1588Timestamps.IsValidTimeStamp(tuplesTime.Item1))
+            {
+                var time = PTP1588Timestamps.UnixTimeStampToDateTimeLocal(tuplesTime.Item1);
+                double ticks = tuplesTime.Item2 / 100.00;
+                var timeWithTicks = time.AddTicks((long)ticks);
+                return timeWithTicks;
+            }
+
+            return md.TestSetup.TimeStamp;
+        }
+
+        private static List<ITestSummary> BuildITestSummary(IEnumerable<ITestMetadata> metadata)
+        {
+            List<ITestSummary> ts;
+            try
+            {
+                ts = metadata.Select(md => new TestSummary
+                {
+                    TestMetadata = md,
+                    SetupName = md.TestSetup.SetupName,
+                    Id = md.TestRun.Id + ParseEventNumber(md.TestRun.FilePath),
+                    Description = md.TestRun.Description,
+                    FileDate = md.TestRun.FileDate,
+                    TimeStamp = GetTimestamp(md),
+                    ChannelCount = md.TestRun.Channels.Count,
+                    DataType = md.TestRun.DataType,
+                    IsSelected = false,
+                    //Parent = parent,
+                    Graphs = md.TestSetup.TestGraphs,
+                    Channels = md.TestRun.Channels,
+                    CalculatedChannels = md.TestRun.CalculatedChannels,
+                    CalibrationBehavior = md.TestSetup.CalibrationBehavior
+                }).Cast<ITestSummary>().OrderByDescending(x => x.TimeStamp.Ticks).ToList();
+            }
+            catch (Exception ex)
+            {
+                var error = ex.Message;
+                ts = new List<ITestSummary>();
+            }
+            return ts;
+        }
+        private const string TEST_NAME = "TSRAIR_GO_TEST";
+        /// <summary>
+        /// Return list of files
+        /// </summary>
+        /// <param name="xDoc">.dts file in xml format</param>
+        /// <param name="path">.dts file path</param>
+        /// <param name="file">.dts file name</param>
+        /// <returns></returns>
+        public List<ITestMetadata> GetTestMetadataList(XDocument xDoc, string path, string file)
+        {
+            List<ITestMetadata> tm;
+            //keep track of any tests that fail to load and warn of them
+            List<ITestMetadata> tmToRemove = new List<ITestMetadata>();
+            try
+            {
+                var items = xDoc.Elements("Tests").Elements("TestMetadata")
+                .Select(x => new TestMetadata
+                {
+                    TestRun = GetTestRunMetadata(x),
+                    TestSetup = GetTestSetupMetadata(x)
+                }).Cast<ITestMetadata>();
+                if (RunTestVariables.IsTSRAIRGo)
+                {
+                    tm = items.Where(x => x.TestRun.FilePath.Contains(TEST_NAME)).ToList();
+                }
+                else { tm = items.ToList(); }
+                
+                var errors = new List<string>();
+                foreach (var testMetadata in tm)
+                {
+
+                    try
+                    {
+                        testMetadata.TestRun.Channels =
+                            new ITestChannel[testMetadata.TestRun.Modules.Select(x => x.NumberOfChannels).ToList()
+                                .Sum()].ToList();
+                    }
+                    catch (Exception ex)
+                    {
+                        errors.Add($"Failed to load channels from {testMetadata.TestSetup.SetupName} - {ex.Message}");
+                        tmToRemove.Add(testMetadata);
+                    }
+                }
+
+                if (errors.Any())
+                {
+                    var eventAggregator = ContainerLocator.Container.Resolve<IEventAggregator>();
+                    eventAggregator.GetEvent<Events.PageErrorEvent>()
+                        .Publish(new Events.PageErrorArg(errors.ToArray(), null));
+                }
+
+                foreach (var metaData in tmToRemove)
+                {
+                    tm.Remove(metaData);
+                }
+
+            }
+            catch (Exception ex)
+            {
+                var error = ex.Message;
+                tm = new List<ITestMetadata>();
+            }
+            return tm;
+        }
+
+        #region TestMetadata
+
+        private static DateTime GetDateTime(string dataString)
+        {
+            if (string.Equals("NOVALUE", dataString)) return DateTime.MinValue;
+            return Convert.ToDateTime(dataString, CultureInfo.InvariantCulture);
+        }
+
+        #region TestSetupMetadata
+        /// <summary>
+        /// Returns Test setup metadata 
+        /// </summary>
+        /// <param name="x"></param>
+        /// <returns></returns>
+        private TestSetupMetadata GetTestSetupMetadata(XElement x)
+        {
+
+            TestSetupMetadata ts;
+            try
+            {
+                if (x.Element("TestSetup") != null)
+                {
+                    ts = (from c in x.Descendants("TestSetup")
+                          select new TestSetupMetadata
+                          {
+                              SetupName = c.Element(TestSetupMetadataFields.Name.ToString())?.Value,
+                              TimeStamp = GetDateTime(c.Element(TestSetupMetadataFields.Timestamp.ToString())?.Value),
+                              TestGraphs = GetTestSetupGraphs(c.Element(TestSetupMetadataFields.Graphs.ToString())),
+                              CalibrationBehavior = (CalibrationBehaviors)Enum.Parse(typeof(CalibrationBehaviors), c.Element(TestSetupMetadataFields.CalibrationBehavior.ToString())?.Value ?? CalibrationBehaviors.NonLinearIfAvailable.ToString())
+                          }).FirstOrDefault();
+                }
+                else
+                {
+                    ts = new TestSetupMetadata
+                    {
+                        SetupName = "N/A",
+                        TimeStamp = DateTime.MinValue,
+                        TestGraphs = new List<ITestGraphs>(),
+                        CalibrationBehavior = CalibrationBehaviors.NonLinearIfAvailable
+                    };
+                }
+
+            }
+            catch (Exception ex)
+            {
+                var error = ex.Message;
+                ts = new TestSetupMetadata();
+            }
+            return ts;
+        }
+
+        /// <summary>
+        /// Returns graphs
+        /// </summary>
+        /// <param name="xTestGraphs"></param>
+        /// <returns></returns>
+        private List<ITestGraphs> GetTestSetupGraphs(XElement xTestGraphs)
+        {
+            List<ITestGraphs> tg;
+            try
+            {
+                tg = (from c in xTestGraphs.Descendants("Graph")
+                      select new TestGraphs
+                      {
+                          Name = c.Element(TestGraphsFields.Name.ToString())?.Value,
+                          HardwareChannelName = c.Element(TestGraphsFields.HardwareChannelName.ToString())?.Value,
+                          ChannelIds = GetChannelIds(c.Element(TestGraphsFields.Channels.ToString()))
+                      }).Cast<ITestGraphs>().ToList();
+
+            }
+            catch (Exception ex)
+            {
+                var error = ex.Message;
+                tg = new List<ITestGraphs>();
+            }
+            return tg;
+        }
+
+        /// <summary>
+        /// Returns graph's list of ChannelIds
+        /// </summary>
+        /// <param name="xChannelIds"></param>
+        /// <returns></returns>
+        private List<string> GetChannelIds(XElement xChannelIds)
+        {
+            try
+            {
+                return (from c in xChannelIds.Descendants(TestGraphsFields.Channel.ToString()) select c.Element(TestGraphsFields.ChannelId.ToString())?.Value).ToList();
+
+            }
+            catch (Exception ex)
+            {
+                var error = ex.Message;
+                return new List<string>();
+            }
+        }
+
+        #endregion TestSetupMetadata
+
+        #region TestRunMetadata
+
+        /// <summary>
+        /// returns TestRun Metadata
+        /// </summary>
+        /// <param name="x">DataPRO data folder</param>
+        /// <returns></returns>
+        private TestRunMetadata GetTestRunMetadata(XElement x)
+        {
+            TestRunMetadata td;
+            try
+            {
+                td = (from c in x.Descendants("Test")
+                      select new TestRunMetadata
+                      {
+                          /* Name is id in DTS file, id is a file name */
+
+                          Id = Path.GetFileNameWithoutExtension(c.Attribute(TestRunMetadataFields.FilePath.ToString())?.Value),
+                          Name = c.Attribute(TestRunMetadataFields.Id.ToString())?.Value,
+
+                          Description = c.Attribute(TestRunMetadataFields.Description.ToString())?.Value,
+                          InlineSerializedData = ParseBoolean(c.Attribute(TestRunMetadataFields.InlineSerializedData.ToString())?.Value),
+                          TestGuid = c.Attribute(TestRunMetadataFields.Guid.ToString())?.Value,
+                          FaultFlags = ParseInt(c.Attribute(TestRunMetadataFields.FaultFlags.ToString())?.Value),
+                          Software = c.Attribute(TestRunMetadataFields.Software.ToString())?.Value,
+                          SoftwareVersion = c.Attribute(TestRunMetadataFields.SoftwareVersion.ToString())?.Value,
+                          DataType = c.Attribute(TestRunMetadataFields.DataType.ToString())?.Value,
+                          FilePath = c.Attribute(TestRunMetadataFields.FilePath.ToString())?.Value,
+                          FileDate = ParseDateTime(c.Attribute(TestRunMetadataFields.FileDate.ToString())?.Value),
+                          Modules = LoadTestModules(c.Element(TestRunMetadataFields.Modules.ToString()), c.Attribute(TestRunMetadataFields.Id.ToString())?.Value, Path.GetFileNameWithoutExtension(c.Attribute(TestRunMetadataFields.FilePath.ToString())?.Value)),
+                          //Channels = LoadTestChannels(c.Elements(TestRunMetadataFields.Modules.ToString()).Elements(TestRunMetadataFields.Module.ToString()).Elements(TestRunMetadataFields.Channels.ToString())),
+                          //CalculatedChannels = LoadTestCalculatedChannel(c.Elements(TestRunMetadataFields.Modules.ToString()).Elements(TestRunMetadataFields.Module.ToString()).Elements(TestRunMetadataFields.CalculatedChannels.ToString())),
+                      }).FirstOrDefault();
+
+            }
+            catch (Exception ex)
+            {
+                var error = ex.Message;
+                td = new TestRunMetadata();
+            }
+            return td;
+        }
+
+        /// <summary>
+        /// Returns list of all Test Modules
+        /// </summary>
+        /// <param name="xTestModules">Modules xml node</param>
+        /// <param name="testSetupName"></param>
+        /// <param name="testId"></param>
+        /// <returns></returns>
+        private List<ITestModule> LoadTestModules(XElement xTestModules, string testSetupName, string testId)
+        {
+            List<ITestModule> tm;
+            try
+            {
+                tm = (from m in xTestModules.Descendants("Module")
+                      select new TestModule
+                      {
+                          SerialNumber = m.Attribute(TestModuleFields.SerialNumber.ToString())?.Value,
+                          BaseSerialNumber = m.Attribute(TestModuleFields.BaseSerialNumber.ToString())?.Value,
+                          AaFilterRateHz = ParseInt(m.Attribute(TestModuleFields.AaFilterRateHz.ToString())?.Value),
+                          Number = ParseInt(m.Attribute(TestModuleFields.Number.ToString())?.Value),
+                          NumberOfSamples = ParseInt(m.Attribute(TestModuleFields.NumberOfSamples.ToString())?.Value),
+                          UnsubsampledNumberOfSamples = ParseInt(m.Attribute(TestModuleFields.UnsubsampledNumberOfSamples.ToString())?.Value),
+                          RequestedPostTriggerSeconds = ParseDouble(m.Attribute(TestModuleFields.RequestedPostTriggerSeconds.ToString())?.Value),
+                          RequestedPreTriggerSeconds = ParseDouble(m.Attribute(TestModuleFields.RequestedPreTriggerSeconds.ToString())?.Value),
+                          PostTriggerSeconds = ParseDouble(m.Attribute(TestModuleFields.PostTriggerSeconds.ToString())?.Value),
+                          PreTriggerSeconds = ParseDouble(m.Attribute(TestModuleFields.PreTriggerSeconds.ToString())?.Value),
+                          RecordingMode = m.Attribute(TestModuleFields.RecordingMode.ToString())?.Value,
+                          SampleRateHz = ParseInt(m.Attribute(TestModuleFields.SampleRateHz.ToString())?.Value),
+                          StartRecordSampleNumber = ParseInt(m.Attribute(TestModuleFields.StartRecordSampleNumber.ToString())?.Value),
+                          NumberOfChannels = ParseInt(m.Attribute(TestModuleFields.NumberOfChannels.ToString())?.Value),
+                          InlineSerializedData = ParseBoolean(m.Attribute(TestModuleFields.InlineSerializedData.ToString())?.Value),
+                          StartRecordTimestampSec = ParseInt(m.Attribute(TestModuleFields.StartRecordTimestampSec.ToString())?.Value),
+                          StartRecordTimestampNanoSec = ParseInt(m.Attribute(TestModuleFields.StartRecordTimestampNanoSec.ToString())?.Value),
+                          TriggerTimestampSec = ParseInt(m.Attribute(TestModuleFields.TriggerTimestampSec.ToString())?.Value),
+                          TriggerTimestampNanoSec = ParseInt(m.Attribute(TestModuleFields.TriggerTimestampNanoSec.ToString())?.Value),
+
+                          TriggerSampleNumbers = LoadTriggerSampleNumbers(m.Elements("TriggerSampleNumbers")),
+
+
+                          PTPMasterSync = ParseBoolean(m.Attribute(TestModuleFields.PTPMasterSync.ToString())?.Value),
+                          TiltSensorAxisXDegreesPre = ParseInt(m.Attribute(TestModuleFields.TiltSensorAxisXDegreesPre.ToString())?.Value),
+                          TiltSensorAxisYDegreesPre = ParseInt(m.Attribute(TestModuleFields.TiltSensorAxisYDegreesPre.ToString())?.Value),
+                          TiltSensorAxisZDegreesPre = ParseInt(m.Attribute(TestModuleFields.TiltSensorAxisZDegreesPre.ToString())?.Value),
+                          TiltSensorAxisXDegreesPost = ParseInt(m.Attribute(TestModuleFields.TiltSensorAxisXDegreesPost.ToString())?.Value),
+                          TiltSensorAxisYDegreesPost = ParseInt(m.Attribute(TestModuleFields.TiltSensorAxisYDegreesPost.ToString())?.Value),
+                          TiltSensorAxisZDegreesPost = ParseInt(m.Attribute(TestModuleFields.TiltSensorAxisZDegreesPost.ToString())?.Value),
+                          TemperatureLocation1Pre = ParseInt(m.Attribute(TestModuleFields.TemperatureLocation1Pre.ToString())?.Value),
+                          TemperatureLocation2Pre = ParseInt(m.Attribute(TestModuleFields.TemperatureLocation2Pre.ToString())?.Value),
+                          TemperatureLocation3Pre = ParseInt(m.Attribute(TestModuleFields.TemperatureLocation3Pre.ToString())?.Value),
+                          TemperatureLocation4Pre = ParseInt(m.Attribute(TestModuleFields.TemperatureLocation4Pre.ToString())?.Value),
+                          TemperatureLocation1Post = ParseInt(m.Attribute(TestModuleFields.TemperatureLocation1Post.ToString())?.Value),
+                          TemperatureLocation2Post = ParseInt(m.Attribute(TestModuleFields.TemperatureLocation2Post.ToString())?.Value),
+                          TemperatureLocation3Post = ParseInt(m.Attribute(TestModuleFields.TemperatureLocation3Post.ToString())?.Value),
+                          TemperatureLocation4Post = ParseInt(m.Attribute(TestModuleFields.TemperatureLocation4Post.ToString())?.Value),
+                          Channels = LoadTestChannels(m.Elements("Channels"), m.Attribute(TestModuleFields.SerialNumber.ToString())?.Value, testSetupName, testId),
+                          CalculatedChannels = LoadTestCalculatedChannels(m.Elements("CalculatedChannels"), testSetupName, testId)
+                      }).Cast<ITestModule>().ToList();
+            }
+            catch (Exception ex)
+            {
+                var error = ex.Message;
+                tm = new List<ITestModule>();
+            }
+            return tm;
+        }
+        /// <summary>
+        /// ?
+        /// </summary>
+        /// <param name="xTriggerSampleNumbers"></param>
+        /// <returns></returns>
+        // ReSharper disable once UnusedParameter.Local
+        private List<ulong> LoadTriggerSampleNumbers(IEnumerable<XElement> xTriggerSampleNumbers)
+        {
+            return new List<ulong>();
+        }
+
+        /// <summary>
+        /// Returns list (IEnumerable) of all test channels 
+        /// </summary>
+        /// <param name="xTestChannels">Channels xml node</param>
+        /// <param name="moduleId"></param>
+        /// <param name="testSetupName"></param>
+        /// <param name="testId"></param>
+        /// <returns></returns>
+        private List<ITestChannel> LoadTestChannels(IEnumerable<XElement> xTestChannels, string moduleId, string testSetupName, string testId)
+        {
+            List<ITestChannel> tc;
+            try
+            {
+                tc = (from m in xTestChannels.Descendants("AnalogInputChanel")
+                      select new TestChannel
+                      {
+                          TestId = testId,
+                          TestSetupName = testSetupName,
+                          ModuleSerialNumber = moduleId,
+                          SerialNumber = m.Attribute(TestChannelFields.SerialNumber.ToString())?.Value,
+                          ChannelId = m.Attribute(TestChannelFields.ChannelId.ToString()) == null || ParseInt(m.Attribute(TestChannelFields.ChannelId.ToString())?.Value) == -1 ? m.GetHashCode().ToString() : m.Attribute(TestChannelFields.ChannelId.ToString())?.Value,
+                          Description = m.Attribute(TestChannelFields.Description.ToString())?.Value,
+                          ChannelType = m.Attribute(TestChannelFields.ChannelType.ToString())?.Value,
+                          Number = ParseInt(m.Attribute(TestChannelFields.Number.ToString())?.Value),
+                          DigitalMultiplier = m.Attribute(TestChannelFields.DigitalMultiplier.ToString())?.Value,
+                          DigitalMode = m.Attribute(TestChannelFields.DigitalMode.ToString())?.Value,
+                          Start = GetDateTime(m.Attribute(TestChannelFields.Start.ToString())?.Value),
+                          Bridge = m.Attribute(TestChannelFields.Bridge.ToString())?.Value,
+                          BridgeResistanceOhms = ParseDouble(m.Attribute(TestChannelFields.BridgeResistanceOhms.ToString())?.Value),
+                          ZeroPoint = ParseDouble(m.Attribute(TestChannelFields.ZeroPoint.ToString())?.Value),
+                          ChannelDescriptionString = m.Attribute(TestChannelFields.ChannelDescriptionString.ToString())?.Value,
+                          ChannelName2 = m.Attribute(TestChannelFields.ChannelName2.ToString())?.Value,
+                          HardwareChannelName = m.Attribute(TestChannelFields.HardwareChannelName.ToString())?.Value,
+                          DesiredRange = ParseDouble(m.Attribute(TestChannelFields.DesiredRange.ToString())?.Value),
+                          Sensitivity = ParseDouble(m.Attribute(TestChannelFields.Sensitivity.ToString())?.Value),
+                          SoftwareFilter = m.Attribute(TestChannelFields.SoftwareFilter.ToString())?.Value,
+                          ProportionalToExcitation = ParseBoolean(m.Attribute(TestChannelFields.ProportionalToExcitation.ToString())?.Value),
+                          IsInverted = ParseBoolean(m.Attribute(TestChannelFields.IsInverted.ToString())?.Value),
+                          LinearizationFormula = m.Attribute(TestChannelFields.LinearizationFormula.ToString())?.Value,
+                          IsSubsampled = ParseBoolean(m.Attribute(TestChannelFields.IsSubsampled.ToString())?.Value),
+                          AbsoluteDisplayOrder = ParseInt(m.Attribute(TestChannelFields.AbsoluteDisplayOrder.ToString())?.Value),
+                          LastCalibrationDate = GetDateTime(m.Attribute(TestChannelFields.LastCalibrationDate.ToString())?.Value),
+                          SensorId = m.Attribute(TestChannelFields.SensorId.ToString())?.Value,
+                          OffsetToleranceLowMv = ParseInt(m.Attribute(TestChannelFields.OffsetToleranceLowMv.ToString())?.Value),
+                          OffsetToleranceHighMv = ParseInt(m.Attribute(TestChannelFields.OffsetToleranceHighMv.ToString())?.Value),
+                          DataFlag = ParseInt(m.Attribute(TestChannelFields.DataFlag.ToString())?.Value),
+                          ExcitationVoltage = m.Attribute(TestChannelFields.ExcitationVoltage.ToString())?.Value,
+                          Eu = m.Attribute(TestChannelFields.Eu.ToString())?.Value,
+                          CalSignalEnabled = ParseBoolean(m.Attribute(TestChannelFields.CalSignalEnabled.ToString())?.Value),
+                          ShuntEnabled = ParseBoolean(m.Attribute(TestChannelFields.ShuntEnabled.ToString())?.Value),
+                          VoltageInsertionCheckEnabled = ParseBoolean(m.Attribute(TestChannelFields.VoltageInsertionCheckEnabled.ToString())?.Value),
+                          RemoveOffset = ParseBoolean(m.Attribute(TestChannelFields.RemoveOffset.ToString())?.Value),
+                          ZeroMethod = m.Attribute(TestChannelFields.ZeroMethod.ToString())?.Value,
+                          ZeroAverageWindowBegin = ParseDouble(m.Attribute(TestChannelFields.ZeroAverageWindowBegin.ToString())?.Value),
+                          ZeroAverageWindowEnd = ParseDouble(m.Attribute(TestChannelFields.ZeroAverageWindowEnd.ToString())?.Value),
+                          InitialEu = ParseInt(m.Attribute(TestChannelFields.InitialEu.ToString())?.Value),
+                          InitialOffset = m.Attribute(TestChannelFields.InitialOffset.ToString())?.Value,
+                          UnsubsampledSampleRateHz = ParseInt(m.Attribute(TestChannelFields.UnsubsampledSampleRateHz.ToString())?.Value),
+                          MeasuredShuntDeflectionMv = ParseDouble(m.Attribute(TestChannelFields.MeasuredShuntDeflectionMv.ToString())?.Value),
+                          TargetShuntDeflectionMv = ParseDouble(m.Attribute(TestChannelFields.TargetShuntDeflectionMv.ToString())?.Value),
+                          MeasuredExcitationVoltage = ParseDouble(m.Attribute(TestChannelFields.MeasuredExcitationVoltage.ToString())?.Value),
+                          FactoryExcitationVoltage = ParseDouble(m.Attribute(TestChannelFields.FactoryExcitationVoltage.ToString())?.Value),
+                          TimeOfFirstSample = ParseDouble(m.Attribute(TestChannelFields.TimeOfFirstSample.ToString())?.Value),
+                          Multiplier = m.Attribute(TestChannelFields.Multiplier.ToString()) == null ? 1 : ParseDouble(m.Attribute(TestChannelFields.Multiplier.ToString())?.Value),
+                          UserOffsetEu = ParseDouble(m.Attribute(TestChannelFields.UserOffsetEU.ToString())?.Value),
+                          UnitConversion = m.Attribute(TestChannelFields.UnitConversion.ToString()) == null ? 1 : ParseInt(m.Attribute(TestChannelFields.UnitConversion.ToString())?.Value),
+                          AtCapacity = ParseBoolean(m.Attribute(TestChannelFields.AtCapacity.ToString())?.Value),
+                          CapacityOutputIsBasedOn = ParseInt(m.Attribute(TestChannelFields.CapacityOutputIsBasedOn.ToString())?.Value),
+                          SensitivityUnits = m.Attribute(TestChannelFields.SensitivityUnits.ToString())?.Value,
+                          SensorCapacity = ParseInt(m.Attribute(TestChannelFields.SensorCapacity.ToString())?.Value),
+                          SensorPolarity = m.Attribute(TestChannelFields.SensorPolarity.ToString())?.Value,
+                          IsoCode = m.Attribute(TestChannelFields.IsoCode.ToString())?.Value ?? string.Empty,
+                          IsoChannelName = m.Attribute(TestChannelFields.IsoChannelName.ToString())?.Value ?? string.Empty,
+                          UserCode = m.Attribute(TestChannelFields.UserCode.ToString())?.Value ?? string.Empty,
+                          UserChannelName = m.Attribute(TestChannelFields.UserChannelName.ToString())?.Value ?? string.Empty,
+                          UseEUScaler = ParseBoolean(m.Attribute(TestChannelFields.UseEUScaler.ToString())?.Value),
+                          ScaleFactorEU = ParseDouble(m.Attribute(TestChannelFields.ScaleFactorEU.ToString())?.Value),
+                      }).Cast<ITestChannel>().ToList();
+            }
+            catch (Exception ex)
+            {
+                var error = ex.Message;
+                tc = new List<ITestChannel>();
+            }
+            return tc;
+        }
+
+
+        /// <summary>
+        /// Load Calculated Channels
+        /// </summary>
+        /// <param name="xTestCalculatedChannel"></param>
+        /// <param name="testSetupName"></param>
+        /// <param name="testId"></param>
+        /// <returns></returns>
+        private List<ITestChannel> LoadTestCalculatedChannels(IEnumerable<XElement> xTestCalculatedChannel, string testSetupName, string testId)
+        {
+            List<ITestChannel> list = new List<ITestChannel>();
+            try
+            {
+                var calculatedChannelsPart = xTestCalculatedChannel.Descendants("CalculatedChannel");
+                foreach (var m in calculatedChannelsPart)
+                {
+                    var tc = new TestChannel()
+                    {
+                        TestId = testId,
+                        TestSetupName = testSetupName,
+                        IsCalculatedChannel = true,
+                        ChannelId =
+                            m.Attribute(TestChannelFields.ChannelId.ToString()) == null ||
+                            ParseInt(m.Attribute(TestChannelFields.ChannelId.ToString())?.Value) == -1
+                                ? m.GetHashCode().ToString()
+                                : m.Attribute(TestChannelFields.ChannelId.ToString())?.Value,
+                        //37943, wipe info for calculated channels that's just the first channel's info
+                        SerialNumber = Strings.Strings.Table_NA,
+                        Description = m.Attribute(TestChannelFields.Description.ToString())?.Value,
+                        ChannelType = m.Attribute(TestChannelFields.ChannelType.ToString())?.Value,
+                        Number = ParseInt(m.Attribute(TestChannelFields.Number.ToString())?.Value),
+                        DigitalMultiplier = m.Attribute(TestChannelFields.DigitalMultiplier.ToString())?.Value,
+                        DigitalMode = m.Attribute(TestChannelFields.DigitalMode.ToString())?.Value,
+                        Start = GetDateTime(m.Attribute(TestChannelFields.Start.ToString())?.Value),
+                        Bridge = m.Attribute(TestChannelFields.Bridge.ToString())?.Value,
+                        BridgeResistanceOhms =
+                            ParseDouble(m.Attribute(TestChannelFields.BridgeResistanceOhms.ToString())?.Value),
+                        ChannelDescriptionString =
+                            m.Attribute(TestChannelFields.ChannelDescriptionString.ToString())?.Value,
+                        ChannelName2 = m.Attribute(TestChannelFields.ChannelName2.ToString())?.Value,
+                        HardwareChannelName = Strings.Strings.Table_NA,
+                        DesiredRange = ParseDouble(m.Attribute(TestChannelFields.DesiredRange.ToString())?.Value),
+                        Sensitivity = ParseDouble(m.Attribute(TestChannelFields.Sensitivity.ToString())?.Value),
+                        SoftwareFilter = m.Attribute(TestChannelFields.SoftwareFilter.ToString())?.Value,
+                        ProportionalToExcitation =
+                            ParseBoolean(m.Attribute(TestChannelFields.ProportionalToExcitation.ToString())?.Value),
+                        IsInverted = ParseBoolean(m.Attribute(TestChannelFields.IsInverted.ToString())?.Value),
+                        LinearizationFormula = m.Attribute(TestChannelFields.LinearizationFormula.ToString())?.Value,
+                        IsSubsampled = ParseBoolean(m.Attribute(TestChannelFields.IsSubsampled.ToString())?.Value),
+                        AbsoluteDisplayOrder =
+                            ParseInt(m.Attribute(TestChannelFields.AbsoluteDisplayOrder.ToString())?.Value),
+                        LastCalibrationDate =
+                            GetDateTime(m.Attribute(TestChannelFields.LastCalibrationDate.ToString())?.Value),
+                        SensorId = m.Attribute(TestChannelFields.SensorId.ToString())?.Value,
+                        OffsetToleranceLowMv =
+                            ParseInt(m.Attribute(TestChannelFields.OffsetToleranceLowMv.ToString())?.Value),
+                        OffsetToleranceHighMv =
+                            ParseInt(m.Attribute(TestChannelFields.OffsetToleranceHighMv.ToString())?.Value),
+                        DataFlag = ParseInt(m.Attribute(TestChannelFields.DataFlag.ToString())?.Value),
+                        ExcitationVoltage = m.Attribute(TestChannelFields.ExcitationVoltage.ToString())?.Value,
+                        Eu = m.Attribute(TestChannelFields.Eu.ToString())?.Value,
+                        CalSignalEnabled =
+                            ParseBoolean(m.Attribute(TestChannelFields.CalSignalEnabled.ToString())?.Value),
+                        ShuntEnabled = ParseBoolean(m.Attribute(TestChannelFields.ShuntEnabled.ToString())?.Value),
+                        VoltageInsertionCheckEnabled =
+                            ParseBoolean(m.Attribute(TestChannelFields.VoltageInsertionCheckEnabled.ToString())?.Value),
+                        RemoveOffset = ParseBoolean(m.Attribute(TestChannelFields.RemoveOffset.ToString())?.Value),
+                        ZeroMethod = m.Attribute(TestChannelFields.ZeroMethod.ToString())?.Value,
+                        ZeroAverageWindowBegin =
+                            ParseDouble(m.Attribute(TestChannelFields.ZeroAverageWindowBegin.ToString())?.Value),
+                        ZeroAverageWindowEnd =
+                            ParseDouble(m.Attribute(TestChannelFields.ZeroAverageWindowEnd.ToString())?.Value),
+                        InitialEu = ParseInt(m.Attribute(TestChannelFields.InitialEu.ToString())?.Value),
+                        InitialOffset = m.Attribute(TestChannelFields.InitialOffset.ToString())?.Value,
+                        UnsubsampledSampleRateHz =
+                            ParseInt(m.Attribute(TestChannelFields.UnsubsampledSampleRateHz.ToString())?.Value),
+                        MeasuredShuntDeflectionMv =
+                            ParseDouble(m.Attribute(TestChannelFields.MeasuredShuntDeflectionMv.ToString())?.Value),
+                        MeasuredExcitationVoltage =
+                            ParseDouble(m.Attribute(TestChannelFields.MeasuredExcitationVoltage.ToString())?.Value),
+
+                        FactoryExcitationVoltage =
+                            ParseInt(m.Attribute(TestChannelFields.UnsubsampledSampleRateHz.ToString())?.Value),
+                        TimeOfFirstSample =
+                            ParseDouble(m.Attribute(TestChannelFields.MeasuredShuntDeflectionMv.ToString())?.Value),
+
+                        Multiplier = m.Attribute(TestChannelFields.Multiplier.ToString()) == null
+                            ? 1
+                            : ParseDouble(m.Attribute(TestChannelFields.Multiplier.ToString())?.Value),
+                        UserOffsetEu = ParseDouble(m.Attribute(TestChannelFields.UserOffsetEU.ToString())?.Value),
+                        UnitConversion = m.Attribute(TestChannelFields.UnitConversion.ToString()) == null
+                            ? 1
+                            : ParseInt(m.Attribute(TestChannelFields.UnitConversion.ToString())?.Value),
+                        AtCapacity = ParseBoolean(m.Attribute(TestChannelFields.AtCapacity.ToString())?.Value),
+                        CapacityOutputIsBasedOn =
+                            ParseInt(m.Attribute(TestChannelFields.CapacityOutputIsBasedOn.ToString())?.Value),
+
+                        SourceChannelNumber = m.Attribute(TestChannelFields.SourceChannelNumber.ToString())?.Value,
+                        SourceModuleNumber = m.Attribute(TestChannelFields.SourceModuleNumber.ToString())?.Value,
+                        SourceModuleSerialNumber =
+                            m.Attribute(TestChannelFields.SourceModuleSerialNumber.ToString())?.Value,
+                        Calculation = m.Attribute(TestChannelFields.Calculation.ToString())?.Value,
+                        SampleRateHz = ParseInt(m.Attribute(TestChannelFields.SampleRateHz.ToString())?.Value),
+                        //37943, wipe info for calculated channels that's just the first channel's info
+                        IsoCode = Strings.Strings.Table_NA,
+                        //37943, wipe info for calculated channels that's just the first channel's info
+                        IsoChannelName = Strings.Strings.Table_NA,
+                        //37943, wipe info for calculated channels that's just the first channel's info
+                        UserCode = Strings.Strings.Table_NA,
+                        //37943, wipe info for calculated channels that's just the first channel's info
+                        UserChannelName = Strings.Strings.Table_NA,
+                        UseEUScaler = ParseBoolean(m.Attribute(TestChannelFields.UseEUScaler.ToString())?.Value),
+                        ScaleFactorEU = ParseDouble(m.Attribute(TestChannelFields.ScaleFactorEU.ToString())?.Value),
+                    };
+                    var hic = m.Attribute("HIC");
+                    if (null != hic)
+                    {
+                        if (double.TryParse(hic.Value, out var d))
+                        {
+                            tc.HIC = d;
+                            tc.T1Sample = ulong.Parse(m.Attribute("T1").Value);
+                            tc.T2Sample = ulong.Parse(m.Attribute("T2").Value);
+                        }
+                    }
+
+                    list.Add(tc);
+                }
+            }
+            catch (Exception ex)
+            {
+                var error = ex.Message;
+                list = new List<ITestChannel>();
+            }
+            return list;
+        }
+        #endregion TestRunMetadata
+
+        #endregion TestMetadata
+
+        #region Support functions
+
+
+
+        /// <summary>
+        /// Safer way to parse 
+        /// </summary>
+        /// <param name="param"></param>
+        /// <returns></returns>
+        private int ParseInt(string param)
+        {
+            var result = 0;
+            int.TryParse(param, out result);
+            return result;
+        }
+        /// <summary>
+        /// Safer way to parse 
+        /// </summary>
+        /// <param name="param"></param>
+        /// <returns></returns>
+        private double ParseDouble(string param)
+        {
+            double.TryParse(param, NumberStyles.Any, CultureInfo.InvariantCulture, out var result);
+            return result;
+        }
+        /// <summary>
+        /// Safer way to parse 
+        /// </summary>
+        /// <param name="param"></param>
+        /// <returns></returns>
+        private bool ParseBoolean(string param)
+        {
+            bool.TryParse(param, out var result);
+            return result;
+        }
+
+        private DateTime ParseDateTime(string param)
+        {
+            DateTime.TryParse(param, out var result);
+            return result;
+        }
+
+
+
+        #endregion Support functions
+    }
+}