init

Common/DTS.Common/Interface/TestSetups/CachedItemsList/ICachedItem.cs

@@ -0,0 +1,16 @@
+using System;
+
+namespace DTS.Common.Interface.TestSetups.CachedItemsList
+{
+    public interface ICachedItem
+    {
+        string Name { get; }
+        string ObjectType { get; }
+        DateTime CacheTime { get; }
+        /// <summary>
+        /// DateTime.MinValue indicates no longer in db, otherwise
+        /// the LastModified time in the db
+        /// </summary>
+        DateTime DBTime { get; }
+    }
+}

Common/DTS.Common/Interface/TestSetups/CachedItemsList/ICachedItemsListView.cs

@@ -0,0 +1,6 @@
+using DTS.Common.Base;
+
+namespace DTS.Common.Interface.TestSetups.CachedItemsList
+{
+    public interface ICachedItemsListView : IBaseView { }
+}

Common/DTS.Common/Interface/TestSetups/CachedItemsList/ICachedItemsListViewModel.cs

@@ -0,0 +1,16 @@
+using DTS.Common.Base;
+using DTS.Common.Interface.DataRecorders;
+using DTS.Common.Interface.Sensors;
+
+namespace DTS.Common.Interface.TestSetups.CachedItemsList
+{
+    public interface ICachedItemsListViewModel : IBaseViewModel
+    {
+        ICachedItemsListView View { get; set; }
+        ICachedItem[] CachedItems { get; set; }
+        bool SetCachedItems(ISensorData[] sensors, ISensorCalibration[] sensorCalibrations, IDASHardware[] hardware,
+            IDASHardware[] allDAS);
+        bool HasOutofDateCachedItems { get; }
+        bool HasMissingSensors { get; }
+    }
+}

Common/DTS.Common/Interface/TestSetups/Diagnostics/IDiagnosticsTreeView.cs

@@ -0,0 +1,6 @@
+using DTS.Common.Base;
+
+namespace DTS.Common.Interface.TestSetups.Diagnostics
+{
+    public interface IDiagnosticsTreeView : IBaseView { }
+}

Common/DTS.Common/Interface/TestSetups/Diagnostics/IDiagnosticsViewModel.cs

@@ -0,0 +1,10 @@
+using DTS.Common.Base;
+
+namespace DTS.Common.Interface.TestSetups.Diagnostics
+{
+    public interface IDiagnosticsViewModel : IBaseViewModel
+    {
+        IDiagnosticsTreeView View { get; set; }
+        void Unset();
+    }
+}

Common/DTS.Common/Interface/TestSetups/ICalculatedChannelRecord.cs

@@ -0,0 +1,70 @@
+using DTS.Common.Base.Classes;
+using DTS.Common.Converters;
+using System.ComponentModel;
+
+namespace DTS.Common.Interface.TestSetups
+{
+    [TypeConverter(typeof(EnumDescriptionTypeConverter))]
+    public enum Operations
+    {
+        [DescriptionResource("CalculatedChannel_Sum")]
+        SUM = 1,
+        [DescriptionResource("CalculatedChannel_Average")]
+        AVERAGE = 2,
+        [DescriptionResource("CalculatedChannel_IRTRACC3D_Thorax")]
+        IRTRACC3D = 3,
+        [DescriptionResource("CalculatedChannel_IRTRACC3D_Abdomen")]
+        IRTRACC3D_ABDOMEN = 4,
+        [DescriptionResource("CalculatedChannel_IRTRACC3D_LowerThorax")]
+        IRTRACC3D_LOWERTHORAX = 5,
+        [DescriptionResource("CalculatedChannel_Resultant")]
+        Resultant = 6,
+        [DescriptionResource("HIC")]
+        HIC = 7
+    }
+    /// <summary>
+    /// describes Calculated Channel record in the db
+    /// </summary>
+    public interface ICalculatedChannelRecord
+    {
+        string Name { get; set; }
+        string TestSetupName { get; set; }
+        /// <summary>
+        /// Database Id for record
+        /// </summary>
+        int Id { get; set; }
+        /// <summary>
+        /// operation to apply to input channels
+        /// </summary>
+        Operations Operation { get; set; }
+        /// <summary>
+        /// Single code (ISO or user) to associate with calculated channel
+        /// </summary>
+        string CalculatedValueCode { get; set; }
+        /// <summary>
+        /// CSV separated list of channel ids that are inputs for the calculation
+        /// </summary>
+        string[] InputChannelIds { get; set; }
+        /// <summary>
+        /// CFC to apply to input channels prior to calculation
+        /// </summary>
+        string CFCForInputChannels { get; set; }
+        /// <summary>
+        /// CFC to apply to output of calculation
+        /// </summary>
+        string ChannelFilterClassForOutput { get; set; }
+        /// <summary>
+        /// Database Id for test setup record
+        /// </summary>
+        int TestSetupId { get; set; }
+        /// <summary>
+        /// Whether channel can be viewed in realtime or not
+        /// </summary>
+        bool ViewInRealtime { get; set; }
+        /// <summary>
+        /// Clip length to apply to calculation if relevant
+        /// some calculations are a max over an clip for example
+        /// </summary>
+        int ClipLength { get; set; }
+    }
+}

Common/DTS.Common/Interface/TestSetups/IISFFile.cs

@@ -0,0 +1,203 @@
+using DTS.Common.Interface.Sensors;
+
+namespace DTS.Common.Interface.TestSetups
+{
+    public interface IISFFile
+    {
+        /// <summary>
+        /// RECORD_LENGTH bytes (80)
+        /// </summary>
+        char[] HeaderLine1 { get; set; }
+        /// <summary>
+        /// 8 characters, starting at character 7
+        /// </summary>
+        char[] TestSetupName { get; set; }
+        /// <summary>
+        /// starts at character 15, 5 characters long
+        /// </summary>
+        short NumberOfRecords { get; }
+        /// <summary>
+        /// 22 characters, starting at character 20
+        /// </summary>
+        char[] TestType { get; set; }
+        /// <summary>
+        /// 30 characters, starting at character 42
+        /// </summary>
+        char[] TestDivision { get; set; }
+        /// <summary>
+        /// 8 characters start at character 72, without .TCF extension
+        /// </summary>
+        char[] TCFile { get; set; }
+        /// <summary>
+        /// RECORD_LENGTH, we don't use anything from it currently...
+        /// </summary>
+        char[] HeaderLine2 { get; set; }
+        /// <summary>
+        /// RECORD_LENGTH, we don't use anything from it currently
+        /// </summary>
+        char[] HeaderLine3 { get; set; }
+
+        IISFSensorRecord[] Records { get; }
+        /// <summary>
+        /// adds a record, updates record count
+        /// </summary>
+        /// <param name="record"></param>
+        void AddRecord(IISFSensorRecord record);
+        void WriteToFile(string pathToFile);
+        void AddSensors(ISensorData[] sensors);
+    }
+
+    public interface IISFSensorRecord
+    {
+        /// <summary>
+        /// RECORD_LENGTH the whole first record
+        /// </summary>
+        char[] Record1 { get; set; }
+        /// <summary>
+        /// 2 characters, starting at character 75
+        /// </summary>
+        char[] Tag { get; set; }
+        /// <summary>
+        /// 5 characters start at character 7
+        /// </summary>
+        char[] DataChannelNumber { get; set; }
+        void SetDataChannelNumber(short value);
+
+        /// <summary>
+        /// 1 character, starting at character 15
+        /// </summary>
+        bool UserIdSensorIDIsNotSpecified { get; set; }
+
+        /// <summary>
+        /// 11 characters start at 19
+        /// </summary>
+        char[] CapacityCharacters { get; set; }
+        void SetCapacity(double capacity);
+        double GetCapacity();
+        /// <summary>
+        /// 12 characters, starting at 30
+        /// </summary>
+        char[] SerialNumber { get; set; }
+        /// <summary>
+        /// 11 characters, start at 42
+        /// is Sensitivity/1000 (V)
+        /// can also be c0 if polynomial
+        /// </summary>
+        char[] Sensitivity { get; set; }
+        void SetSensitivity(double sensitivity);
+        double GetSensitivity();
+        /// <summary>
+        /// 11 characters starting at 53
+        /// </summary>
+        char[] BridgeResistance { get; set; }
+
+        void SetBridgeResistance(double resistance);
+        /// <summary>
+        /// RECORD_LENGTH
+        /// </summary>
+        char[] Record2 { get; set; }
+        /// <summary>
+        /// 12 characters, starting at character 7 (of record 2)
+        /// </summary>
+        char[] EngineeringUnits { get; set; }
+        /// <summary>
+        /// 11 characters, starting at character 20
+        /// </summary>
+        char[] C1 { get; set; }
+        void SetC1(double c1);
+        double GetC1();
+        /// <summary>
+        /// 17 characters, starting at character 31
+        /// </summary>
+        char[] EID { get; set; }
+        /// <summary>
+        /// 4 characters, starting at 49
+        /// </summary>
+        char[] Unknown1 { get; set; }
+        /// <summary>
+        /// 2 characters, starting at 53
+        /// </summary>
+        char[] Unknown2 { get; set; }
+        /// <summary>
+        /// 11 characters starting at 55 (TOM ONLY [sensortype TI])
+        /// is /1000 of ordinary
+        /// </summary>
+        char[] FireDelay { get; set; }
+        /// <summary>
+        /// 8 characters, starting at 66
+        /// STANDARD is the default value, we don't really support anything else currently
+        /// </summary>
+        char[] TOMConfigurationName { get; set; }
+        /// <summary>
+        /// RECORD_LENGTH, third record of 4
+        /// </summary>
+        char[] Record3 { get; set; }
+        /// <summary>
+        /// 15 characters start at 14 of record 3
+        /// </summary>
+        char[] CommentPart1 { get; set; }
+        /// <summary>
+        /// 40 characters starting at 33
+        /// </summary>
+        char[] CommentPart2 { get; set; }
+        /// <summary>
+        /// RECORD_LENGTH, the 4th record of 4
+        /// </summary>
+        char[] Record4 { get; set; }
+        /// <summary>
+        /// 15 characters, starting at character 12
+        /// </summary>
+        char[] CommentPart3 { get; set; }
+        /// <summary>
+        /// sets CommentPart1, CommentPart2, CommentPart3
+        /// </summary>
+        /// <param name="s"></param>
+        void SetSensorComment(string s);
+        /// <summary>
+        /// 20 characters starting at 30
+        /// checked for digital inputs (should contain N/O or N/C)
+        /// </summary>
+        char[] SensorType { get; set; }
+        /// <summary>
+        /// 11 characters starting at 50
+        /// </summary>
+        char[] C2 { get; set; }
+        void SetC2(double c2);
+        /// <summary>
+        /// 11 characters starting at 61
+        /// notice for poly's we should be multiplying by 1000D?
+        /// calibration.Records.Records.First().Poly.SetCoefficient(0, calibration.Records.Records[0].Sensitivity / 1000.0D);
+        /// calibration.Records.Records.First().Poly.SetCoefficient(1, c1 / 1000.0D);
+        /// calibration.Records.Records.First().Poly.SetCoefficient(2, c2 / 1000.0D);
+        /// calibration.Records.Records.First().Poly.SetCoefficient(3, c3 / 1000.0D);
+        /// </summary>
+        char[] C3 { get; set; }
+        void SetC3(double c3);
+        /// <summary>
+        /// writes record to stream
+        /// </summary>
+        /// <param name="writer"></param>
+        void Write(System.IO.BinaryWriter writer);
+
+        void SetSensor(ISensorData sensor);
+    }
+
+    public abstract class ConstantsAndEnums
+    {
+        public const int RECORD_LENGTH = 80;
+        public enum ISFKnownChannelTypes
+        {
+            VS,
+            VU,
+            SB,
+            TI, //not analog (TOM)
+            TC, //not analog (TOM)
+            CT, //Digital
+            XP,
+            P4,
+            VF,
+            NB,
+            EX
+        }
+    }
+}

Common/DTS.Common/Interface/TestSetups/IROIPeriodChannelRecord.cs

@@ -0,0 +1,18 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace DTS.Common.Interface.TestSetups
+{
+    /// <summary>
+    /// Describes a record in the ROIPeriodChannels table
+    /// </summary>
+    public interface IROIPeriodChannelRecord
+    {
+        int TestSetupROIId { get; set; }
+        string ChannelName { get; set; }
+        long ChannelId { get; set; }
+    }
+}

Common/DTS.Common/Interface/TestSetups/ITestDASOrder.cs

@@ -0,0 +1,10 @@
+namespace DTS.Common.Interface.TestSetups
+{
+    /// <summary>
+    /// This interface allows DAS to be ordered within a test setup.
+    /// </summary>
+    public interface ITestDASOrder
+    {
+        int DASIndex { get; set; }
+    }
+}

Common/DTS.Common/Interface/TestSetups/ITestSetupHardwareRecord.cs

@@ -0,0 +1,18 @@
+using static DTS.Common.Enums.DASFactory.DFConstantsAndEnums;
+
+namespace DTS.Common.Interface.TestSetups
+{
+    /// <summary>
+    /// Interface describing records for test setup hardware
+    /// </summary>
+    public interface ITestSetupHardwareRecord
+    {
+        int DASId { get; set; }
+        int TestSetupId { get; set; }
+        bool AddDAS { get; set; }
+        int SamplesPerSecond { get; set; }
+        bool IsClockMaster { get; set; }
+        int AntiAliasFilterRate { get; set; }
+        byte PTPDomainId { get; set; }
+    }
+}

Common/DTS.Common/Interface/TestSetups/ITestSetupROIRecord.cs

@@ -0,0 +1,22 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace DTS.Common.Interface.TestSetups
+{
+    /// <summary>
+    /// Describes a record in the TestSetupROIs table
+    /// </summary>
+    public interface ITestSetupROIRecord
+    {
+        int TestSetupROIId { get; set; }
+        int TestSetupId { get; set; }
+        string Suffix { get; set; }
+        double ROIStart { get; set; }
+        double ROIEnd { get; set; }
+        bool IsEnabled { get; set; }
+        bool IsDefault { get; set; }
+    }
+}

Common/DTS.Common/Interface/TestSetups/ITestSetupsView.cs

@@ -0,0 +1,8 @@
+using DTS.Common.Base;
+
+namespace DTS.Common.Interface
+{
+    public interface ITestSetupsView:IBaseView
+    {
+    }
+}

Common/DTS.Common/Interface/TestSetups/ITestSetupsViewModel.cs

@@ -0,0 +1,8 @@
+using DTS.Common.Base;
+
+namespace DTS.Common.Interface
+{
+    public interface ITestSetupsViewModel:IBaseViewModel
+    {
+    }
+}

Common/DTS.Common/Interface/TestSetups/Imports/TTS/AnalogChannels/IAnalogChannelsView.cs

@@ -0,0 +1,6 @@
+using DTS.Common.Base;
+
+namespace DTS.Common.Interface.TestSetups.Imports.TTS
+{
+    public interface IAnalogChannelsView : IBaseView { }
+}

Common/DTS.Common/Interface/TestSetups/Imports/TTS/AnalogChannels/IAnalogChannelsViewModel.cs

@@ -0,0 +1,10 @@
+using DTS.Common.Base;
+
+namespace DTS.Common.Interface.TestSetups.Imports.TTS
+{
+    public interface IAnalogChannelsViewModel : IBaseViewModel
+    {
+        IAnalogChannelsView View { get; set; }
+        string Validate();
+    }
+}

Common/DTS.Common/Interface/TestSetups/Imports/TTS/DIChannels/IDigitalInputChannelsView.cs

@@ -0,0 +1,6 @@
+using DTS.Common.Base;
+
+namespace DTS.Common.Interface.TestSetups.Imports.TTS.DIChannels
+{
+    public interface IDigitalInputChannelsView : IBaseView { }
+}

Common/DTS.Common/Interface/TestSetups/Imports/TTS/DIChannels/IDigitalInputChannelsViewModel.cs

@@ -0,0 +1,9 @@
+using DTS.Common.Base;
+
+namespace DTS.Common.Interface.TestSetups.Imports.TTS.DIChannels
+{
+    public interface IDigitalInputChannelsViewModel : IBaseViewModel
+    {
+        IDigitalInputChannelsView View { get; set; }
+    }
+}

Common/DTS.Common/Interface/TestSetups/Imports/TTS/DOChannels/IDigitalOutputChannelsView.cs

@@ -0,0 +1,6 @@
+using DTS.Common.Base;
+
+namespace DTS.Common.Interface.TestSetups.Imports.TTS.DOChannels
+{
+    public interface IDigitalOutputChannelsView : IBaseView { }
+}

Common/DTS.Common/Interface/TestSetups/Imports/TTS/DOChannels/IDigitalOutputChannelsViewModel.cs

@@ -0,0 +1,9 @@
+using DTS.Common.Base;
+
+namespace DTS.Common.Interface.TestSetups.Imports.TTS.DOChannels
+{
+    public interface IDigitalOutputChannelsViewModel : IBaseViewModel
+    {
+        IDigitalOutputChannelsView View { get; set; }
+    }
+}

Common/DTS.Common/Interface/TestSetups/Imports/TTS/EditFile/IEditFileView.cs

@@ -0,0 +1,6 @@
+using DTS.Common.Base;
+
+namespace DTS.Common.Interface.TestSetups.Imports.TTS
+{
+    public interface IEditFileView : IBaseView { }
+}

Common/DTS.Common/Interface/TestSetups/Imports/TTS/EditFile/IEditFileViewModel.cs

@@ -0,0 +1,29 @@
+using DTS.Common.Base;
+using DTS.Common.Interface.TestSetups.Imports.TTS.ReadFile;
+
+namespace DTS.Common.Interface.TestSetups.Imports.TTS
+{
+    public interface IEditFileViewModel : IBaseViewModel
+    {
+        IEditFileView View { get; set; }
+        bool Validate();
+        /// <summary>
+        /// validates changes on page
+        /// if record is passed in, also makes sure there are no
+        /// RequiredChannels with identical channel codes
+        /// </summary>
+        /// <param name="record">null, or record being changed</param>
+        /// <returns></returns>
+        bool ValidateChange(ITTSChannelRecord record = null);
+        bool ChangeValidationIsNeeded { get; set; }
+        /// <summary>
+        /// Initializes components in View UI
+        /// </summary>
+        void InitializeView();
+        /// <summary>
+        /// filters the available sensors by the given text
+        /// </summary>
+        /// <param name="text"></param>
+        void Search(string text);
+    }
+}

Common/DTS.Common/Interface/TestSetups/Imports/TTS/HardwareScan/IChannelSummary.cs

@@ -0,0 +1,12 @@
+using DTS.Common.Base;
+
+namespace DTS.Common.Interface
+{
+    public interface IChannelSummary : IBaseClass
+    {
+        string ChannelType { get; set; }
+        int Requested { get; set; }
+        int Assigned { get; set; }
+        int Unassigned { get; set; }
+    }
+}

Common/DTS.Common/Interface/TestSetups/Imports/TTS/HardwareScan/IDasSummary.cs

@@ -0,0 +1,14 @@
+using DTS.Common.Base;
+
+namespace DTS.Common.Interface
+{
+    public interface IDasSummary : IBaseClass
+    {
+        string DASSerial { get; set; }
+        string EIDFound { get; set; }
+        string BatteryVoltageStatus { get; set; }
+        System.Windows.Media.SolidColorBrush BatteryVoltageColor { get; set; }
+        string InputVoltageStatus { get; set; }
+        System.Windows.Media.SolidColorBrush InputVoltageColor { get; set; }
+    }
+}

Common/DTS.Common/Interface/TestSetups/Imports/TTS/HardwareScan/IHardwareScanView.cs

@@ -0,0 +1,6 @@
+using DTS.Common.Base;
+
+namespace DTS.Common.Interface
+{
+    public interface IHardwareScanView : IBaseView { }
+}

Common/DTS.Common/Interface/TestSetups/Imports/TTS/HardwareScan/IHardwareScanViewModel.cs

@@ -0,0 +1,25 @@
+using System.Collections.Generic;
+using DTS.Common.Base;
+using DTS.Common.Interface.TestSetups.Imports.TTS.HardwareScan;
+using DTS.Common.Interface.TestSetups.Imports.TTS.ReadFile;
+using DTS.Common.Utils;
+
+namespace DTS.Common.Interface
+{
+    public interface IHardwareScanViewModel : IBaseViewModel
+    {
+        IHardwareScanView View { get; set; }
+
+        IHardwareSummaryRecord[] HardwareRecords { get; }
+
+        void SetStatus(string status);
+        void SetProgress(double progress);
+        void HardwareScan();
+        void SetChannelSummaryList(ITTSChannelRecord[] channelRecords);
+    }
+
+    /// <summary>
+    /// delegate to scan hardware
+    /// </summary>
+    public delegate void HardwareScanDelegate();
+}

Common/DTS.Common/Interface/TestSetups/Imports/TTS/HardwareScan/IHardwareSummaryRecord.cs

@@ -0,0 +1,21 @@
+namespace DTS.Common.Interface.TestSetups.Imports.TTS.HardwareScan
+{
+    public interface IHardwareSummaryRecord
+    {
+        uint DOut { get; set; }
+        uint DIn { get; set; }
+        uint Squib { get; set; }
+        uint Analog { get; set; }
+        uint Total { get; }
+        uint SPS { get; set; }
+        uint SPD { get; set; }
+        uint SPT { get; set; }
+        uint ECM { get; set; }
+        uint Rack { get; set; }
+        uint G5 { get; set; }
+        void UpdateTotal();
+
+        void Update(uint analog, uint squib, uint din, uint dout, uint ecm, uint sps, uint spt, uint spd, uint g5,
+            uint rack);
+    }
+}

Common/DTS.Common/Interface/TestSetups/Imports/TTS/LevelTrigger/ILevelTrigger.cs

@@ -0,0 +1,40 @@
+using DTS.Common.Interface.TestSetups.Imports.TTS.ReadFile;
+
+namespace DTS.Common.Interface.TestSetups.Imports.TTS.LevelTrigger
+{
+    public interface ILevelTrigger
+    {
+        string Code { get; }
+        string JCode { get; }
+        double ValuePercent { get; set; }
+        double ValueEU { get; set; }
+        string EULabel { get; }
+        string HWSerialNumber { get; }
+        int ChannelNumber { get; }
+        ITTSChannelRecord Channel { get; set; }
+        ITTSSetup TestSetup { get; }
+        ITTSChannelRecord[] AvailableChannels { get; }
+        bool IsActive { get; }
+        /// <summary>
+        /// updates available channels and Channel
+        /// </summary>
+        void Refresh();
+        /// <summary>
+        /// adds the channel as a possible channel for level trigger
+        /// </summary>
+        /// <param name="channel"></param>
+        void Add(ITTSChannelRecord channel);
+        /// <summary>
+        /// removes the channel as a possible channel for level trigger,
+        /// unassigns channel if currently assigned
+        /// </summary>
+        /// <param name="channel"></param>
+        void Remove(ITTSChannelRecord channel);
+        bool IsModified { get; set; }
+        /// <summary>
+        /// returns a sequence of bytes representing this level trigger suitable to base a hash on
+        /// </summary>
+        /// <returns></returns>
+        byte[] GetBytes();
+    }
+}

Common/DTS.Common/Interface/TestSetups/Imports/TTS/LevelTrigger/ILevelTriggerView.cs

@@ -0,0 +1,6 @@
+using DTS.Common.Base;
+
+namespace DTS.Common.Interface
+{
+    public interface ILevelTriggerView : IBaseView { }
+}

Common/DTS.Common/Interface/TestSetups/Imports/TTS/LevelTrigger/ILevelTriggerViewModel.cs

@@ -0,0 +1,12 @@
+using System.Collections.Generic;
+using DTS.Common.Base;
+using DTS.Common.Utils;
+
+namespace DTS.Common.Interface
+{
+    public interface ILevelTriggerViewModel : IBaseViewModel
+    {
+        ILevelTriggerView View { get; set; }
+    }
+
+}

Common/DTS.Common/Interface/TestSetups/Imports/TTS/ReadFile/IReadFileView.cs

@@ -0,0 +1,6 @@
+using DTS.Common.Base;
+
+namespace DTS.Common.Interface
+{
+    public interface IReadFileView : IBaseView { }
+}

Common/DTS.Common/Interface/TestSetups/Imports/TTS/ReadFile/IReadFileViewModel.cs

@@ -0,0 +1,23 @@
+using DTS.Common.Base;
+using DTS.Common.Enums;
+using DTS.Common.Interface.Sensors;
+
+namespace DTS.Common.Interface
+{
+    public interface IReadFileViewModel : IBaseViewModel
+    {
+        IReadFileView View { get; set; }
+        void SetStatus(string status);
+        void SetStatus(string status, string error);
+        void SetProgress(double progress);
+        string FileToImport { get; set; }
+        void ReadFile(string fileName, double defaultSampleRate, RecordingModes defaultMode, double defaultTTSPreTrigger, double defaultTTSPostTrigger,
+            double defaultTTSROIStart, double defaultTTSROIEnd, bool defaultRequireEIDFound, string defaultDigitalInputMode, ISquibSettingDefaults squibDefaults);
+    }
+
+    /// <summary>
+    /// delegate to read a TTS import file
+    /// </summary>
+    /// <param name="importFile">file to be used for import</param>
+    public delegate void ReadFileDelegate(string importFile);
+}

Common/DTS.Common/Interface/TestSetups/Imports/TTS/ReadFile/ITTSChannelRecord.cs

@@ -0,0 +1,129 @@
+using System.Windows;
+using DTS.Common.Base;
+using DTS.Common.Enums;
+using DTS.Common.Enums.TTS;
+using DTS.Common.Interface.DataRecorders;
+
+namespace DTS.Common.Interface.TestSetups.Imports.TTS.ReadFile
+{
+    /// <summary>
+    /// represents a single record in a TTS Import
+    /// </summary>
+    public interface ITTSChannelRecord : IBaseClass
+    {
+        int ChannelNumber { get; set; }
+        string ChannelCode { get; set; }
+        string JCodeOrDescription { get; set; }
+        double ChannelRange { get; set; }
+        int ChannelFilterHz { get; set; }
+        string SensorEID { get; set; }
+        string SensorSerialNumber { get; set; }
+        double SensorSensitivity { get; set; }
+        double SensorExcitationVolts { get; set; }
+        double SensorCapacity { get; set; }
+        string SensorEU { get; set; }
+        bool SensorPolarity { get; set; }
+        ToyotaBridgeType ChannelType { get; set; }
+        string Description { get; set; }
+        bool ProportionalToExcitation { get; set; }
+        double BridgeResistance { get; set; }
+        double InitialOffsetVoltage { get; set; }
+        double InitialOffsetVoltageTolerance { get; set; }
+        bool RemoveOffset { get; set; }
+        ToyotaZeroMethods ZeroMethod { get; set; }
+        double CableMultiplier { get; set; }
+        double InitialEUInMV { get; set; }
+        double InitialEUInEU { get; set; }
+        double IRTraccExponent { get; set; }
+        double PolynomialConstant { get; set; }
+        double PolynomialCoefficientC { get; set; }
+        double PolynomialCoefficentB { get; set; }
+        double PolynomialCoefficientA { get; set; }
+        double PolynomialCoefficientAlpha { get; set; }
+        string ISOCode { get; set; }
+        string ISODescription { get; set; }
+        string ISOPolarity { get; set; }
+        bool IsSquib { get; set; }
+        bool IsDigitalInput { get; set; }
+        bool IsDigitalOutput { get; set; }
+        /// <summary>
+        /// returns true if the record is empty (no channel code and no sensor serial number)
+        /// </summary>
+        bool IsEmptyRecord { get; }
+        IHardwareChannel HardwareChannel { get; set; }
+        /// <summary>
+        /// returns whether the channelcode is valid or not
+        /// </summary>
+        bool IsChannelCodeValid { get; set; }
+        bool IsJCodeValid { get; set; }
+        bool IsRangeValid { get; set; }
+        bool IsFilterValid { get; set; }
+        /// <summary>
+        /// disabled channels are channels which are in the test setup, but aren't used during run test
+        /// </summary>
+        bool Disabled { get; set; }
+        /// <summary>
+        /// for squibs, what firemode to use
+        /// </summary>
+        SquibFireMode SquibFireMode { get; set; }
+        /// <summary>
+        /// the delay in ms between trigger and squib fire
+        /// </summary>
+        double SquibFireDelayMs { get; set; }
+        /// <summary>
+        /// whether to limit the duration or not of squib fire
+        /// </summary>
+        bool LimitDuration { get; set; }
+        /// <summary>
+        /// the duration of the squib fire in ms from the start of firing
+        /// (if limiting duration)
+        /// </summary>
+        double SquibFireDurationMs { get; set; }
+        /// <summary>
+        /// the limit for current (amps)
+        /// </summary>
+        double SquibFireCurrent { get; set; }
+        /// <summary>
+        /// the squib resistance tolerance low value (ohms)
+        /// </summary>
+        double SquibFireResistanceLowOhm { get; set; }
+        /// <summary>
+        /// the squib resistance tolerance high value (ohms)
+        /// </summary>
+        double SquibFireResistanceHighOhm { get; set; }
+        /// <summary>
+        /// the digital input mode (if relevant)
+        /// </summary>
+        DigitalInputModes DigitalInputMode { get; set; }
+        /// <summary>
+        /// the digital output mode (if relevant)
+        /// </summary>
+        DigitalOutputModes DigitalOutputMode { get; set; }
+        /// <summary>
+        /// the delay between trigger and output (if relevant)
+        /// </summary>
+        double DigitalOutputDelay { get; set; }
+        /// <summary>
+        /// the duration of output after output started (if relevant)
+        /// </summary>
+        double DigitalOutputDuration { get; set; }
+        IEditFileViewModel Parent { get; set; }
+        //bool ValidationNeeded { get; set; }
+        ITTSChannelRecord Copy();
+        Visibility RangeVisible { get; }
+        Visibility FilterVisible { get; }
+        bool OriginallyRequestedChannel { get; set; }
+        /// <summary>
+        /// controls whether the channel should be marked as diagnostics mode or not
+        /// note that diagnostics mode is only used when the configuration supports diagnostics mode
+        /// even if the sensor has diagnosticsmode set to true
+        /// </summary>
+        bool DiagnosticsMode { get; set; }
+        bool IsModified { get; set; }
+        /// <summary>
+        /// returns an array of bytes to represent the channel, for use in CRC and hashing
+        /// </summary>
+        /// <returns>array of bytes representing the channel</returns>
+        byte[] GetBytes();
+    }
+}

Common/DTS.Common/Interface/TestSetups/Imports/TTS/ReadFile/ITTSSetup.cs

@@ -0,0 +1,65 @@
+using DTS.Common.Enums;
+using DTS.Common.Interface.TestSetups.Imports.TTS.LevelTrigger;
+using System;
+
+namespace DTS.Common.Interface.TestSetups.Imports.TTS.ReadFile
+{
+    public interface ITTSSetup
+    {
+        string Filename { get; set; }
+        string TestId { get; set; }
+        /// <summary>
+        /// The first 4 lines of the .csv file which may be needed to create a new .csv file in Edit File
+        /// </summary>
+        string Line1 { get; set; }
+        string Line2 { get; set; }
+        string Line3 { get; set; }
+        string Line4 { get; set; }
+        string[] DummyList { get; set; }
+        double SampleRate { get; set; }
+        RecordingModes Mode { get; set; }
+        double TestLength { get; }
+        double PreTrigger { get; set; }
+        double PostTrigger { get; set; }
+        double ROIStart { get; set; }
+        double ROIEnd { get; set; }
+        ITTSChannelRecord[] Channels { get; set; }
+        ILevelTrigger[] LevelTriggers { get; set; }
+        string OriginalImportFile { get; set; }
+        /// <summary>
+        /// The global default setting for Test Setups.
+        /// If True, HybridRecorder is added to CircularBuffer and Recorder.
+        /// </summary>
+        bool AllowAdvancedRecordingModes { get; set; }
+        /// <summary>
+        /// the global default setting for Test Setups
+        /// if true Active Ram and Active Ram Multiple Events recording modes
+        /// are allowed
+        /// http://manuscript.dts.local/f/cases/31841/Add-support-for-Active-RAM-mode
+        /// </summary>
+        bool AllowActiveRecordingModes { get; set; }
+        bool AllowTSRAIRRecordingModes { get; set; }
+        /// <summary>
+        /// allows consumers to specify whether EIDs must be found for sensors to be used
+        /// </summary>
+        bool RequireEIDFound { get; set; }
+        /// <summary>
+        /// The value from DataPRO.config.exe
+        /// </summary>
+        string DefaultDigitalInputMode { get; set; }
+        /// <summary>
+        /// The value from DataPRO.config.exe
+        /// </summary>
+        double DefaultSquibFireDurationMs { get; set; }
+        string GetHashCode();
+        /// <summary>
+        /// Holds sensors that should be assigned to hardware channels
+        /// this can only happen through the XML import, where hardware and sensors are already assigned
+        /// these persist until the assignment is made
+        /// once the assignment has been made it's no longer necessary to remember the assignment since it has already been made
+        /// this is necessary because readfile for the xml import happens before hardware is scanned
+        /// and the hardware scan might not find all hardware
+        /// </summary>
+        Tuple<string, string>[] PreAssignedSensorIdAndHwId { get; set; }
+    }
+}

Common/DTS.Common/Interface/TestSetups/Imports/TTS/Summary/ISummaryChannel.cs

@@ -0,0 +1,11 @@
+using DTS.Common.Base;
+
+namespace DTS.Common.Interface
+{
+    public interface ISummaryChannel : IBaseClass
+    {
+        string ChannelType { get; set; }
+        int Assigned { get; set; }
+        string Unassigned { get; set; }
+    }
+}

Common/DTS.Common/Interface/TestSetups/Imports/TTS/Summary/ISummaryView.cs

@@ -0,0 +1,11 @@
+using DTS.Common.Base;
+
+namespace DTS.Common.Interface
+{
+    public interface ISummaryView : IBaseView
+    {
+        void UpdateTestIds(string[] serializedValues);
+        string GetTestId();
+        void SetTestName(string testName);
+    }
+}

Common/DTS.Common/Interface/TestSetups/Imports/TTS/Summary/ISummaryViewModel.cs

@@ -0,0 +1,28 @@
+using System.Collections.Generic;
+using DTS.Common.Base;
+using DTS.Common.Enums;
+using DTS.Common.Interface.TestSetups.Imports.TTS.ReadFile;
+
+namespace DTS.Common.Interface
+{
+    public interface ISummaryViewModel : IBaseViewModel
+    {
+        ISummaryView View { get; set; }
+        void SetStatus(string status, string error = default(string));
+        void SetProgress(double progress);
+        bool TestSetupComplete { get; set; }
+        string ImportFileName { get; }
+        string TestSetupName { get; }
+        double SampleRate { get; }
+        RecordingModes RecordingMode { get; }
+        string PreTrigger { get; }
+        string PostTrigger { get; }
+        void SetChannelList();
+        void UpdateUI();
+        void SetSerializedTestIdValues(string[] values);
+        void SetAvailableSampleRates(int[] values);
+
+        string GetTestId();
+        void SetAAFExceptions(Dictionary<double, List<double>> values);
+    }
+}

Common/DTS.Common/Interface/TestSetups/Imports/TTS/TOMChannels/ITOMChannelsView.cs

@@ -0,0 +1,6 @@
+using DTS.Common.Base;
+
+namespace DTS.Common.Interface.TestSetups.Imports.TTS
+{
+    public interface ITOMChannelsView : IBaseView { }
+}

Common/DTS.Common/Interface/TestSetups/Imports/TTS/TOMChannels/ITOMChannelsViewModel.cs

@@ -0,0 +1,9 @@
+using DTS.Common.Base;
+
+namespace DTS.Common.Interface.TestSetups.Imports.TTS
+{
+    public interface ITOMChannelsViewModel : IBaseViewModel
+    {
+        ITOMChannelsView View { get; set; }
+    }
+}

Common/DTS.Common/Interface/TestSetups/TestSetupsList/ITestSetup.cs

@@ -0,0 +1,54 @@
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Windows;
+using DTS.Common.Interface.Channels;
+using DTS.Common.Interface.DataRecorders;
+using DTS.Common.Interface.Groups.GroupList;
+using DTS.Common.Interface.Sensors;
+
+namespace DTS.Common.Interface.TestSetups.TestSetupsList
+{
+    public interface ITestSetup : ITestSetupRecord
+    {
+        void AddGroup(IGroup group, IDictionary<int, ISensorData> sensorLookup, IDictionary<long, IGroupChannel> channelLookup);
+        Dictionary<IGroup, IGroupChannel[]> ChannelsForGroup { get; set; }
+        Dictionary<string, bool> DASClockMasterList { get; set; }
+        Dictionary<string, double> DASSampleRateList { get; set; }
+        Dictionary<string, float> DASAAFRateList { get; set; }
+        Dictionary<string, List<string>> EncapsulatedDASList { get; set; }
+        //returns rate for das, if doesn't currently have a rate uses default value
+        double GetSampleRate(string dasSerialNumber, double defaultValue);
+        bool Filter(string term);
+        Visibility TooltipVisibility { get; }
+        string TooltipMessage { get; }
+        string CompletionErrorMessage { get; }
+
+        ObservableCollection<IGroup> Groups { get; set; }
+        void AddGroup(IGroup group, IDictionary<int, ISensorData> sensorLookup, IDictionary<int, IDASHardware> hardwareLookup, IChannelSetting[] channelDefaults);
+
+        /// <summary>
+        /// explicitly adds hardware to test, regardless of what hardware is
+        /// included through groups
+        /// </summary>
+        int[] AddedHardware { get; set; }
+        /// <summary>
+        /// explicitly removes hardware from test, regardless of what hardware was included through groups
+        /// </summary>
+        int[] RemovedHardware { get; set; }
+
+        int[] GetAllIncludedHardware();
+
+        void AddHardware(int dasId, string dasSerialNumber, IDASHardware[] allHardware, IDictionary<int, IDASHardware> lookup);
+        void AddHardware(int dasId, IDictionary<int, IDASHardware> lookup);
+        void RemoveHardware(int dasId, IDASHardware[] allHardware, IDictionary<int, IDASHardware> lookup);
+        void SaveGroups();
+        void SaveHardware();
+        void RemoveGroup(IGroup group);
+        void MoveGroupUp(IGroup group);
+        void MoveGroupDown(IGroup group);
+        void MoveGroupToDisplayOrder(IGroup group, int displayOrder);
+
+        List<IGroupChannel> GetChannels();
+        void SetTestSetupChannelOrder();
+    }
+}

Common/DTS.Common/Interface/TestSetups/TestSetupsList/ITestSetupRecord.cs

@@ -0,0 +1,321 @@
+using DTS.Common.Enums;
+using DTS.Common.Enums.DASFactory;
+using DTS.Common.Enums.Sensors;
+using DTS.Common.Enums.Viewer;
+using DTS.Common.Interface.ISO.ExtraProperties;
+using DTS.Common.Interface.RegionOfInterest;
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+
+namespace DTS.Common.Interface.TestSetups.TestSetupsList
+{
+    /// <summary>
+    /// Describes a test setup record in the database
+    /// </summary>
+    public interface ITestSetupRecord
+    {
+        /// <summary>
+        /// does a deep copy of provided test setup
+        /// </summary>
+        /// <param name="copy">source record to copy</param>
+        void Copy(ITestSetupRecord copy);
+        /// <summary>
+        /// Database Id of test setup
+        /// </summary>
+        int Id { get; set; }
+        /// <summary>
+        /// Name of test setup
+        /// </summary>
+        string Name { get; set; }
+        /// <summary>
+        /// Description of test setup
+        /// </summary>
+        string Description { get; set; }
+        /// <summary>
+        /// whether test execution should progress automatically
+        /// </summary>
+        bool AutomaticProgression { get; set; }
+        /// <summary>
+        /// delay between steps when using automatic progression
+        /// </summary>
+        int AutomaticProgressionDelayMS { get; set; }
+        /// <summary>
+        /// whether the trigger polarity should be switched from close to open
+        /// </summary>
+        bool InvertTriggerCompletion { get; set; }
+        /// <summary>
+        /// whether the start polarity should be switched from close to open
+        /// </summary>
+        bool InvertStartRecordCompletion { get; set; }
+        /// <summary>
+        /// Whether or not a shorted start should be ignored
+        /// </summary>
+        bool IgnoreShortedStartCompletion { get; set; }
+        /// <summary>
+        /// Whether or not a shorted trigger should be ignored
+        /// </summary>
+        bool IgnoreShortedTriggerCompletion { get; set; }
+        /// <summary>
+        /// Whether diagnostics should be a viewable step when executing test
+        /// </summary>
+        bool ViewDiagnostics { get; set; }
+        /// <summary>
+        /// whether verify channels should be a viewable step when executing test
+        /// </summary>
+        bool VerifyChannels { get; set; }
+
+        bool AutoVerifyChannels { get; set; }
+        double AutoVerifyDelaySeconds { get; set; }
+        /// <summary>
+        /// overall recording mode of test
+        /// Some DAS may not support the actual recording mode but may support a related recording
+        /// mode (example circular buffer + UART versus circular buffer)
+        /// </summary>
+        RecordingModes RecordingMode { get; set; }
+        /// <summary>
+        /// samples per second for test as overall value
+        /// Each DAS can have it's own rate so this is mostly just to control the rate for new das added to a test
+        /// </summary>
+        double SamplesPerSecondAggregate { get; set; }
+        /// <summary>
+        /// amount of data pre trigger that is requested in seconds
+        /// </summary>
+        double PreTriggerSeconds { get; set; }
+        /// <summary>
+        /// amount of data post trigger that is requested in seconds
+        /// </summary>
+        double PostTriggerSeconds { get; set; }
+        /// <summary>
+        /// number of events to record if recording mode supports multiple events
+        /// </summary>
+        int NumberOfEvents { get; set; }
+        /// <summary>
+        /// whether all channels are required to pass diagnostics for test execution
+        /// </summary>
+        bool StrictDiagnostics { get; set; }
+        /// <summary>
+        /// whether user confirmation is required on diagnostic errors discovered before
+        /// test execution continues
+        /// </summary>
+        bool RequireUserConfirmationOnErrors { get; set; }
+        /// <summary>
+        /// whether to perform a Region of Interest (ROI) download as a unique step of test execution
+        /// </summary>
+        bool DoROIDownload { get; set; }
+        /// <summary>
+        /// whether to include viewing region of interest (ROI) as a step of test execution
+        /// </summary>
+        bool ViewROIDownload { get; set; }
+        /// <summary>
+        /// whether to include downloading all available data as a step of test execution
+        /// </summary>
+        bool DownloadAll { get; set; }
+        /// <summary>
+        /// whether to include real time as a step of test execution
+        /// </summary>
+        bool ViewRealtime { get; set; }
+        /// <summary>
+        /// the number of plots to show in real time if viewing real time
+        /// </summary>
+        short DefaultNumberRealtimeGraphs { get; set; }
+        BindingList<IRegionOfInterest> RegionsOfInterest { get; set; }
+        /// <summary>
+        /// the start of the region of interest (deprecated?)
+        /// </summary>
+        double ROIStart { get; set; }
+        /// <summary>
+        /// the end of the region of interest (deprecated?)
+        /// </summary>
+        double ROIEnd { get; set; }
+        /// <summary>
+        /// whether to include viewing of all download data as a step of test execution
+        /// </summary>
+        bool ViewDownloadAll { get; set; }
+        /// <summary>
+        /// whether to include export as a step of test execution
+        /// </summary>
+        bool ViewExport { get; set; }
+        /// <summary>
+        /// Bit mask of export formats to select in export step by default
+        /// </summary>
+        SupportedExportFormatBitFlags ExportFormats { get; set; }
+        string LabDetails { get; set; }
+        /// <summary>
+        /// Whether lab details should be included as a part of test execution
+        /// </summary>
+        bool UseLabratoryDetails { get; set; }
+        string CustomerDetails { get; set; }
+        /// <summary>
+        /// Whether customer details should be included as a part of test execution
+        /// </summary>
+        bool UseCustomerDetails { get; set; }
+        /// <summary>
+        /// Whether to allow test execution to continue when sensors in test are missing
+        /// </summary>
+        bool AllowMissingSensors { get; set; }
+        /// <summary>
+        /// whether a sensor with an ID is allowed to be assigned on a channel if the Id
+        /// was not found on that channel
+        /// </summary>
+        bool AllowSensorIdToBlankChannel { get; set; }
+        CalibrationBehaviors CalibrationBehavior { get; set; }
+        /// <summary>
+        /// whether test setup record should be synchronized with central server
+        /// (deprecated)
+        /// </summary>
+        bool LocalOnly { get; set; }
+        /// <summary>
+        /// when test setup was last modified
+        /// </summary>
+        DateTime LastModified { get; set; }
+        /// <summary>
+        /// who last modified test setup
+        /// </summary>
+        string LastModifiedBy { get; set; }
+        bool TurnOffExcitation { get; set; }
+        /// <summary>
+        /// whether to use EU levels to "trigger" channels in realtime viewer
+        /// </summary>
+        bool TriggerCheckRealtime { get; set; }
+        /// <summary>
+        /// Whether to include trigger check as a step in test execution
+        /// </summary>
+        bool TriggerCheckStep { get; set; }
+        /// <summary>
+        /// whether to include post test diagnostics as a step in test execution
+        /// </summary>
+        bool PostTestDiagnosticsLevel { get; set; }
+
+        /// <summary>
+        /// whether there's an expectation that there is a common status line between all DAS
+        /// in test.
+        /// </summary>
+        bool CommonStatusLine { get; set; }
+        bool SameAsDownloadFolder { get; set; }
+        /// <summary>
+        /// whether to include upload data as a step 
+        /// </summary>
+        bool UploadData { get; set; }
+        /// <summary>
+        /// folder to upload data to
+        /// [legacy, superseded by upload ini file]
+        /// </summary>
+        string UploadFolder { get; set; }
+        /// <summary>
+        /// whether to upload only export data files when uploading files
+        /// </summary>
+        bool UploadExportsOnly { get; set; }
+        string Settings { get; set; }
+        bool WarnOnFailedBattery { get; set; }
+        /// <summary>
+        /// whether test setup completion has been calculated yet or not
+        /// If dirty is true it has not been calculated and needs to be
+        /// </summary>
+        bool Dirty { get; set; }
+        /// <summary>
+        /// whether the test setup is complete and ready to run
+        /// [dependent on Dirty]
+        /// </summary>
+        bool IsComplete { get; set; }
+        /// <summary>
+        /// any warnings or errors known in test setup, stored to avoid needing to calculate when retrieving all setups
+        /// </summary>
+        string ErrorMessage { get; set; }
+        string TestEngineerDetails { get; set; }
+        /// <summary>
+        /// whether to use test engineer details in test execution
+        /// </summary>
+        bool UseTestEngineerDetails { get; set; }
+        byte[] TagsBlobBytes { get; set; }
+        /// <summary>
+        /// whether units in the test should be auto armed
+        /// </summary>
+        bool DoAutoArm { get; set; }
+        bool DoEnableRepeat { get; set; }
+        /// <summary>
+        /// Whether test is a checkout test
+        /// this has multiple internal meanings including whether strict diagnostics are used or not, whether data
+        /// should be collected from sensors or not, etc
+        /// this should generally be false
+        /// </summary>
+        bool CheckoutMode { get; set; }
+        /// <summary>
+        /// Instrumentation Setup File used to create test setup, if relevant
+        /// </summary>
+        string ISFFile { get; set; }
+        bool QuitTestWithoutWarning { get; set; }
+        bool NotAllChannelsRealTime { get; set; }
+        bool NotAllChannelsViewer { get; set; }
+        bool SuppressMissingSensorsWarning { get; set; }
+        bool DoStreaming { get; set; }
+        ClockSyncProfile ClockSyncProfileMaster { get; set; }
+        ClockSyncProfile ClockSyncProfileSlave { get; set; }
+        List<IExtraProperty> ExtraProperties { get; set; }
+        bool MeasureSquibResistancesStep { get; set; }
+        string TestSetupUniqueId { get; set; }
+
+        bool LowgLevelTriggerOn { get; set; }
+        bool LowgLevelTriggerOnX { get; set; }
+        bool LowgLevelTriggerOnY { get; set; }
+        bool LowgLevelTriggerOnZ { get; set; }
+        bool HighgLevelTriggerOn { get; set; }
+
+        bool HighgLevelTriggerOnX { get; set; }
+        bool HighgLevelTriggerOnY { get; set; }
+        bool HighgLevelTriggerOnZ { get; set; }
+        bool AngularAccelLevelTriggerOn { get; set; }
+        bool AngularAccelLevelTriggerOnX { get; set; }
+        bool AngularAccelLevelTriggerOnY { get; set; }
+        bool AngularAccelLevelTriggerOnZ { get; set; }
+        bool AngularRateLevelTriggerOn { get; set; }
+        bool AngularRateLevelTriggerOnX { get; set; }
+        bool AngularRateLevelTriggerOnY { get; set; }
+        bool AngularRateLevelTriggerOnZ { get; set; }
+        double LowgLinearLevelTriggerX { get; set; }
+        double LowgLinearLevelTriggerY { get; set; }
+        double LowgLinearLevelTriggerZ { get; set; }
+        double HighgLinearLevelTriggerX { get; set; }
+        double HighgLinearLevelTriggerY { get; set; }
+        double HighgLinearLevelTriggerZ { get; set; }
+        double AngularRateLevelTriggerX { get; set; }
+        double AngularRateLevelTriggerY { get; set; }
+        double AngularRateLevelTriggerZ { get; set; }
+        double AngularAccelLevelTriggerX { get; set; }
+        double AngularAccelLevelTriggerY { get; set; }
+        double AngularAccelLevelTriggerZ { get; set; }
+        bool HumidityLevelTriggerOn { get; set; }
+        bool PressureLevelTriggerOn { get; set; }
+        bool TemperatureLevelTriggerOn { get; set; }
+        double HumidityLevelTriggerBelow { get; set; }
+        double HumidityLevelTriggerAbove { get; set; }
+        double PressureLevelTriggerBelow { get; set; }
+        double PressureLevelTriggerAbove { get; set; }
+        double TemperatureLevelTriggerBelow { get; set; }
+        double TemperatureLevelTriggerAbove { get; set; }
+        double LowgLinearAccRate { get; set; }
+        double HighgLinearAccRate { get; set; }
+        double AngularRate { get; set; }
+        double TemperatureHumidityPressureRate { get; set; }
+        bool BatterySaverModeOn { get; set; }
+        bool WakeUpAndArmTriggerOn { get; set; }
+        WakeupTriggers WakeUpTrigger { get; set; }
+        int WakeUpMagnetTimeout { get; set; }
+        int WakeUpMotionTimeout { get; set; }
+        DateTime WakeUpTimeSessionStart { get; set; }
+        TimeSpan WakeUpTimeDuration { get; set; }
+        bool TimedIntervalTriggerOn { get; set; }
+        int IntervalBetweenEventStartsMinutes { get; set; }
+        TimeUnitTypeEnum TimedIntervalUnits { get; set; }
+        double TimedIntervalDuration { get; set; }
+        double TimedIntervalEvents { get; set; }
+        bool RTCScheduleTriggerOn { get; set; }
+        DateTime RTCScheduleStartDateTime { get; set; }
+        TimeSpan RTCScheduleDuration { get; set; }
+        bool StartWithEvent { get; set; }
+        void InitializeFromDefaults(CalibrationBehaviors calBehavior,
+            RecordingModes recordingMode, double preTriggerSeconds, double postTriggerSeconds,
+            int numEvents);
+        bool AlignUDPToPPS { get; set; }
+    }
+}

Common/DTS.Common/Interface/TestSetups/TestSetupsList/ITestSetupsListView.cs

@@ -0,0 +1,6 @@
+using DTS.Common.Base;
+
+namespace DTS.Common.Interface.TestSetups.TestSetupsList
+{
+    public interface ITestSetupsListView : IBaseView { }
+}

Common/DTS.Common/Interface/TestSetups/TestSetupsList/ITestSetupsListViewModel.cs

@@ -0,0 +1,16 @@
+using DTS.Common.Base;
+using DTS.Common.Interface.Pagination;
+
+namespace DTS.Common.Interface.TestSetups.TestSetupsList
+{
+    public interface ITestSetupsListViewModel : IBaseViewModel, IFilterableListView
+    {
+        ITestSetupsListView View { get; set; }
+        ITestSetup[] TestSetups { get; set; }
+        void SetTestSetups(ITestSetup[] allTestSetups);
+        void Sort(object sortBy, bool bColumnClick);
+        void Unset();
+        void Filter(string currentFilter);
+        void MouseDoubleClick(int index);
+    }
+}

Common/DTS.Common/Interface/TestSetups/TestSetupsList/ITestTemplate.cs

@@ -0,0 +1,369 @@
+using DTS.Common.Interface.DASFactory;
+using DTS.Common.Interface.DataRecorders;
+using DTS.Common.Interface.Groups.GroupList;
+using DTS.Common.Interface.Sensors;
+using System;
+using System.Collections.Generic;
+
+namespace DTS.Common.Interface.TestSetups.TestSetupsList
+{
+
+    /// <summary>
+    /// this is an interface to the Heavy Test Setup class
+    /// </summary>
+    public interface ITestTemplate : ITestSetup
+    {
+        bool LowgLevelTriggersMixed { get; set; }
+        double LowgLinearLevelTriggerAggregate { get; set; }
+        bool HighgLevelTriggersMixed { get; set; }
+        double HighgLinearLevelTriggerAggregate { get; set; }
+        bool AngularAccelLevelTriggersMixed { get; set; }
+        double AngularAccelLevelTriggerAggregate { get; set; }
+        bool AngularRateLevelTriggersMixed { get; set; }
+        double AngularRateLevelTriggerAggregate { get; set; }
+        /// <summary>
+        /// property used to indicate that the test is destructive or impact and should set the first use date
+        /// of any relevant sensors or DAS
+        /// 15524 DAS "First Use Date"
+        /// 44625 make it optional property , null shows it's not selected
+        /// note: this property is not serialized with the test setup, it's a run-time set property when
+        /// running the test
+        /// </summary>
+        bool? DestructiveTest { get; set; }
+
+        /// <summary>
+        /// removes the ids for this test template creating a copy without the id associations
+        /// </summary>
+        void CreateCopy();
+
+        void ClearHardware();
+
+        /// <summary>
+        /// returns true whenever the test template is a quick test setup, false otherwise
+        /// </summary>
+        bool QuickSensorCheck { get; set; }
+
+
+        #region Properties
+        bool ExpressTestSetup { get; set; }
+        bool PreserveTestId { get; set; }
+
+        /// <summary>
+        /// true if the test objects and other fields have already been loaded from the database, false otherwise
+        /// </summary>
+        bool IsLoaded { get; }
+
+        void SetIsLoaded(bool bIsLoaded);
+
+        bool ArmCheckListStep { get; set; }
+        bool CheckListBatteryVoltageCheck { get; set; }
+        bool CheckListInputVoltageCheck { get; set; }
+        bool CheckListSquibResistanceCheck { get; set; }
+        bool CheckListSensorIdCheck { get; set; }
+        bool CheckListRequirePass { get; set; }
+        bool CheckListTiltSensorCheck { get; set; }
+        bool CheckListTemperatureCheck { get; set; }
+        bool CheckListClockSyncCheck { get; set; }
+
+        Dictionary<string, double> FilterLookup { get; set; }
+
+        /// <summary>
+        /// excitation warmup time
+        /// can be defined at test level, test object level, (and maybe at hardware or channel level?)
+        /// if defined here, we return it right away, otherwise we pass it to the max of the test objets
+        /// </summary>
+        int ExcitationWarmupTimeMS { get; set; }
+
+        int GraphCount { get; }
+
+
+        string SetupFile { get; set; }
+        string TestId { get; set; }
+        string TestIdNode { get; set; }
+
+        string TestDirectory { get; set; }
+        string OriginalTestDirectory { get; set; }
+        string SampleRateText { get; set; }
+
+        List<string> CheckedDASList { get; set; }
+        bool GroupsStepValid { get; set; }
+
+
+        //assumes list is in order and sets display orders accordingly
+        void SetGroupsListOrder();
+
+        double MaxSampleRate { get; }
+        double MinSampleRate { get; }
+        string DownloadFolder { get; set; }
+        string ExportFolder { get; set; }
+        DateTime TestTime { get; set; }
+        int ChannelCount { get; }
+        int IncludedChannelCount { get; }
+        #endregion Properties
+
+        /// <summary>
+        /// if you use rename serial number method to create a new test setup, we have to go and recreate the groups.
+        /// groups are supposed to be unique to a test setup, and we don't want them to unintentionally share groups
+        /// <param name="bAddedGroups">whether operating on static or dynamic groups</param>
+        /// </summary>
+        void Rename(bool bAddedGroups);
+
+        int GetMaxDisplayOrder();
+
+
+        #region LEVEL_TRIGGER            
+
+        /// <summary>
+        /// replaces any level triggers that have a specific id, with another
+        /// brand new id
+        /// </summary>
+        /// <param name="oldId"></param>
+        /// <param name="newId"></param>
+        void ReplaceLevelTriggerChannel(string oldId, string newId);
+
+        /// <summary>
+        /// scans through all level triggers, looks for any level triggers that might be associated with an old group serial number
+        /// and replaces those references with the new group serial number
+        /// </summary>
+        /// <param name="oldGroupSerial"></param>
+        /// <param name="newGroupSerial"></param>
+        void ReplaceLevelTriggerChannelGroupMapping(string oldGroupSerial, string newGroupSerial);
+
+        /// <summary>
+        /// updates the channel settings for groups which have changed serial numbers [rename/clone group]
+        /// 8404 Copy all channel parameters/settings/level triggers/graphs when cloning a test setup
+        /// </summary>
+        /// <param name="oldIdToNewIdLookup"></param>
+        /// <param name="oldGroupSnToNewGroupSn"></param>
+        void ReplaceChannelSetting(Dictionary<string, string> oldIdToNewIdLookup, Dictionary<string, string> oldGroupSnToNewGroupSn);
+
+        void ReplaceLevelTriggerChannel(Dictionary<string, string> oldIdToNewIdLookup, Dictionary<string, string> oldGroupSnToNewGroupSn);
+
+        void RenameLevelTriggerChannels(string oldName, string newName);
+
+        void RemoveImpossibleLevelTriggers();
+        #endregion LEVEL_TRIGGER
+
+        #region Sensor
+
+
+        /// <summary>
+        /// get sensor from sensor db again (but preserving custom values such as range/polarity/CFC/etc)
+        /// note, test objects already get sensors from from db every time. we hold onto them here, I guess for efficiency, but we could get them fresh every time as well
+        /// </summary>
+        void RefreshSensorsFromDb();
+
+        /// <summary>
+        /// sets a channel to be disabled
+        /// disabled channels don't appear in run test
+        /// </summary>
+        /// <param name="groupName"></param>
+        /// <param name="channelName"></param>
+        /// <param name="disabled"></param>
+        void SetDisabled(string groupName, string channelName, bool disabled);
+
+        //public SensorData GetSensor(IGroupChannel groupChannel)
+        //SensorData GetSensor(string serialNumber, string testObjectSerial, string channelName)
+
+        // FB5438 & FB5023
+        void RemoveSensor(string sensorserialnumber, string testobjectserial, string channelname);
+        #endregion Sensor
+
+        #region XML
+        /// <summary>
+        /// writes a test setup out to xml
+        /// </summary>
+        /// <param name="writer"></param>
+        void WriteXML(ref System.Xml.XmlWriter writer);
+        #endregion XML        
+
+        void ReloadGroupsMemoryOnly();
+
+        /// <summary>
+        /// reloads static groups from list
+        /// </summary>
+        void ReloadGroups(bool bMemoryOnly);
+
+        bool CheckForIEPE();
+        /// <summary>
+        /// returns whether there is a TOM in the test setup or not
+        /// </summary>
+        /// <returns></returns>
+        bool CheckForTOM();
+
+        /// <summary>
+        /// returns whether there is a TOM with channels in use in the test setup or not
+        /// </summary>
+        /// <returns></returns>
+        bool CheckForTOMInTest();
+
+        /// <summary>
+        /// returns whether there is an analog channel in the test or not
+        /// </summary>
+        /// <returns></returns>
+        bool CheckForAnalog();
+
+        /// <summary>
+        /// sets the dirty flag
+        /// does NOT set the flag in the database, so this should only be called when the flag needs to be set in memory
+        /// (for instance during initialization)
+        /// </summary>
+        /// <param name="bDirty"></param>
+        void SetIsDirty(bool bDirty);
+
+        /// <summary>
+        /// sets the complete flag
+        /// does not set the flag in the database, so this should only be called when the flag needs to be set in memory
+        /// (for instance during initialization)
+        /// </summary>
+        /// <param name="bComplete"></param>
+        void SetIsComplete(bool bComplete);
+
+        /// <summary>
+        /// sets the completion error message.
+        /// does not set the field in the db, so this should only be called when the information nets to be set in memory and not the db
+        /// (for instance during initialization)
+        /// </summary>
+        /// <param name="msg"></param>
+        void SetCompletionErrorMessage(string msg);
+        double GetSampleRateForHardware(string h);
+
+        float GetAAFForHardware(IDASCommunication das);
+
+        float GetAAFForHardware(IDASCommunication das, int sps);
+
+
+        /// <summary>
+        /// returns the Anti-Alias Filter (AAF) for the DAS in question
+        /// this is dependent on the sample rate for the hardware and a ratio in the config file
+        /// (RealtimeSampleRateAAFilterRatio)
+        /// </summary>
+        /// <param name="das"></param>
+        /// <returns></returns>
+        float GetRealtimeAAFForHardware(IDASCommunication idas, double samplerate);
+
+        void SetDefaultSetupFile();
+
+        /// <summary>
+        /// calculates whether the test setup is complete or not
+        /// will cause the test setup to be loaded if it is not yet
+        /// does not unload the test setup
+        /// </summary>
+        void CalculateIsComplete(bool bSetInDb = true);
+
+        void CheckSensorCalDates();
+
+        /// <summary>
+        /// marks a test setup as unchecked by setting the dirty flag, which means the next time completion is checked it will be calculated again
+        /// this function will change that flag in the database immediately
+        /// </summary>
+        void MarkIsCompleteUnchecked(bool skipMemoryCheck = false);
+
+        void ClearOverrides();
+
+
+        /// <summary>
+        /// frees up the memory assigned during Load, this includes channels, groups, meta data, etc
+        /// various things may cause us to load the information and hold the information for some setups,
+        /// but in general we want to unload it if we don't need it
+        /// </summary>
+        void UnLoad();
+
+        /// <summary>
+        /// signifies if the test setup is being used for a quick checkout
+        /// quick checkout tests are not stored and are run time only
+        /// </summary>
+        bool IsQuickCheckout { get; set; }
+
+        void Load(bool fromDB = false);
+
+        /// <summary>
+        /// All items from db are updated in our cache
+        /// </summary>
+        void UpdateFromDb();
+
+        IDASHardware[] GetHardwareFromDb();
+
+        IDASHardware[] GetAllCachedHardware2();
+
+        ISensorCalibration[] GetCachedSensorCalibrations();
+
+        ISensorData[] GetCachedSensors();
+
+
+        /// <summary>
+        /// loads all the information for the test setup from tables in the db
+        /// we do this so that we can keep the minimal information on hand until we need it
+        /// </summary>
+        void LoadFromDb();
+
+        string GetTestIdNode();
+
+        /// <summary>
+        /// gets a serialized version of the settings table
+        /// </summary>
+        /// <returns></returns>
+        string GetSettings();
+
+
+        /// <summary>
+        /// loads values from a serialized string into the settings table
+        /// </summary>
+        /// <param name="s"></param>
+        void LoadSettings(string s);
+
+        bool CheckListTriggerStartCheck { get; set; }
+
+        void FilterTestObjects(string term);
+
+        int GetAbsoluteNumber(string serial, int dasChannelNumber);
+
+        double GetPreTriggerSeconds(string serial);
+
+        double GetPostTriggerSeconds(string serial);
+
+        int GetNumberOfRealtimeSupportedChannels();
+
+        /// <summary>
+        /// for some reason it seems custom and lab details are held in two different areas, in meta deta and in the custom/lab detail objects
+        /// this function merely synchronizes the meta data with the objects
+        /// </summary>
+        void SynchronizeTestMetaData();
+
+
+        #region CalculatedChannels
+
+        void UpdateCalculatedChannelId(string[] names, int[] newIds);
+
+        void UpdateCalculatedChannelId(string name, int newId);
+
+        void RemoveImpossibleCalculatedChannels();
+
+        void ReplaceCalculatedChannel(Dictionary<string, string> oldIdToNewIdLookup);
+
+        void RenameCalculatedChannels(string oldName, string newName);
+
+        #endregion CalculatedChannels     
+
+        void SetHardwareOverride(string hid, bool bAdd);
+
+        /// <summary>
+        /// takes a dynamic group in the test and replaces it with a snapshot of the static group
+        /// also updates calculated channels and level trigger channels
+        /// 15400 Group Push/Pull should allow the LT to be preserved in the Test Setup regardless of push/pull
+        /// </summary>
+        /// <param name="_updateGroup"></param>
+        /// <param name="staticGroup"></param>
+        void UpdateDynamicGroupFromStaticGroup(IGroup _updateGroup, IGroup staticGroup);
+
+        #region MetaData
+
+        // FB14362 This method will keep the _metaDataLookup dictionary updated to prevent the missing data from database.
+        void UpdateMetaDataLookupKey(char oldKey, char newKey);
+
+        #endregion MetaData
+
+        void Rename(string newName);
+
+    }
+}