init

Common/DTS.Common.Import/Parsers/CSV/AbstractCSVParser.cs

@@ -0,0 +1,31 @@
+using DTS.Common.Classes.Sensors;
+using DTS.Common.Enums.Sensors;
+using DTS.Common.Import.ImportOptions;
+using DTS.Common.Import.Interfaces;
+
+namespace DTS.Common.Import.Parsers.CSV
+{
+    public abstract class AbstractCSVParser : IParseCSVSensor
+    {
+        public abstract int Version { get; }
+        protected ICalibrationImport _calibrationImport;
+        protected ZeroMethodOptions _zeroMethodOptions;
+        protected IImportNotification _importNotification;
+        protected bool ImportCreateDynamicGroups { get; set; }
+        protected bool UseISOCodeFilterMapping { get; set; }
+        protected bool UseZeroForUnfiltered { get; set; }
+        public void Initialize(ICalibrationImport import, ZeroMethodOptions zmOptions,
+            IImportNotification importNotification, bool importCreateDynamicGroups,
+            bool useISOCodeFilterMapping, bool useZeroForUnfiltered)
+        {
+            _calibrationImport = import;
+            _zeroMethodOptions = zmOptions;
+            _importNotification = importNotification;
+            ImportCreateDynamicGroups = importCreateDynamicGroups;
+            UseISOCodeFilterMapping = useISOCodeFilterMapping;
+            UseZeroForUnfiltered = useZeroForUnfiltered;
+        }
+
+        public abstract void ParseVersion(CSVImportTags.Tags field, string val, ParseParameters pp);
+    }
+}

Common/DTS.Common.Import/Parsers/CSV/CSVFile.cs

@@ -0,0 +1,107 @@
+using DTS.Common.Import.ImportOptions;
+using System;
+using System.IO;
+using System.Linq;
+
+namespace DTS.Common.Import
+{
+    public class CSVFile
+    {
+        private readonly string _filename;
+        public CSVFile(string filename)
+        {
+            _filename = filename;
+        }
+        public static bool IsInUse(string filename)
+        {
+            if (!string.IsNullOrEmpty(filename))
+            {
+                try
+                {
+                    _ = File.ReadAllLines(filename);
+                    return false;
+                }
+                catch (IOException)
+                {
+                    return true;
+                }
+                catch (Exception)
+                {
+                    //We can supress this exception since we are interested in IOException only
+                }
+            }
+            return true;
+        }
+        //FB 40598 check the format of csv and determine if is test setup or not
+        public static bool IsCSVFileForTestSetupImport(string filename, CsvImportOptions csvImportOptions)
+        {
+            try
+            {
+                using (var csvReader = CsvUtil.CreateCsvReader(filename))
+                {
+                    var tokens = CsvUtil.ReadFields(csvReader);
+
+                    if (tokens != null && tokens[0] == "Version")
+                    {
+                        return true;
+                    }
+                }
+            }
+            catch
+            {
+                // return false later
+            }
+            return false;
+        }
+
+        //FB 43815 Get the CSV file version 
+        public static int GetCsvVersion(string filename)
+        {
+            try
+            {
+                using (var csvReader = CsvUtil.CreateCsvReader(filename))
+                {
+                    var tokens = CsvUtil.ReadFields(csvReader);
+
+                    if (tokens != null && tokens[0] == "Version")
+                    {
+                        var tokens2 = CsvUtil.ReadFields(csvReader);
+                        if (tokens2 != null)
+                        {
+                            var version = Convert.ToInt32(tokens2[0]);
+                            return version;
+                        }
+                    }
+                    return 0;
+                }
+            }
+            catch
+            {
+                return 0;
+            }
+        }
+
+        public int LineCount
+        {
+            get
+            {
+                var count = 0;
+                if (!string.IsNullOrEmpty(_filename))
+                {
+                    string[] lines;
+                    try
+                    {
+                        lines = File.ReadAllLines(_filename);
+                        return lines.Count();
+                    }
+
+                    catch (Exception)
+                    {
+                        return count;
+                    }
+                }
+                return count;
+            }
+        }
+    }
+}

Common/DTS.Common.Import/Parsers/CSV/CSVGroupImport.cs

@@ -0,0 +1,192 @@
+using DataPROWin7.DataModel;
+using DTS.Common.Classes.Groups;
+using DTS.Common.Classes.Sensors;
+using DTS.Common.Interface.Groups.GroupList;
+using DTS.Common.Storage;
+using DTS.SensorDB;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+//FB 36879 updated to handle csv group process logic only 
+namespace DTS.Common.Import
+{
+    public class CSVGroupImport : IGroupImport
+    {
+        public ParseParameters ParseParameters { get; set; }
+        public Tuple<TestTemplate, List<IGroup>> CreateGroups(List<SensorData> sensors, Dictionary<string, List<TsetSetupImportSensorInfo>> groupSensorLookup,
+            TestTemplate testTemplate, bool createDynamicGroups, List<IGroup> staticGroups, Action<double> setProgress)
+        {
+            var channelDefaults = DbOperations.GetChannelSettingDefaults();
+            var sensorLookup = sensors.ToDictionary(s => s.SerialNumber);
+
+            if (groupSensorLookup == null || !groupSensorLookup.Any())
+            {
+                return null;
+            }
+
+            var allDAS = DataPROWin7.DataModel.Classes.Hardware.DASHardwareList.GetAllHardware();
+
+            var dasSerialToId = GroupHelper.GetDAS(groupSensorLookup, allDAS);
+            if (dasSerialToId.Count > 0)
+            {
+                using (var e = dasSerialToId.GetEnumerator())
+                {
+                    while (e.MoveNext())
+                    {
+                        testTemplate.AddHardware(e.Current.Value);
+                    }
+                }
+            }
+
+            int total = groupSensorLookup.Count;
+            int current = 0;
+            var displayOrder = 1;
+
+            foreach (var group in groupSensorLookup)
+            {
+                // Make your template
+                var newGroup = GroupHelper.CreateEmptyGroup();
+                newGroup.Name = group.Key;
+                newGroup.DisplayName = newGroup.Name;
+
+                var importTemplateChannelList = group.Value;
+                List<Interface.Channels.IGroupChannel> groupChannels = new List<Interface.Channels.IGroupChannel>();
+                foreach (var ch in importTemplateChannelList)
+                {
+                    var groupChannel = new GroupChannel(false, newGroup.DisplayName, newGroup, channelDefaults);
+                    if (!string.IsNullOrWhiteSpace(ch.DASSerialNumber) && dasSerialToId.ContainsKey(ch.DASSerialNumber))
+                    {
+                        groupChannel.DASId = dasSerialToId[ch.DASSerialNumber];
+                    }
+                    if (ch.DASChannelIndex >= 0)
+                    {
+                        groupChannel.DASChannelIndex = ch.DASChannelIndex;
+                    }
+
+                    if (sensorLookup.ContainsKey(ch.SerialNumber))
+                    {
+                        var sd = sensorLookup[ch.SerialNumber];
+                        var tsetSetupImportSensorInfo = group.Value.Find(p => p.SerialNumber == ch.SerialNumber && p.DASSerialNumber == ch.DASSerialNumber);
+                        if (tsetSetupImportSensorInfo != null)
+                        {
+                            groupChannel.IsoChannelName = tsetSetupImportSensorInfo.IsoChannelName;
+                            groupChannel.UserChannelName = tsetSetupImportSensorInfo.UserChannelName;
+                            groupChannel.UserCode = tsetSetupImportSensorInfo.UserCode;
+                            groupChannel.IsoCode = tsetSetupImportSensorInfo.IsoCode;
+                        }
+                        else
+                        {
+                            groupChannel.IsoChannelName = sd.Comment;
+                            groupChannel.UserChannelName = sd.Comment;
+                            groupChannel.UserCode = ch.UserCode;
+                            groupChannel.IsoCode = ch.IsoCode;
+                        }
+
+                        groupChannel.SetSensorData(sd, null, true);
+                        groupChannel.SensorId = sd.DatabaseId;
+                        groupChannel.Range = sd.Capacity;
+
+                        //http://manuscript.dts.local/f/cases/43490/Full-scale-is-used-for-channel-desired-range-in-import
+                        //set range using sd.Range if it's set and it's different than capacity and is valid
+                        //the default value is 0 so if we have a non zero value it should have been explicitly set
+                        //in the CSV import version this gets set to rangelow/rangehigh/rangemedium
+                        if (!ParseParameters.ImportContainedSensorRanges && sd.RangeHigh == sd.RangeLow && sd.RangeLow == sd.RangeMedium && Math.Abs(sd.Capacity - sd.RangeLow) > .1 && sd.IsAnalog() && sd.RangeMedium > 1)
+                        {
+                            groupChannel.Range = sd.RangeLow;
+                        }
+
+                        groupChannel.FilterClass = sd.FilterClass;
+                        groupChannel.Polarity = sd.Polarity;
+
+                        groupChannel.SquibLimitDuration = sd.LimitSquibFireDuration;
+                        groupChannel.SquibDuration = sd.SquibFireDurationMS;
+                        groupChannel.SquibDelay = sd.SquibFireDelayMS;
+                        groupChannel.SquibFireMode = sd.SquibFireMode;
+                        groupChannel.SquibCurrent = sd.SquibOutputCurrent;
+
+                        groupChannel.DigitalOutputMode = sd.DigitalOutputMode;
+                        groupChannel.DigitalOutDelay = sd.DigitalOutputDelayMS;
+                        groupChannel.DigitalOutDuration = sd.DigitalOutputDurationMS;
+
+                        groupChannel.DigitalInputMode = sd.InputMode;
+                        groupChannel.ActiveValue = sd.InputActiveValue.ToString("N0");
+                        groupChannel.DefaultValue = sd.InputDefaultValue.ToString("N0");
+
+                        if (null != sd.Calibration)
+                        {
+                            groupChannel.AvailableInitialOffsets = sd.Calibration.InitialOffsets.Offsets;
+                            groupChannel.InitialOffset = sd.Calibration.InitialOffsets.DefaultOffset;
+                            //FB 36905 & 35530 check for null 
+                            groupChannel.ZeroMethod = sd.Calibration.ZeroMethods.Methods[0].Method;
+                            groupChannel.ZeroMethodStart = sd.Calibration.ZeroMethods.Methods[0].Start;
+                            groupChannel.ZeroMethodEnd = sd.Calibration.ZeroMethods.Methods[0].End;
+                        }
+
+                        groupChannel.GroupChannelOrder = 1 + sensors.IndexOf(sd);
+                        groupChannel.TestSetupOrder = 1 + sensors.IndexOf(sd);
+                    }
+                    groupChannels.Add(groupChannel);
+                }
+                newGroup.GroupChannelList = groupChannels;
+                if (!createDynamicGroups)
+                {
+                    staticGroups.Add(newGroup);
+                }
+                newGroup.DisplayOrder = displayOrder++;
+                testTemplate.Groups.Add(newGroup);
+                testTemplate.ChannelsForGroup[newGroup] = groupChannels.ToArray();
+
+                setProgress(100D * current / total);
+                current++;
+            }
+            return Tuple.Create(testTemplate, staticGroups);
+
+        }
+
+        public Dictionary<string, List<TsetSetupImportSensorInfo>> GetGroupSensorLookup(List<SensorData> sensors, Dictionary<string, string> sensorGroupNameLookup, Dictionary<string, List<string>> groupNameSensorListLookup)
+        {
+            Dictionary<string, List<TsetSetupImportSensorInfo>> groupSensorLookup = new Dictionary<string, List<TsetSetupImportSensorInfo>>();
+            //FB 30358 Either sensorGroupNameLookup or groupNameSensorListLookup will be populated. dependes on the child class
+            if (sensorGroupNameLookup != null && sensorGroupNameLookup.Any())
+            {
+                groupSensorLookup = sensorGroupNameLookup.Values.Distinct().AsEnumerable().
+                   ToDictionary(groupName => groupName, groupName => new List<TsetSetupImportSensorInfo>());
+
+                foreach (var s in sensors)
+                {
+                    // Build the group sensor and group type dictionary
+                    if (!sensorGroupNameLookup.ContainsKey(s.SerialNumber)) continue;
+
+                    GroupHelper.GetTestSensorParameters(out var isoCode, out var isoChannelName, out var userCode, out var userChannelName, ParseParameters,
+                        s, out var dasSerialNumber, out var dasChannelIdx);
+
+                    // add to group dictionary
+                    groupSensorLookup[sensorGroupNameLookup[s.SerialNumber]].Add(new TsetSetupImportSensorInfo(s.SerialNumber, isoCode,
+                        isoChannelName, userCode, userChannelName, dasSerialNumber, dasChannelIdx));
+                }
+            }
+
+            if (groupNameSensorListLookup != null && groupNameSensorListLookup.Any())
+            {
+                foreach (var g in groupNameSensorListLookup)
+                {
+                    groupSensorLookup.Add(g.Key, new List<TsetSetupImportSensorInfo>());
+                    foreach (var sensorSerialNumber in g.Value)
+                    {
+                        var sd = sensors.Find(s => s.SerialNumber == sensorSerialNumber);
+
+                        if (sd != null)
+                        {
+                            GroupHelper.GetTestSensorParameters(out var isoCode, out var isoChannelName, out var userCode, out var userChannelName,
+                                ParseParameters, sd, out var dasSerialNumber, out var dasChannelIdx);
+                            groupSensorLookup[g.Key].Add(new TsetSetupImportSensorInfo(sd.SerialNumber, sd.ISOCode,
+                                isoChannelName, userCode, userChannelName, dasSerialNumber, dasChannelIdx));
+                        }
+                    }
+                }
+            }
+
+            return groupSensorLookup;
+        }
+    }
+}

Common/DTS.Common.Import/Parsers/CSV/DTSCSVSensorsParser.cs

@@ -0,0 +1,392 @@
+using DTS.Common.Classes.Sensors;
+using DTS.Common.Enums.Sensors;
+using DTS.Common.Interface.Sensors;
+using DTS.Common.SharedResource.Strings;
+using DTS.SensorDB;
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using static DTS.Common.Enums.Sensors.SensorConstants;
+using System.IO;
+using DTS.Common.Enums;
+using DTS.Slice.Users;
+using DTS.Common.Import.ImportOptions;
+using DTS.Common.Import.Interfaces;
+using DTS.Common.Import.Parsers;
+using DTS.Common.Utilities.Logging;
+using DTS.Common.Import.Factories;
+
+namespace DTS.Common.Import
+{
+    public class DTSCSVSensorsParser : ParseVariantBase
+    {
+        private readonly List<string> Errors = new List<string>();
+        private readonly User _currentUser;
+        private readonly CsvImportOptions _csvImportOptions;
+        private readonly ICalibrationImport _calibrationImport;
+        private readonly ZeroMethodOptions _zeroMethodOptions;
+        private readonly IImportNotification _importNotification;
+        public DTSCSVSensorsParser(IImportNotification importNotification, User user, CsvImportOptions csvImportOptions,
+            ICalibrationImport calibrationImport, ZeroMethodOptions zeroMethodOptions)
+        {
+            _currentUser = user;
+            _csvImportOptions = csvImportOptions;
+            _calibrationImport = calibrationImport;
+            _zeroMethodOptions = zeroMethodOptions;
+            _importNotification = importNotification;
+        }
+
+        public bool ImportCreateDynamicGroups { get; set; }
+        public bool UseISOCodeFilterMapping { get; set; }
+        public bool UseZeroForUnfiltered { get; set; }
+
+
+        private ISquibSettingDefaults GetSquibDefaults()
+        {
+            return SquibSettingDefaults.GetSquibSettingsDefault(_currentUser.UserName);
+        }
+        private IDigitalOutDefaults GetDigitalOutDefaults()
+        {
+            return DigitalOutputDefaults.GetDigitalOutDefault(_currentUser.UserName);
+        }
+
+        public override void Parse(ref ImportObject importObject)
+        {
+
+            if (string.IsNullOrEmpty(FileName))
+            {
+                return;
+            }
+
+            if (importObject == null)
+            {
+                throw new ArgumentNullException("importObject", "importObject can't be null or empty");
+            }
+
+            importObject = ParseSensor(importObject, FileName);
+            AssignErrorsToImportObject(ref importObject);
+        }
+
+        private void AssignErrorsToImportObject(ref ImportObject importObject)
+        {
+            //FB 42971 Assign errors in this parser to the import object errors property to be reported to user
+            foreach (var error in Errors)
+            {
+                importObject.AddError(new ImportError { ContinueImportOnError = true, Message = error, Severity = ImportSeverityError.Error });
+            }
+        }
+
+        private ImportObject ParseSensor(ImportObject importObject, string filename)
+        {
+            var columns = new List<CSVImportTags.Tags>();
+            var line = 2;
+            var version = 0;
+            var sensorGroupNameLookup = new Dictionary<string, string>();
+            var sensorGroupTypeLookup = new Dictionary<string, string>();
+            var groupNameTestObjectLookup = new Dictionary<string, string>();
+            var sensorISOCode = new Dictionary<string, string>();
+            var sensorISOChannelName = new Dictionary<string, string>();
+            var sensorUserCode = new Dictionary<string, string>();
+            var sensorUserChannelName = new Dictionary<string, string>();
+            var sensorDASSerialNumber = new Dictionary<string, string>();
+            var sensorDASChannelIdx = new Dictionary<string, int>();
+            var pp = new ParseParameters()
+            {
+                ImportCulture = _csvImportOptions.ImportCulture,
+                StripBackslash = _csvImportOptions.StripBackSlash,
+                SensorGroupNameLookup = sensorGroupNameLookup,
+                SensorGroupTypeLookup = sensorGroupTypeLookup,
+                GroupNameToTestObjectLookup = groupNameTestObjectLookup,
+                UseISOCodeFilterMapping = UseISOCodeFilterMapping,
+                UseZeroForUnfiltered = UseZeroForUnfiltered,
+                SensorISOCode = sensorISOCode,
+                SensorISOChannelName = sensorISOChannelName,
+                SensorUserCode = sensorUserCode,
+                SensorUserChannelName = sensorUserChannelName,
+                SensorDASSerialNumber = sensorDASSerialNumber,
+                SensorDASChannelIndex = sensorDASChannelIdx
+            };
+
+            using (var parser = CsvUtil.CreateCsvReader(filename))
+            {
+                var tokens = CsvUtil.ReadFields(parser);
+
+                if (tokens != null && tokens[0] == "Version")
+                {
+                    var tokens2 = CsvUtil.ReadFields(parser);
+              
+                    if (tokens2 != null)
+                    {
+                        int.TryParse(tokens2[0], out version);
+                    }
+                    if (version == 6)
+                    {
+                        //read until you have no empty start and the tag is < 5
+                        while (parser.Read())
+                        {
+                            tokens = CsvUtil.ReadFields(parser, false);
+                            if (null == tokens || string.IsNullOrWhiteSpace(tokens[0])) { continue; }
+                            var tag = CSVImportTags.GetTagForString(tokens[0]);
+                            if (tag == CSVImportTags.Tags.Unknown) { continue; }
+                            var tagVersion = CSVImportTags.GetVersionForTag(tag);
+                            if (tagVersion > 4) { continue; }
+                            else
+                            {
+                                break;
+                            }
+                        }
+                    }
+                    else
+                    {
+                        parser.Read();//read an empty line 
+                        tokens = CsvUtil.ReadFields(parser);
+                    }
+                }
+
+                if (tokens == null)
+                {
+                    Errors.Clear();
+                    Errors.Add("No tokens to parse");
+                    return importObject;
+                }
+
+                foreach (var token in tokens)
+                {
+                    columns.Add(CSVImportTags.GetTagForString(token));
+                }
+
+                if (0 == columns.Count)
+                {
+                    //NONE of the columns row was recognized, PopulateSensor below will fail as it uses this to populate the sensor
+                    //this will not import any further, so shortcut to an error to the user
+                    //14745 Vague error message when Test Setup import is attempted
+
+                    Errors.Clear();
+                    Errors.Add(StringResources.ImportSensorsPreviewControl_NoColumnsInTDCCSV);
+                    return importObject;
+                }
+
+                var squibDefaults = GetSquibDefaults();
+                var digitalOutDefaults = GetDigitalOutDefaults();
+
+                //18259 DataPRO XML and CSV imports let you import inconsistent SensitvityUnits
+                var sensorsWithUpdatedSensitivityUnits = new List<string>();
+                while (parser.Read())
+                {
+                    tokens = CsvUtil.ReadFields(parser, false);
+                    if (null == tokens) { break; }
+                    var sd = new SensorData();
+                    var sc = new SensorCalibration();
+                    pp.SensorData = sd;
+                    pp.SensorCal = sc;
+                    pp.SquibDefaults = squibDefaults;
+                    pp.DigitalOutDefaults = digitalOutDefaults;
+                    if (!PopulateSensor(columns, tokens.ToArray(), File.GetLastWriteTime(filename), pp))
+                    {
+                        //pp.Errors contains all the errors related to this sensor which is parsed
+                        var errorMessage = $"Line {line}: {string.Join(CultureInfo.CurrentCulture.TextInfo.ListSeparator, pp.Errors)}";
+                        Errors.Add(errorMessage);
+                        line++;
+                        continue;
+                    }
+                    if (!sc.IsProportional && sc.Records.Records[0].SensitivityUnits == SensUnits.mVperVperEU)
+                    {
+                        sc.Records.Records[0].SensitivityUnits = SensUnits.mVperEU;
+                        if (!sensorsWithUpdatedSensitivityUnits.Contains(sd.SerialNumber))
+                        {
+                            sensorsWithUpdatedSensitivityUnits.Add(sd.SerialNumber);
+                        }
+                    }
+
+                    if (!sd.SerialNumber.StartsWith(Constants.ISO_CH_ONLY_PREFIX))
+                    {
+                        if (!string.IsNullOrEmpty(sd.SerialNumber))
+                        {
+                            importObject.AddSensorLookup(sd.SerialNumber, sd);
+
+                        }
+
+                        if (!string.IsNullOrEmpty(sd.SerialNumber))
+                        {
+                            importObject.AddCalibrationLookup(sd.SerialNumber, new List<SensorCalibration>(new[] { sc }));
+                        }
+                    }
+
+                    // this is for compatability for import test setups
+                    importObject.AddSensor(sd);
+                    importObject.AddSensorChannelCodeLookup(sd.SettingName, sd.SerialNumber);
+                    // this is for compatability for import test setups
+                    importObject.AddCalibration(sc);
+                    line++;
+                }
+
+                if (sensorsWithUpdatedSensitivityUnits.Any())
+                {
+                    var msg = $"{StringResources.SensorsUpdatedSensitivityUnits} {string.Join(", ", sensorsWithUpdatedSensitivityUnits.ToArray())}";
+                    _importNotification.ReportErrors(new List<string>(new[] { msg }));
+                }
+            }
+            importObject.AssignSensorGroupNameLookup(sensorGroupNameLookup);
+            importObject.AssignSensorGroupTypeLookup(sensorGroupTypeLookup);
+            importObject.AssignGroupNameTestObjectLookup(groupNameTestObjectLookup);
+            importObject.AssignParseParameters(pp);
+            return importObject;
+        }
+
+        private void Preparse(ParseParameters pp)
+        {
+            var sd = (SensorData)pp.SensorData;
+            sd.Initialize(pp.SquibDefaults);
+            sd.Initialize(pp.DigitalOutDefaults);
+        }
+        private void PostParse(ParseParameters pp)
+        {
+            var sd = (SensorData)pp.SensorData;
+            var sc = (SensorCalibration)pp.SensorCal;
+            sd.InitializeTag(sd.Bridge);
+
+            pp.SensorCal.SerialNumber = pp.SensorData.SerialNumber;
+            if (!double.IsNaN(pp.IrtraccExponent) && pp.SensorData.SensorCategory == (int)SensorInformationFile.TDCSensorCategory.IRTracc)
+            {
+                pp.SensorCal.IsProportional = false;
+                pp.SensorCal.NonLinear = true;
+                if (pp.SensorCal.Records.Records[0].Poly.NonLinearStyle == NonLinearStyles.IRTraccAverageOverTime)
+                {
+                    pp.SensorCal.Records.Records[0].Poly.MMPerV = 1000D / pp.Sensitivity;
+                    pp.SensorCal.Records.Records[0].Poly.LinearizationExponent = pp.IrtraccExponent;
+                    pp.SensorCal.Records.Records[0].Poly.NonLinearStyle = NonLinearStyles.IRTraccAverageOverTime;
+                }
+                pp.SensorCal.Records.Records[0].Poly.MarkValid(true);
+            }
+            else
+            {
+                pp.SensorCal.Records.Records[0].Sensitivity = pp.Sensitivity;
+                if (pp.SensorCal.IsProportional) { pp.SensorCal.Records.Records[0].Excitation = pp.SensorData.SupportedExcitation.First(); }
+            }
+            if (!double.IsNaN(pp.OriginalOffset))
+            {
+                pp.SensorCal.InitialOffsets.Offsets[0].EU = pp.OriginalOffset;
+                pp.SensorCal.InitialOffsets.Offsets[0].Form = InitialOffsetTypes.EU;
+            }
+            pp.SensorCal.ZeroMethods = new ZeroMethods(new[] { new ZeroMethod(pp.ZeroType, pp.ZeroStart, pp.ZeroEnd) });
+            if (sd.SerialNumber.StartsWith(Constants.ISO_CH_ONLY_PREFIX) && !string.IsNullOrEmpty(sd.ISOCode)) { pp.Errors = new List<string>(); }
+
+            //warn if we are analog and have 0 sensitivity ...
+            if (pp.SensorCal.Records.Records[0].Sensitivity == 0D && !sd.IsDigitalOutput() && !sd.IsDigitalInput() && !sd.IsSquib()
+                && !sd.IsUart() && !sd.IsStreamInput() && !sd.IsStreamOutput() && !sd.IsCan())
+            {
+                pp.Errors.Add(string.Format(StringResources.InvalidEmptySensitivity, sd.SerialNumber));
+            }
+            //warn if we are analog and have invalid capacity
+            if (sd.Capacity < 1 && !sd.IsDigitalInput() && !sd.IsDigitalOutput() && !sd.IsSquib()
+                && !sd.IsUart() && !sd.IsStreamOutput() && !sd.IsStreamInput() && !sd.IsCan())
+            {
+                pp.Errors.Add(string.Format(StringResources.ImportSensor_InvalidCapacity, sd.SerialNumber,
+                    sd.Capacity));
+            }
+            //warn if we are analog and have invalid excitation
+            if (IsAnalogWithInvalidExcitation(sd, sc))
+            {
+                pp.Errors.Add(string.Format(StringResources.InvalidExcitation,
+                    pp.SensorCal.Records.Records[0].Excitation));
+            }
+            if (IsAnalogWithInvalidSensitivity(sd, sc))
+            {
+                pp.Errors.Add(string.Format(StringResources.InvalidEmptySensitivity,
+                    sd.SerialNumber));
+            }
+        }
+        private void Parse(CSVImportTags.Tags tag, string sValue, ParseParameters pp,
+            IReadOnlyDictionary<int, IParseCSVSensor> parsers)
+        {
+            var version = CSVImportTags.GetVersionForTag(tag);
+            if (parsers.ContainsKey(version))
+            {
+                parsers[version].ParseVersion(tag, sValue, pp);
+            }
+        }
+
+
+
+
+        /// <summary>
+        /// scans throw a line of tokens in an expected column order and populates a sensor and a sensor calibration with data from that line
+        /// errors is populated with any errors encountered during the import
+        /// returns true if any errors were detected.
+        /// </summary>
+        /// <param name="columns"></param>
+        /// <param name="tokens"></param>
+        /// <param name="sd"></param>
+        /// <param name="errors"></param>
+        /// <param name="sc"></param>
+        /// <param name="fileDateTime"></param>
+        /// <param name="importCulture"></param>
+        /// <param name="sensorGroupNameLookup"></param>
+        /// <param name="sensorGroupTypeLookup"></param>
+        /// <param name="squibDefaults"></param>
+        /// <param name="digitalOutDefaults"></param>
+        /// <param name="groupNameToTestObjectLookup"></param>
+        /// <param name="stripBackslash"></param>
+        /// <param name="useISOCodeFilterMapping"></param>
+        /// <param name="useZeroForUnfiltered"></param>
+        /// <returns></returns>
+        private bool PopulateSensor(IReadOnlyList<CSVImportTags.Tags> columns,
+            string[] tokens,
+            DateTime fileDateTime,
+            ParseParameters pp
+            )
+        {
+            pp.SensorData.LastModified = fileDateTime;
+            pp.IrtraccExponent = double.NaN;
+            pp.Sensitivity = double.NaN;
+            pp.SensorCal.ModifyDate = DateTime.Now;
+            pp.ZeroType = pp.SensorCal.ZeroMethods.Methods.First().Method;
+            pp.ZeroEnd = pp.SensorCal.ZeroMethods.Methods.First().End;
+            pp.ZeroStart = pp.SensorCal.ZeroMethods.Methods.First().Start;
+            pp.SavedIsProportional = false;
+            pp.SavedRemoveOffset = false;
+            //FB 42971 for each senosr starts with no errors 
+            pp.Errors = new List<string>();
+            Preparse(pp);
+
+            var parsers = CSVSensorParserFactory.CreateCSVParsers(_calibrationImport, _zeroMethodOptions,
+                _importNotification, ImportCreateDynamicGroups, UseISOCodeFilterMapping,
+                UseZeroForUnfiltered);
+
+            for (var i = 0; i < columns.Count; i++)
+            {
+                var field = columns[i];
+                var val = tokens[i];
+                if (val.StartsWith("'") && !val.StartsWith("''")) { val = val.Substring(1); }
+                try
+                {
+                    Parse(field, val, pp, parsers);
+                }
+                catch (Exception ex)
+                {
+                    APILogger.Log($"Failed to parse tags version {i}", ex);
+                    return false;
+                }
+            }
+
+            PostParse(pp);
+
+            return !pp.Errors.Any();
+        }
+
+        private static bool IsAnalogWithInvalidExcitation(SensorData sd, SensorCalibration sc)
+        {
+            return sc.Records.Records[0].Excitation ==
+                    ExcitationVoltageOptions.ExcitationVoltageOption.Undefined &&
+                    (sd.Bridge == BridgeType.FullBridge ||
+                sd.Bridge == BridgeType.HalfBridge ||
+                sd.Bridge == BridgeType.QuarterBridge);
+        }
+        private static bool IsAnalogWithInvalidSensitivity(SensorData sd, SensorCalibration sc)
+        {
+            if (sd == null || sc == null || null == sc.Records || null == sc.Records.Records || 0 == sc.Records.Records.Length) { return true; }
+            return sd.IsAnalog() && Math.Abs(sc.Records.Records[0].Sensitivity) < .0000001;
+        }
+    }
+}

Common/DTS.Common.Import/Parsers/CSV/DTSCSVTestSetupParser.cs

@@ -0,0 +1,281 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using DataPROWin7.DataModel;
+using DTS.Common.Classes;
+using DTS.Common.Enums.DASFactory;
+using DTS.Common.Import.Enums;
+using DTS.Common.Import.Factories;
+using DTS.Common.Import.ImportOptions;
+using DTS.Common.Import.Parsers;
+using DTS.Common.Interface.Groups.GroupList;
+using DTS.Common.SharedResource.Strings;
+using DTS.Common.Storage;
+using DTS.SensorDB;
+
+namespace DTS.Common.Import
+{
+    public class DTSCSVTestSetupParser : ParseVariantBase
+    {
+        private readonly IImportNotification _importNotification;
+        private readonly CsvImportOptions _csvImportOptions;
+        private readonly TestSetupImportData _defaultsTestSetupImportData;
+        private readonly IGroupImport _groupImport;
+        //FB 36905
+        private readonly bool _createDynamicGroups;
+        public DTSCSVTestSetupParser(IImportNotification importNotification, CsvImportOptions csvImportOptions, TestSetupImportData testSetupImportData, IGroupImport groupImport, bool createDynamicGroups)
+        {
+            _csvImportOptions = csvImportOptions;
+            _defaultsTestSetupImportData = testSetupImportData;
+            _importNotification = importNotification;
+            _groupImport = groupImport;
+            _createDynamicGroups = createDynamicGroups;
+        }
+
+        public static TestTemplate CreateTestSetup(TestSetupImportData tsid, DASHardware[] allDAS)
+        {
+            var t = new TestTemplate
+            {
+                Name = tsid.Name,
+                Description = tsid.Description,
+                SamplesPerSecondAggregate = tsid.SamplesPerSecond,
+                PostTriggerSeconds = tsid.PosttriggerSeconds,
+                PreTriggerSeconds = tsid.PretriggerSeconds,
+                RecordingMode = tsid.RecordingMode,
+                CalibrationBehavior = tsid.CalibrationBehavior
+            };
+
+            AddHardwareToTestSetup(t, tsid, allDAS);
+
+            SetClockSyncs(t, tsid);
+            if (RecordingModeExtensions.IsAStreamMode(tsid.RecordingMode))
+            {
+                t.DoStreaming = true;
+            }
+            return t;
+        }
+        private static void SetClockSyncs(TestTemplate t, TestSetupImportData tsid)
+        {
+            if (tsid.ManageClocksOutsideOfDataPROMaster)
+            {
+                t.ClockSyncProfileMaster = ClockSyncProfile.Manual;
+            }
+            if (tsid.ManageClocksOutsideOfDataPROSlave)
+            {
+                t.ClockSyncProfileSlave = ClockSyncProfile.Manual;
+            }
+
+        }
+
+        private static void AddHardwareToTestSetup(TestTemplate t, TestSetupImportData tsid, DASHardware[] allDAS)
+        {
+            if (null != tsid.SampleRateForDAS && 0 != tsid.SampleRateForDAS.Count)
+            {
+                using (var e = tsid.SampleRateForDAS.GetEnumerator())
+                {
+                    while (e.MoveNext())
+                    {
+                        var das = Array.Find(allDAS, d => d.SerialNumber.Equals(e.Current.Key));
+                        if (null == das) { continue; }
+                        t.AddHardware(das.DASId);
+                        if (tsid.IsClockMaster.ContainsKey(das.SerialNumber))
+                        {
+                            t.DASClockMasterList[das.SerialNumber] = tsid.IsClockMaster[das.SerialNumber];
+                        }
+                        if (tsid.DomainIdForDAS.ContainsKey(das.SerialNumber))
+                        {
+                            t.DASPTPDomainIDList[das.SerialNumber] = Convert.ToByte(t.DASPTPDomainIDList[das.SerialNumber]);
+                        }
+                    }
+                }
+            }
+        }
+        public static void UpdateDASSampleRate(TestTemplate t, TestSetupImportData tsid, DASHardware[] allDAS)
+        {
+            if (null != tsid.SampleRateForDAS && 0 != tsid.SampleRateForDAS.Count)
+            {
+                using (var e = tsid.SampleRateForDAS.GetEnumerator())
+                {
+                    while (e.MoveNext())
+                    {
+                        var das = Array.Find(allDAS, d => d.SerialNumber.Equals(e.Current.Key));
+                        if (null == das) { continue; }
+                        //why are there two places for this information?
+                        t.SetSampleRateForHardware(das, Convert.ToDouble(e.Current.Value));
+                        t.DASSampleRateList[das.SerialNumber] = Convert.ToDouble(e.Current.Value);
+                    }
+                }
+                if (tsid.SampleRateForDAS.Distinct().Count() > 1)
+                {
+                    t.CommonStatusLine = false;
+                }
+            }
+        }
+
+        public override void Parse(ref ImportObject importObject)
+        {
+            if (string.IsNullOrEmpty(FileName))
+            {
+                return;
+            }
+
+            if (importObject == null)
+            {
+                throw new ArgumentNullException("importObject", "importObject can't be null or empty");
+            }
+            //FB 40598 Check if the file is supported for test setup import
+
+            if (!CSVFile.IsCSVFileForTestSetupImport(FileName, _csvImportOptions))
+            {
+                importObject.AddError(new ImportError { Message = StringResources.Import_CSVFileNotForTestSetup, ContinueImportOnError = false, Severity = ImportSeverityError.Critical });
+                return;
+            }
+
+            var tsid = ParseTestSetup(FileName);
+
+            if (tsid == null)
+            {
+                return;
+            }
+
+            if (importObject.TestSetups().Any(p => p.Name == tsid.Name))
+            {
+                return;
+            }
+
+            var allDAS = DataPROWin7.DataModel.Classes.Hardware.DASHardwareList.GetAllHardware();
+            var t = CreateTestSetup(tsid, allDAS);
+            //FB 36879 Add the hardware list for the test setup
+            //FB 43815 if only the version is 6 which means we have hardware in the file otherwise it would nter a test setup with 0 hardware which would cause problems in
+            //import summary and run test setup button in that wizard 
+            if (t != null && CSVFile.GetCsvVersion(FileName) >= 6)
+            {
+                importObject.AddHardwareList(t.GetHardware());
+            }
+
+            if (tsid.Tags != null)
+            {
+                t?.SetTags(tsid.Tags.ToArray(), DbOperations.GetSQLCommand, DbOperations.TagsGet,
+                    DbOperations.TagsGetId, DbOperations.TagsInsert);
+            }
+
+            //FB Assign the parse parameters
+            _groupImport.ParseParameters = importObject.ParseParameters();
+
+            AssignCalibrations(ref importObject);
+
+            var res = AssignGroupsToTestSetup(t, importObject.SensorGroupNamesLookup(), null, importObject.StaticGroups().ToList(),
+                importObject.Sensors().ToList(), _groupImport, _importNotification, tsid.Version);
+
+            var staticGroups = res?.Item2;
+            var sensors = res?.Item3;
+            var testSetup = res?.Item1;
+
+            if (staticGroups != null)
+            {
+                importObject.AddStaticGroups(staticGroups);
+            }
+
+            var cleanedSensors = GroupHelper.CleanUneededSensorDataPlaceHolder(importObject.CalibrationsLookup(), sensors);
+            if (cleanedSensors != null)
+            {
+                importObject.ClearSensors();
+
+                importObject.AddSensors(cleanedSensors);
+            }
+
+            UpdateDASSampleRate(t, tsid, allDAS);
+
+            if (testSetup != null)
+            {
+                importObject.AddTestSetup(testSetup);
+                //FB 38039, 40758 Identify type of import by number of test setups
+                importObject.TestSetupImportFileFormat = importObject.GetImportFileFormat();
+            }
+
+            importObject.SourceFormat = ImportFormats.DTS_CSV;
+        }
+        /// <summary>
+        /// set the calibration for the sensor based on the most recent in the import
+        /// this is necessary as it was coming in with the latest calibration from the database (which
+        /// will be empty in a brand new import)
+        /// http://manuscript.dts.local/f/cases/43722/When-Importing-Csv-test-setup-software-zero-method-in-test-setup-parameters-does-not-match-import
+        /// </summary>
+        private void AssignCalibrations(ref ImportObject importObject)
+        {
+            if (null == importObject) { return; }            
+            if (null == importObject.Sensors() || !importObject.Sensors().Any()) { return; }
+            if (null == importObject.Calibrations() || !importObject.Calibrations().Any()) { return; }
+
+            foreach( var sensor in importObject.Sensors())
+            {
+                var cals = importObject.CalibrationLookup(sensor.SerialNumber);
+                if (null == cals || 0 == cals.Count) { return; }
+                cals.Sort();
+                sensor.Calibration = cals[cals.Count - 1];
+            }
+
+        }
+        //FB 36879 Single Responsibility principle , moved the method to this class
+        private Tuple<TestTemplate, List<IGroup>, List<SensorData>> AssignGroupsToTestSetup(TestTemplate testTemplate, Dictionary<string, string> sensorGroupNameLookup, Dictionary<string, List<string>> groupNameSensorListLookup,
+          List<IGroup> existingStaticGroups, List<SensorData> sensors, IGroupImport groupImport, IImportNotification importNotification, int csvVersion)
+        {
+            try
+            {
+                _ = GroupHelper.ReverseChannelOrder(testTemplate, sensorGroupNameLookup, sensors);
+
+                var groupSensorLookup = groupImport.GetGroupSensorLookup(sensors, sensorGroupNameLookup, groupNameSensorListLookup);
+
+                sensors = GroupHelper.NormalizeSensorIds(sensors);
+                //FB 36905
+                var testAndGroups = groupImport.CreateGroups(sensors, groupSensorLookup, testTemplate, _createDynamicGroups, existingStaticGroups, importNotification.SetProgress);
+
+                if (testAndGroups == null)
+                {
+                    TestTemplate noTestSetup = null;
+                    List<IGroup> noGroup = null;
+                    return Tuple.Create(noTestSetup, noGroup, sensors);
+                }
+                return Tuple.Create(testAndGroups.Item1, testAndGroups.Item2, sensors);
+            }
+            catch (Exception ex)
+            {
+                importNotification.ReportErrors(new List<string> { ex.Message });
+                return null;
+            }
+        }
+
+    
+
+        private TestSetupImportData ParseTestSetup(string filename)
+        {
+            var tsid = new TestSetupImportData()
+            {
+                SamplesPerSecond = _defaultsTestSetupImportData.SamplesPerSecond,
+                Tags = new List<string>(),
+                Version = 0,
+                RecordingMode = _defaultsTestSetupImportData.RecordingMode,
+                PretriggerSeconds = _defaultsTestSetupImportData.PretriggerSeconds,
+                PosttriggerSeconds = _defaultsTestSetupImportData.PosttriggerSeconds,
+                CalibrationBehavior = _defaultsTestSetupImportData.CalibrationBehavior
+            };
+
+            using (var parser = CsvUtil.CreateCsvReader(filename))
+            {
+                var parsers = CSVTestParserFactory.CreateCSVParsers();
+
+                parsers[0].ParseVersion(parser, tsid);
+
+                if (tsid.Version == 6)
+                {
+                    for (var i = 1; i < parsers.Length; i++)
+                    {
+                        parsers[i].ParseVersion(parser, tsid);
+                    }
+                }
+            }
+
+            return tsid;
+        }
+    }
+}

Common/DTS.Common.Import/Parsers/CSV/Version0CSVSensorParser.cs

@@ -0,0 +1,391 @@
+using DTS.Common.Classes.Sensors;
+using DTS.Common.DAS.Concepts;
+using DTS.Common.DataModel;
+using DTS.Common.Enums.Sensors;
+using DTS.Common.Import.Interfaces;
+using DTS.Common.SharedResource.Strings;
+using DTS.Common.Utilities.Logging;
+using DTS.SensorDB;
+using System;
+using System.Globalization;
+using System.Linq;
+
+namespace DTS.Common.Import.Parsers.CSV
+{
+    [System.Diagnostics.CodeAnalysis.SuppressMessage("Minor Code Smell", "S101:Types should be named in PascalCase", Justification = "Acronym")]
+    public class Version0CSVSensorParser : AbstractCSVParser
+    {
+        /// <summary>
+        /// handles the Version 0 Channel name tag
+        /// </summary>
+        /// <param name="val"></param>
+        /// <param name="pp"></param>
+        private static void HandleVersion0ChannelName(string val, ParseParameters pp)
+        {
+            pp.SensorData.Comment = val;
+            if (string.IsNullOrWhiteSpace(pp.SensorData.ISOChannelName))
+            {
+                pp.SensorData.ISOChannelName = val;
+            }
+            if (string.IsNullOrEmpty(pp.SensorData.UserChannelName))
+            {
+                pp.SensorData.UserChannelName = val;
+            }
+        }
+        public override int Version => 0;
+        public override void ParseVersion(CSVImportTags.Tags field, string val, ParseParameters pp)
+        {
+            var sd = (SensorData)pp.SensorData;
+            try
+            {
+                #region and another very long switch statement
+                switch (field)
+                {
+                    case CSVImportTags.Tags.Axis: break;
+
+                    case CSVImportTags.Tags.BRIDGE:
+                        //FB 41817 if bridge value is type don't override it, the bridge type will have a value and it will assign it later
+                        if (!string.IsNullOrWhiteSpace(val))
+                        {
+                            pp.SensorData.Bridge = val.ToLower() == "full" ? SensorConstants.BridgeType.FullBridge : SensorConstants.BridgeType.HalfBridge;
+                        }
+                        break;
+                    case CSVImportTags.Tags.BridgeResistance:
+                        {
+                            if (!string.IsNullOrWhiteSpace(val))
+                            {
+                                if (double.TryParse(val, NumberStyles.Any, pp.ImportCulture, out var d))
+                                {
+                                    pp.SensorData.BridgeResistance = d;
+                                }
+                                else { pp.Errors.Add(string.Format(StringResources.InvalidBridgeResistance, val)); }
+                            }
+                        }
+                        break;
+
+                    case CSVImportTags.Tags.BypassAAFilter: pp.SensorData.ByPassFilter = val.ToLower() == "yes"; break;
+
+                    case CSVImportTags.Tags.Category:
+                        {
+                            if (string.IsNullOrWhiteSpace(val)) { return; }
+                            if (int.TryParse(val, NumberStyles.Any, pp.ImportCulture, out var temp))
+                            {
+                                pp.SensorData.SensorCategory = temp;
+                            }
+                            else { pp.Errors.Add(string.Format(StringResources.InvalidCategory, val)); }
+                        }
+                        break;
+
+                    case CSVImportTags.Tags.ChannelName:
+                        HandleVersion0ChannelName(val, pp);
+                        break;
+
+                    case CSVImportTags.Tags.CommentField: pp.SensorData.UserValue1 = val; break;
+
+                    case CSVImportTags.Tags.CustomerCode: pp.SensorData.UserValue2 = val; break;
+
+                    case CSVImportTags.Tags.DatabaseReferenceNumber: break;
+
+                    case CSVImportTags.Tags.DesiredRange:
+                        {
+                            if (string.IsNullOrWhiteSpace(val)) { return; }
+                            if (double.TryParse(val, NumberStyles.Any, pp.ImportCulture, out double d))
+                            {
+                                pp.SensorData.RangeHigh = d;
+                                pp.SensorData.RangeMedium = d;
+                                pp.SensorData.RangeLow = d;
+                            }
+                            else { pp.Errors.Add(string.Format(StringResources.InvalidDesiredRange, val)); }
+                        }
+                        break;
+
+                    case CSVImportTags.Tags.Dimension: break;
+
+                    case CSVImportTags.Tags.Due: break;
+
+                    case CSVImportTags.Tags.DueCal: break;
+
+                    case CSVImportTags.Tags.EquivalentEUShuntResistor: break;
+
+                    case CSVImportTags.Tags.EU:
+                        {
+                            foreach (var r in pp.SensorCal.Records.Records)
+                            {
+                                r.EngineeringUnits = val;//FB16398: set units on all records, not just first
+                            }
+                            //removed dependency to unity framework 
+                            //sc.Records.Records.ForEach(record => record.EngineeringUnits = val); //FB16398: set units on all records, not just first
+                            sd.DisplayUnit = val;
+                        }
+                        break;
+
+                    case CSVImportTags.Tags.Exc:
+                        {
+                            if (string.IsNullOrWhiteSpace(val))
+                            {
+                                return;
+                            }
+                            if (double.TryParse(val, NumberStyles.Any, pp.ImportCulture, out var d))
+                            {
+                                try
+                                {
+                                    pp.SensorData.SupportedExcitation = new[] { Test.Module.Channel.Sensor.GetExcitationVoltageEnumFromMagnitude(d) };
+                                }
+                                catch (Exception ex)
+                                {
+                                    if (ex is NotSupportedException)
+                                    {
+                                        pp.Errors.Add(string.Format(StringResources.InvalidExcitation, val));
+                                    }
+                                }
+                            }
+                            else { pp.Errors.Add(string.Format(StringResources.InvalidExcitation, val)); }
+                        }
+                        break;
+
+                    case CSVImportTags.Tags.FilterClass:
+                        {
+                            if (string.IsNullOrWhiteSpace(val)) { return; }
+                            if (val.Contains(CFC))
+                            {
+                                ParseFilterClassCFC(val, pp, sd);
+                            }
+                            else { ParseFilterClassInt(val, pp, sd); }
+                        }
+                        break;
+
+                    case CSVImportTags.Tags.FullScale:
+                        {
+                            if (string.IsNullOrWhiteSpace(val)) { return; }
+                            if (double.TryParse(val, NumberStyles.Any, pp.ImportCulture, out double d))
+                            {
+                                pp.SensorData.Capacity = d;
+                            }
+                            else { pp.Errors.Add(string.Format(StringResources.InvalidFullScale, val)); }
+                        }
+                        break;
+
+                    case CSVImportTags.Tags.Group1: break;
+
+                    case CSVImportTags.Tags.Group2: break;
+                    case CSVImportTags.Tags.Group3: break;
+                    case CSVImportTags.Tags.Group4: break;
+                    case CSVImportTags.Tags.Group5: break;
+
+                    case CSVImportTags.Tags.InvertSignal: pp.SensorData.Invert = val.ToLower() == "yes"; break;
+
+                    case CSVImportTags.Tags.IRTRACCExponent:
+                        {
+                            if (!string.IsNullOrWhiteSpace(val))
+                            {
+                                if (double.TryParse(val, NumberStyles.Any, pp.ImportCulture, out var d))
+                                {
+                                    if (d < 1) { pp.IrtraccExponent = d; }
+                                }
+                                else { pp.Errors.Add(string.Format(StringResources.InvalidIRTRACCExponent, val)); }
+                            }
+                            else { pp.IrtraccExponent = 1; }
+                        }
+                        break;
+
+                    case CSVImportTags.Tags.LaboratoryCode: pp.SensorData.UserValue3 = val; break;
+
+                    case CSVImportTags.Tags.LastCal:
+                        {
+                            if (string.IsNullOrWhiteSpace(val)) { return; }
+                            if (DateTime.TryParse(val, pp.ImportCulture, DateTimeStyles.AssumeLocal, out var dt))
+                            {
+                                pp.SensorCal.CalibrationDate = dt;
+                            }
+                            else { pp.Errors.Add(string.Format(StringResources.InvalidLastCal, val)); }
+                        }
+                        break;
+
+                    case CSVImportTags.Tags.Location: break;
+
+                    case CSVImportTags.Tags.Manufacturer: pp.SensorData.Manufacturer = val; break;
+
+                    case CSVImportTags.Tags.Model: pp.SensorData.Model = val; break;
+
+                    case CSVImportTags.Tags.OffsetToleranceHigh:
+                        {
+                            if (string.IsNullOrWhiteSpace(val)) { return; }
+                            if (double.TryParse(val, NumberStyles.Any, pp.ImportCulture, out var d))
+                            {
+                                pp.SensorData.OffsetToleranceHigh = d;
+                            }
+                            else { pp.Errors.Add(string.Format(StringResources.InvalidOffsetToleranceHigh, val)); }
+                        }
+                        break;
+
+                    case CSVImportTags.Tags.OffsetToleranceLow:
+                        {
+                            if (string.IsNullOrWhiteSpace(val)) { return; }
+                            if (double.TryParse(val, NumberStyles.Any, pp.ImportCulture, out var d))
+                            {
+                                pp.SensorData.OffsetToleranceLow = d;
+                            }
+                            else { pp.Errors.Add(string.Format(StringResources.InvalidOffsetToleranceLow, val)); }
+                        }
+                        break;
+
+                    case CSVImportTags.Tags.OutputAtEXCFSmV: break;
+
+                    case CSVImportTags.Tags.PartialISOCode: sd.ISOCode = val; break;
+
+                    case CSVImportTags.Tags.Proportional:
+                        pp.SensorCal.IsProportional = val.ToLower() == "yes";
+                        //Since this could get get set to False if the sensor is non-linear, save it in
+                        //case there is also a linear calibration for this sensor and set it to what is saved.
+                        pp.SavedIsProportional = pp.SensorCal.IsProportional;
+                        break;
+
+                    case CSVImportTags.Tags.Received: break;
+
+                    case CSVImportTags.Tags.RemoveOffset:
+                        pp.SensorCal.RemoveOffset = val.ToLower() == "yes";
+                        //Since this could get get set to False if the sensor is non-linear, save it in
+                        //case there is also a linear calibration for this sensor and set it to what is saved.
+                        pp.SavedRemoveOffset = pp.SensorCal.RemoveOffset;
+                        break;
+
+                    case CSVImportTags.Tags.Sensitivity:
+                        {
+                            if (string.IsNullOrWhiteSpace(val))
+                            {
+                                return;
+                            }
+
+                            if (double.TryParse(val, NumberStyles.Any, pp.ImportCulture, out var d))
+                            {
+                                //13810 Sensor ID and sensitivity are degraded to scientific notation when editing
+                                if (val.ToLower().Contains("e"))
+                                {
+                                    pp.Errors.Add(string.Format(StringResources.InvalidSensitivity,
+                                        pp.SensorData.SerialNumber, val));
+                                    return;
+                                }
+
+                                pp.Sensitivity = d;
+                                //FB 41820 set sensitivity in sensor data 
+                                pp.SensorData.Calibration.Records.Records[0].Sensitivity = d;
+                            }
+                            else { pp.Errors.Add(string.Format(StringResources.InvalidSensitivity, sd.SerialNumber, val)); }
+                        }
+                        break;
+
+                    case CSVImportTags.Tags.SensorID:
+                        //13810 Sensor ID and sensitivity are degraded to scientific notation when editing
+                        if (!string.IsNullOrWhiteSpace(val) && val.ToLower() != "none" && !val.ToLower().Contains("e+") && !val.ToLower().Contains("e-"))
+                        {
+                            pp.SensorData.EID = val;
+                        }
+                        break;
+
+                    case CSVImportTags.Tags.SensorSN:
+                        if (string.IsNullOrEmpty(val)) { val = string.Concat(Constants.ISO_CH_ONLY_PREFIX, Guid.NewGuid().ToString()); }
+                        if (pp.StripBackslash)
+                        {
+                            //14772 Sanitize sensor serials when performing TDC sensor import 
+                            var splits = val.Split('\\');
+                            val = splits.Last();
+                        }
+                        pp.SensorData.SerialNumber = val;
+                        pp.SensorData.UUID = val;
+                        break;
+
+                    case CSVImportTags.Tags.SensorType: break;
+
+                    case CSVImportTags.Tags.ShuntResistorValue: break;
+
+                    case CSVImportTags.Tags.SoftwareZeroEquivalentEU:
+                        {
+                            if (!string.IsNullOrWhiteSpace(val))
+                            {
+                                if (double.TryParse(val, NumberStyles.Any, pp.ImportCulture, out double d))
+                                {
+                                    pp.OriginalOffset = d;
+                                }
+                                else { pp.Errors.Add(string.Format(StringResources.InvalidZeroEquivalentEU, val)); }
+                            }
+                        }
+                        break;
+
+                    case CSVImportTags.Tags.SoftwareZeroReference:
+                        switch (val)// (Pre, Avg, 0mV)
+                        {
+                            case SensorDatabaseExport.ZM_STRING_DIAGNOSTICS: pp.ZeroType = ZeroMethodType.UsePreEventDiagnosticsZero; break;
+
+                            case SensorDatabaseExport.ZM_STRING_NONE: pp.ZeroType = ZeroMethodType.None; break;
+
+                            default:
+                                pp.ZeroType = ZeroMethodType.AverageOverTime;
+                                break;
+                        }
+                        break;
+
+                    case CSVImportTags.Tags.Tech: pp.SensorCal.Username = val; break;
+
+                    case CSVImportTags.Tags.Unknown: break;
+
+                    case CSVImportTags.Tags.UseShuntCal:
+                        sd.Shunt = val.ToLower() == "yes" ? ShuntMode.Emulation : ShuntMode.None;
+                        break;
+
+                }
+                #endregion and another very long switch statement
+            }
+            catch (Exception)
+            {
+                pp.Errors.Add(string.Format(StringResources.InvalidField, field, val));
+            }
+        }
+        private const string CFC = "CFC";
+        private static void ParseFilterClassCFC(string val, ParseParameters pp, SensorData sd)
+        {
+            try
+            {
+                var idx = val.IndexOf(CFC);
+                if (0 > idx)
+                {
+                    pp.Errors.Add(string.Format(StringResources.InvalidFilterClass, val));
+                    return;
+                }
+                val = val.Substring(idx + CFC.Length);
+                val = val.Trim();
+            }
+            catch (Exception ex) { APILogger.Log(ex); }
+            ParseFilterClassInt(val, pp, sd);
+        }
+        private static void ParseFilterClassInt(string val, ParseParameters pp, SensorData sd)
+        {
+            try
+            {
+                if (int.TryParse(val, NumberStyles.Any, pp.ImportCulture, out var numericFilterClassValue))
+                {
+                    sd.Filter = new FilterClass(FilterClass.GetFilterClassTypeFromNumericFC(numericFilterClassValue));
+                    var fc = new FilterClass(FilterClass.GetFilterClassTypeFromNumericFC(numericFilterClassValue));
+                    if (null != fc)
+                    {
+                        // http://manuscript.dts.local/f/cases/16440/CSV-Import-should-respect-IS
+                        // 16440 - CSV Import should respect ISO Code Filter Mapping setting
+                        if (pp.UseISOCodeFilterMapping)
+                        {
+                            sd.SetFilterAndFilterClassISO(fc, pp.UseZeroForUnfiltered, false);
+                        }
+                        else
+                        {
+                            sd.Filter = fc;
+                        }
+                    }
+                }
+                else { pp.Errors.Add(string.Format(StringResources.InvalidFilterClass, val)); }
+            }
+            catch (Exception ex) 
+            { 
+                APILogger.Log(ex);
+                pp.Errors.Add(string.Format(StringResources.InvalidFilterClass, val));
+            }
+        }
+    }
+}

Common/DTS.Common.Import/Parsers/CSV/Version0CSVTestParser.cs

@@ -0,0 +1,79 @@
+using CsvHelper;
+using DTS.Common.Classes;
+using DTS.Common.Enums;
+using DTS.Common.Enums.Sensors;
+using DTS.Common.Import.Interfaces;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace DTS.Common.Import.Parsers.CSV
+{
+    public class Version0CSVTestParser : IParseCSVTest
+    {
+        public int Version => 0;
+        public void ParseVersion(CsvReader csvReader, TestSetupImportData tsid)
+        {
+            var tokens = CsvUtil.ReadFields(csvReader);
+
+            if (null == tokens || tokens[0] != "Version")
+            {
+                return;
+            }
+            var tokens2 = CsvUtil.ReadFields(csvReader);
+
+            if (null == tokens2) { return; }
+
+            for (var i = 0; i < tokens.Count && i < tokens2.Count; i++)
+            {
+                GetValueForField(tsid, tokens, tokens2, i);
+            }
+        }
+
+        private static double ParseDoubleValue(string val)
+        {
+            return double.TryParse(val, out var iTemp) ? iTemp : default(double);
+        }
+
+        private static void GetValueForField(TestSetupImportData testSetupImportData, List<string> tokens, List<string> tokens2, int index)
+        {
+            var field = CSVImportTags.GetTagForString(tokens[index]);
+            var val = tokens2[index];
+            switch (field)
+            {
+                case CSVImportTags.Tags.PostTriggerSec:
+                        testSetupImportData.PosttriggerSeconds = ParseDoubleValue(val);
+                    break;
+                case CSVImportTags.Tags.PreTriggerSec:
+                    {
+                            testSetupImportData.PretriggerSeconds = ParseDoubleValue(val);
+                    }
+                    break;
+                case CSVImportTags.Tags.RecordingMode:
+                    {
+                        testSetupImportData.RecordingMode = Enum.TryParse(val, out RecordingModes mode) ? mode : default;
+                    }
+                    break;
+                case CSVImportTags.Tags.SampleRate:
+                    {
+                        testSetupImportData.SamplesPerSecond = ParseDoubleValue(val); 
+                    }
+                    break;
+                case CSVImportTags.Tags.TestSetupDescription:
+                    testSetupImportData.Description = val;
+                    break;
+                case CSVImportTags.Tags.TestSetupName:
+                    testSetupImportData.Name = val;
+                    break;
+                case CSVImportTags.Tags.Version:
+                    {
+                        testSetupImportData.Version = int.TryParse(val, out var iTemp) ? iTemp : default;
+                    }
+                    break;
+                case CSVImportTags.Tags.Tags:
+                    testSetupImportData.Tags = val.Split(';').ToList();
+                    break;
+            }
+        }
+    }
+}

Common/DTS.Common.Import/Parsers/CSV/Version2CSVSensorParser.cs

@@ -0,0 +1,416 @@
+using DTS.Common.Classes.Sensors;
+using DTS.Common.Enums;
+using DTS.Common.Enums.Sensors;
+using DTS.Common.Import.Interfaces;
+using DTS.Common.SharedResource.Strings;
+using DTS.SensorDB;
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using static DTS.Common.Enums.Sensors.SensorConstants;
+
+namespace DTS.Common.Import.Parsers.CSV
+{
+    public class Version2CSVSensorParser : AbstractCSVParser
+    {
+        public override int Version => 2;
+        public override void ParseVersion(CSVImportTags.Tags field, string sVal, ParseParameters pp)
+        {
+            var sd = (SensorData)pp.SensorData;
+            var sc = (SensorCalibration)pp.SensorCal;
+            #region and another very long switch statement
+            switch (field)
+            {
+                case CSVImportTags.Tags.AdditionalInitialOffsets:
+                    {
+                        if (!string.IsNullOrWhiteSpace(sVal))
+                        {
+                            var additionalInitialOffsets = new InitialOffsets(sVal); //merge with original (initial) initial offset
+                            var numAdditionalInitialOffsets = additionalInitialOffsets.Offsets.Length;
+                            var mergedInitialOffsets = new InitialOffset[numAdditionalInitialOffsets + 1];
+                            mergedInitialOffsets[0] = sc.InitialOffsets.Offsets[0];
+                            var counter = 0;
+                            foreach (var additionalInitialOffset in additionalInitialOffsets.Offsets)
+                            {
+                                counter++;
+                                mergedInitialOffsets[counter] = additionalInitialOffset;
+                            }
+                            sc.InitialOffsets.Offsets = mergedInitialOffsets;
+                        }
+                    }
+                    break;
+                case CSVImportTags.Tags.AdditionalLinearSensitivity:
+                    if (!string.IsNullOrWhiteSpace(sVal))
+                    {
+                        //This is a non-linear sensor with additional linear attributes
+                        if (double.TryParse(sVal, NumberStyles.Any, pp.ImportCulture, out var d))
+                        {
+                            //13810 Sensor ID and sensitivity are degraded to scientific notation when editing
+                            if (sVal.ToLower().Contains("e"))
+                            {
+                                pp.Errors.Add(string.Format(StringResources.InvalidSensitivity,
+                                    sd.SerialNumber, sVal));
+                                return;
+                            }
+
+                            pp.Sensitivity = d;
+                        }
+                        else { pp.Errors.Add(string.Format(StringResources.InvalidSensitivity, sd.SerialNumber, sVal)); }
+
+                        //Add a linear calibration record if it doesn't already exist
+                        sc = _calibrationImport.AddLinearCalRecordIfNeeded(sc, pp.SavedIsProportional, pp.SavedRemoveOffset);
+
+                        sc.Records.Records[1].Sensitivity = pp.Sensitivity;
+                        if (sc.IsProportional) { sc.Records.Records[1].Excitation = sd.SupportedExcitation.First(); }
+                    }
+                    break;
+                case CSVImportTags.Tags.AdditionalLinearZeroMethod:
+                    if (!string.IsNullOrWhiteSpace(sVal))
+                    {
+                        {
+                            //Add a linear ZeroMethods record if it doesn't already exist
+                            sc = _calibrationImport.AddLinearZeroMethodIfNeeded(sc, _zeroMethodOptions.ZeroMethodType, _zeroMethodOptions.ZeroMethodStart, _zeroMethodOptions.ZeroMethodEnd);
+
+                            if (Enum.TryParse(sVal, out ZeroMethodType zmt))
+                            {
+                                sc.ZeroMethods.Methods.Last().Method = zmt;
+                                pp.ZeroType = zmt;
+                            }
+                        }
+                    }
+                    break;
+                case CSVImportTags.Tags.AdditionalLinearZeroMethodEnd:
+                    if (!string.IsNullOrWhiteSpace(sVal))
+                    {
+                        {
+                            //Add a linear ZeroMethods record if it doesn't already exist
+                            sc = _calibrationImport.AddLinearZeroMethodIfNeeded(sc, _zeroMethodOptions.ZeroMethodType, _zeroMethodOptions.ZeroMethodStart, _zeroMethodOptions.ZeroMethodEnd);
+
+                            if (double.TryParse(sVal, NumberStyles.Any, pp.ImportCulture, out var zeroMethodEnd))
+                            {
+                                sc.ZeroMethods.Methods.Last().End = zeroMethodEnd;
+                                pp.ZeroEnd = zeroMethodEnd;
+                            }
+                        }
+                    }
+                    break;
+                case CSVImportTags.Tags.AdditionalLinearZeroMethodStart:
+                    if (!string.IsNullOrWhiteSpace(sVal))
+                    {
+                        {
+                            //Add a linear ZeroMethods record if it doesn't already exist
+                            sc = _calibrationImport.AddLinearZeroMethodIfNeeded(sc, _zeroMethodOptions.ZeroMethodType, _zeroMethodOptions.ZeroMethodStart, _zeroMethodOptions.ZeroMethodEnd);
+
+                            if (double.TryParse(sVal, NumberStyles.Any, pp.ImportCulture, out var zeroMethodStart))
+                            {
+                                sc.ZeroMethods.Methods.Last().Start = zeroMethodStart;
+                                pp.ZeroStart = zeroMethodStart;
+                            }
+                        }
+                    }
+                    break;
+                case CSVImportTags.Tags.AxisNumber:
+                    if (short.TryParse(sVal, NumberStyles.Any, pp.ImportCulture, out var axisNumber))
+                    {
+                        sd.AxisNumber = axisNumber;
+                    }
+                    break;
+                case CSVImportTags.Tags.BridgeLegMode:
+                    BridgeLeg bl;
+                    if (Enum.TryParse(sVal, out bl)) { sd.BridgeLegMode = bl; }
+                    break;
+                case CSVImportTags.Tags.BridgeType:
+                    if (Enum.TryParse(sVal, out BridgeType bt))
+                    {
+                        sd.Bridge = bt;
+                    }
+                    else
+                    {
+                        //FB 41817 if not parsable but contains these values use them 
+                        if (sVal.ToLower() == "squib setting")
+                        {
+                            sd.Bridge = BridgeType.SQUIB;
+                        }
+                        else if (sVal.ToLower() == "digital input setting")
+                        {
+                            sd.Bridge = BridgeType.DigitalInput;
+                        }
+                        else if (sVal.ToLower() == "digital output setting")
+                        {
+                            sd.Bridge = BridgeType.TOMDigital;
+                        }
+                        else if (sVal.ToLower() == "full bridge")
+                        {
+                            sd.Bridge = BridgeType.FullBridge;
+                        }
+                    }
+                    break;
+                case CSVImportTags.Tags.CalInterval:
+                    {
+                        if (int.TryParse(sVal, NumberStyles.Any, pp.ImportCulture, out var temp)) { sd.CalInterval = temp; }
+                    }
+                    break;
+
+                case CSVImportTags.Tags.CouplingMode:
+                    {
+                        if (Enum.TryParse(sVal, out CouplingModes cm)) { sd.CouplingMode = cm; }
+                    }
+                    break;
+
+                case CSVImportTags.Tags.Created:
+                    {
+                        if (DateTime.TryParse(sVal, pp.ImportCulture, DateTimeStyles.AssumeLocal, out var dt)) { sd.Created = dt; }
+                    }
+                    break;
+
+                case CSVImportTags.Tags.DelayMS:
+                    {
+                        if (double.TryParse(sVal, out var d)) { sd.DelayMS = d; }
+                    }
+                    break;
+
+                case CSVImportTags.Tags.DigitalOutputDelayMS:
+                    {
+                        if (double.TryParse(sVal, out var d)) { sd.DigitalOutputDelayMS = d; }
+                    }
+                    break;
+
+                case CSVImportTags.Tags.DigitalInputMode:
+                    {
+                        if (Enum.TryParse(sVal, out DigitalInputModes im)) { sd.InputMode = im; }
+                    }
+                    break;
+
+                case CSVImportTags.Tags.DigitalOutputMode:
+                    {
+                        if (Enum.TryParse(sVal, out DigitalOutputModes om)) { sd.DigitalOutputMode = om; }
+                    }
+                    break;
+
+
+                case CSVImportTags.Tags.DigitalScaleMultiplier:
+                    if (!string.IsNullOrEmpty(sVal))
+                    {
+                        sd.ScaleMultiplier.FromDbSerializeString(sVal);
+                    }
+                    break;
+                case CSVImportTags.Tags.Direction:
+                    {
+                        if (sd.Direction == "?" && sd.Direction != sVal)
+                        {
+                            sd.Direction = sVal;
+                        }
+                    }
+                    break;
+
+                case CSVImportTags.Tags.DisplayUnits:
+                    {
+                        //Determine if we know about this display unit
+                        var calEU = MeasurementUnitList.GetMeasurementUnit(sc.Records.Records.First().EngineeringUnits);
+                        try
+                        {
+                            var unitConversion = calEU.GetScalerConversion(sVal);
+
+                            // Convert all the EU values to be represented in DisplayUnits 
+                            sd.RangeHigh *= unitConversion;
+                            sd.RangeMedium *= unitConversion;
+                            sd.RangeLow *= unitConversion;
+                            sd.Capacity *= unitConversion;
+                            sc.InitialOffsets.Offsets.First().EU *= unitConversion;
+                        }
+                        catch (Exception ex)
+                        {
+                            if (ex is InvalidCastException)
+                            {
+                                sd.DisplayUnit = sc.Records.Records.First().EngineeringUnits;
+                                // The units don't match what we are aware of. Lets move on.
+                                break;
+                            }
+                            _importNotification.ReportErrors(new List<string>() { ex.Message });
+                        }
+
+                        sd.DisplayUnit = sVal; break;
+                    }
+
+                case CSVImportTags.Tags.DurationMS:
+                    {
+                        if (double.TryParse(sVal, NumberStyles.Any, pp.ImportCulture, out var d)) { sd.DurationMS = d; }
+                    }
+                    break;
+
+                case CSVImportTags.Tags.DigitalOutputDurationMS:
+                    {
+                        if (double.TryParse(sVal, NumberStyles.Any, pp.ImportCulture, out var d)) { sd.DigitalOutputDurationMS = d; }
+                    }
+                    break;
+
+                case CSVImportTags.Tags.FiveVoltExcSensitivity:
+                    {
+                        if (double.TryParse(sVal, NumberStyles.Any, pp.ImportCulture, out var d))
+                        {
+                            pp.SensorCal = _calibrationImport.CheckForExcitationCalibration(sc, d, ExcitationVoltageOptions.ExcitationVoltageOption.Volt5, sd.DisplayUnit);
+                        }
+                    }
+                    break;
+
+                case CSVImportTags.Tags.InitialOffset: sc.InitialOffsets = new InitialOffsets(sVal); break;
+                case CSVImportTags.Tags.LimitDuration: sd.LimitDuration = sVal.ToLower() == "yes"; break;
+                case CSVImportTags.Tags.NonLinear: sc.NonLinear = sVal.ToLower() == "yes"; break;
+                case CSVImportTags.Tags.NonLinearCalibration:
+                    {
+                        sc.Records.Records[0].Poly.FromSerializeString(sVal);
+                        if (sc.Records.Records[0].Poly.IsValid()) { sc.NonLinear = true; }
+                    }
+                    break;
+                case CSVImportTags.Tags.NumberOfAxes:
+                    {
+                        if (short.TryParse(sVal, NumberStyles.Any, pp.ImportCulture, out var temp)) { sd.NumberOfAxes = temp; }
+                    }
+                    break;
+
+                case CSVImportTags.Tags.PhysicalDimension:
+                    {
+                        //if the physical dimension was already set by the ISOCode, don't reset it
+                        if (sd.PhysicalDimension == "??" && sd.PhysicalDimension != sVal)
+                        {
+                            sd.PhysicalDimension = sVal;
+                        }
+                    }
+                    break;
+
+                case CSVImportTags.Tags.Polarity: sd.Polarity = sVal; break;
+
+                case CSVImportTags.Tags.RangeHigh:
+                    {
+                        pp.ImportContainedSensorRanges = true;
+                        if (double.TryParse(sVal, NumberStyles.Any, pp.ImportCulture, out var d)) { sd.RangeHigh = d; }
+                    }
+                    break;
+
+                case CSVImportTags.Tags.RangeLow:
+                    {
+                        pp.ImportContainedSensorRanges = true;
+                        if (double.TryParse(sVal, NumberStyles.Any, pp.ImportCulture, out var d)) { sd.RangeLow = d; }
+                    }
+                    break;
+
+                case CSVImportTags.Tags.RangeMedium:
+                    {
+                        pp.ImportContainedSensorRanges = true;
+                        if (double.TryParse(sVal, NumberStyles.Any, pp.ImportCulture, out var d)) { sd.RangeMedium = d; }
+                    }
+                    break;
+
+                case CSVImportTags.Tags.SquibFireMode:
+                    {
+                        if (Enum.TryParse(sVal, out SquibFireMode sfm)) { sd.SquibFireMode = sfm; }
+                    }
+                    break;
+
+                case CSVImportTags.Tags.SquibMeasurementType:
+                    {
+                        if (Enum.TryParse(sVal, out SquibMeasurementType smt)) { sd.SquibMeasurementType = smt; }
+                    }
+                    break;
+
+                case CSVImportTags.Tags.SquibOutputCurrent:
+                    {
+                        if (double.TryParse(sVal, NumberStyles.Any, pp.ImportCulture, out var d)) { sd.SquibOutputCurrent = d; }
+                    }
+                    break;
+
+                case CSVImportTags.Tags.SupportedExcitation: sd.SetSupportedExcitationFromString(sVal); break;
+
+                case CSVImportTags.Tags.TenVoltExcSensitivity:
+                    {
+                        if (double.TryParse(sVal, NumberStyles.Any, pp.ImportCulture, out var d))
+                        {
+                            pp.SensorCal = _calibrationImport.CheckForExcitationCalibration(sc, d, ExcitationVoltageOptions.ExcitationVoltageOption.Volt10, sd.DisplayUnit);
+                        }
+                    }
+                    break;
+
+                case CSVImportTags.Tags.TimesUsed:
+                    {
+                        if (int.TryParse(sVal, NumberStyles.Any, pp.ImportCulture, out var temp)) { sd.TimesUsed = temp; }
+                    }
+                    break;
+
+                case CSVImportTags.Tags.TwoVoltExcSensitivity:
+                    {
+                        if (double.TryParse(sVal, NumberStyles.Any, pp.ImportCulture, out var d))
+                        {
+                            pp.SensorCal = _calibrationImport.CheckForExcitationCalibration(sc, d, ExcitationVoltageOptions.ExcitationVoltageOption.Volt2, sd.DisplayUnit);
+                        }
+                    }
+                    break;
+
+                case CSVImportTags.Tags.Unipolar: sd.UniPolar = sVal.ToLower() == "yes"; break;
+
+                case CSVImportTags.Tags.Unknown: break;
+
+                case CSVImportTags.Tags.ZeroMethod:
+                    {
+                        if (Enum.TryParse(sVal, out ZeroMethodType zmt))
+                        {
+                            sc.ZeroMethods.Methods.First().Method = zmt;
+                            pp.ZeroType = zmt;
+                        }
+                    }
+                    break;
+
+                case CSVImportTags.Tags.ZeroMethodEnd:
+                    {
+                        if (double.TryParse(sVal, NumberStyles.Any, pp.ImportCulture, out var zeroMethodEnd))
+                        {
+                            sc.ZeroMethods.Methods.First().End = zeroMethodEnd;
+                            pp.ZeroEnd = zeroMethodEnd;
+                        }
+                    }
+                    break;
+
+                case CSVImportTags.Tags.ZeroMethodStart:
+                    {
+                        if (double.TryParse(sVal, NumberStyles.Any, pp.ImportCulture, out var zeroMethodStart))
+                        {
+                            sc.ZeroMethods.Methods.First().Start = zeroMethodStart;
+                            pp.ZeroStart = zeroMethodStart;
+                        }
+                    }
+                    break;
+
+                case CSVImportTags.Tags.AtCapacity:
+                    {
+                        sc.Records.Records.First().AtCapacity = sVal.ToLower() == "yes";
+                    }
+                    break;
+                case CSVImportTags.Tags.CapacityOutputIsBasedOn:
+                    {
+                        if (double.TryParse(sVal, NumberStyles.Any, pp.ImportCulture, out var temp))
+                        {
+                            sc.Records.Records.First().CapacityOutputIsBasedOn = temp;
+                        }
+                    }
+                    break;
+                case CSVImportTags.Tags.SensitivityUnits:
+                    {
+                        if (!string.IsNullOrEmpty(sVal))
+                        {
+                            sc.Records.Records.First().SensitivityUnits = SensUnitStringConverter.ConvertFromString(sVal);
+                        }
+                    }
+                    break;
+
+                case CSVImportTags.Tags.CheckOffset: { sd.CheckOffset = sVal.ToLower() == "yes"; } break;
+                case CSVImportTags.Tags.Broken: { sd.Broken = sVal.ToLower() == "yes"; } break;
+                case CSVImportTags.Tags.DoNotUse: { sd.DoNotUse = sVal.ToLower() == "yes"; } break;
+                case CSVImportTags.Tags.ISOChannelName: { sd.ISOChannelName = sVal; } break;
+                case CSVImportTags.Tags.UserCode: { sd.UserCode = sVal; } break;
+                case CSVImportTags.Tags.UserChannelName: { sd.UserChannelName = sVal; } break;
+                default: throw new NotSupportedException("Unknown field: " + field);
+            }
+            #endregion and another very long switch statement
+        }
+    }
+}

Common/DTS.Common.Import/Parsers/CSV/Version3CSVSensorParser.cs

@@ -0,0 +1,68 @@
+using DTS.Common.Classes.Sensors;
+using DTS.Common.Enums.Sensors;
+using DTS.Common.SharedResource.Strings;
+using System;
+
+namespace DTS.Common.Import.Parsers.CSV
+{
+    public class Version3CSVSensorParser : AbstractCSVParser
+    {
+        public override int Version => 3;
+        public override void ParseVersion(CSVImportTags.Tags field, string sVal, ParseParameters pp)
+        {
+            switch (field)
+            {
+                case CSVImportTags.Tags.GroupName:
+                    // check sval for empty                            
+                    if (string.IsNullOrEmpty(sVal) || string.IsNullOrWhiteSpace(sVal))
+                    {
+                        pp.Errors.Add(string.Format(StringResources.ImportSensorsPreviewControl_CSVImport_NoGroupNameFound, pp.SensorData.SerialNumber));
+                        return;
+                    }
+                    // check duplicate sd.serialnumber
+                    if (pp.SensorGroupNameLookup.ContainsKey(pp.SensorData.SerialNumber))
+                    {
+                        pp.Errors.Add(string.Format(StringResources.ImportSensorsPreviewControl_CSVImport_DuplicateSensorSN, pp.SensorData.SerialNumber));
+                        return;
+                    }
+                    pp.SensorGroupNameLookup.Add(pp.SensorData.SerialNumber, sVal);
+                    if (!pp.GroupNameToTestObjectLookup.ContainsKey(sVal))
+                    {
+                        pp.GroupNameToTestObjectLookup.Add(sVal, pp.SensorTestObject);
+                    }
+                    else
+                    {
+                        if (pp.GroupNameToTestObjectLookup[sVal] != pp.SensorTestObject && !ImportCreateDynamicGroups)
+                        {
+                            var errorMessage =
+                                string.Format(StringResources.CSVImportMultipleTestObjectsInGroup,
+                                    sVal);
+                            if (!pp.Errors.Contains(errorMessage))
+                            {
+                                pp.Errors.Add(errorMessage);
+                            }
+                            throw new Exception("Parse error");
+                        }
+                    }
+                    break;
+                case CSVImportTags.Tags.GroupType:
+                    // check sval for empty                            
+                    if (string.IsNullOrEmpty(sVal) || string.IsNullOrWhiteSpace(sVal))
+                    {
+                        pp.Errors.Add(string.Format(StringResources.ImportSensorsPreviewControl_CSVImport_NoGroupTypeFound, pp.SensorData.SerialNumber));
+                        return;
+                    }
+                    // check duplicate sd.serialnumber
+                    if (pp.SensorGroupTypeLookup.ContainsKey(pp.SensorData.SerialNumber))
+                    {
+                        pp.Errors.Add(string.Format(StringResources.ImportSensorsPreviewControl_CSVImport_DuplicateSensorSN, pp.SensorData.SerialNumber));
+                        return;
+                    }
+                    pp.SensorGroupTypeLookup.Add(pp.SensorData.SerialNumber, sVal);
+                    break;
+                case CSVImportTags.Tags.Unknown: break;
+                default: throw new NotSupportedException("Unknown field: " + field);
+            }
+        }
+    }
+}

Common/DTS.Common.Import/Parsers/CSV/Version4CSVSensorParser.cs

@@ -0,0 +1,127 @@
+using DTS.Common.Classes.Sensors;
+using DTS.Common.Enums;
+using DTS.Common.Enums.Sensors;
+using System;
+using System.IO.Ports;
+
+namespace DTS.Common.Import.Parsers.CSV
+{
+    public class Version4CSVSensorParser : AbstractCSVParser
+    {
+        public override int Version => 4;
+        public override void ParseVersion(CSVImportTags.Tags field, string sVal, ParseParameters pp)
+        {
+            switch (field)
+            {
+                case CSVImportTags.Tags.DASSerialNumber:
+                    pp.SensorDASSerialNumber[pp.SensorData.SerialNumber] = sVal;
+                    break;
+                case CSVImportTags.Tags.DASChannelIndex:
+                    {
+                        if (int.TryParse(sVal, out var iTemp))
+                        {
+                            pp.SensorDASChannelIndex[pp.SensorData.SerialNumber] = iTemp;
+                        }
+                    }
+                    break;
+                case CSVImportTags.Tags.StreamProfile:
+                    if (Enum.TryParse(sVal, out UDPStreamProfile profile))
+                    {
+                        pp.SensorData.StreamOutUDPProfile = profile;
+                    }
+                    break;
+                case CSVImportTags.Tags.UDPAddress:
+                    pp.SensorData.StreamInUDPAddress = sVal;
+                    pp.SensorData.StreamOutUDPAddress = sVal;
+                    break;
+                case CSVImportTags.Tags.TimeChannelId:
+                    {
+                        if (ushort.TryParse(sVal, out var uTemp))
+                        {
+                            pp.SensorData.StreamOutUDPTimeChannelId = uTemp;
+                        }
+                    }
+                    break;
+                case CSVImportTags.Tags.DataChannelId:
+                    {
+                        if (ushort.TryParse(sVal, out var uTemp))
+                        {
+                            pp.SensorData.StreamOutUDPDataChannelId = uTemp;
+                        }
+                    }
+                    break;
+                case CSVImportTags.Tags.TmNSConfig:
+                    pp.SensorData.StreamOutUDPTmNSConfig = sVal;
+                    break;
+                case CSVImportTags.Tags.IRIGTimeDataPacketIntervalMS:
+                    {
+                        if (ushort.TryParse(sVal, out var uTemp))
+                        {
+                            pp.SensorData.StreamOutIRIGTimeDataPacketIntervalMs = uTemp;
+                        }
+                    }
+                    break;
+                case CSVImportTags.Tags.TMATSIntervalMS:
+                    {
+                        if (ushort.TryParse(sVal, out var uTemp))
+                        {
+                            pp.SensorData.StreamOutTMATSIntervalMs = uTemp;
+                        }
+                    }
+                    break;
+                case CSVImportTags.Tags.BaudRate:
+                    {
+                        if (uint.TryParse(sVal, out var iTemp))
+                        {
+                            pp.SensorData.UartBaudRate = iTemp;
+                        }
+                    }
+                    break;
+                case CSVImportTags.Tags.DataBits:
+                    {
+                        if (uint.TryParse(sVal, out var iTemp))
+                        {
+                            pp.SensorData.UartDataBits = iTemp;
+                        }
+                    }
+                    break;
+                case CSVImportTags.Tags.StopBits:
+                    {
+                        if (Enum.TryParse(sVal, out StopBits stopBits))
+                        {
+                            pp.SensorData.UartStopBits = stopBits;
+                        }
+                    }
+                    break;
+                case CSVImportTags.Tags.Parity:
+                    {
+                        if (Enum.TryParse(sVal, out Parity parity))
+                        {
+                            pp.SensorData.UartParity = parity;
+                        }
+                    }
+                    break;
+                case CSVImportTags.Tags.DataFormat:
+                    {
+                        if (Enum.TryParse(sVal, out UartDataFormat dataFormat))
+                        {
+                            pp.SensorData.UartDataFormat = dataFormat;
+                        }
+                    }
+                    break;
+                case CSVImportTags.Tags.TestUserCode:
+                    pp.SensorUserCode[pp.SensorData.SerialNumber] = sVal;
+                    break;
+                case CSVImportTags.Tags.TestUserChannelName:
+                    pp.SensorUserChannelName[pp.SensorData.SerialNumber] = sVal;
+                    break;
+                case CSVImportTags.Tags.TestIsoCode:
+                    pp.SensorISOCode[pp.SensorData.SerialNumber] = sVal;
+                    break;
+                case CSVImportTags.Tags.TestIsoChannelName:
+                    pp.SensorISOChannelName[pp.SensorData.SerialNumber] = sVal;
+                    break;
+            }
+        }
+    }
+}

Common/DTS.Common.Import/Parsers/CSV/Version5CSVTestParser.cs

@@ -0,0 +1,93 @@
+using CsvHelper;
+using DTS.Common.Classes;
+using DTS.Common.Enums.Sensors;
+using DTS.Common.Import.Interfaces;
+using System;
+using System.Collections.Generic;
+
+namespace DTS.Common.Import.Parsers.CSV
+{
+    public class Version5CSVTestParser : IParseCSVTest
+    {
+        private InputClockSource ParseInputClockSource(string val)
+        {
+            return Enum.TryParse(val, out InputClockSource source) ? source : default;
+        }
+
+        private OutputClockSource ParseOutputClockSource(string val)
+        {
+            return Enum.TryParse(val, out OutputClockSource source) ? source : default;
+        }
+
+        private static bool ParseBoolValue(string val)
+        {
+            return bool.TryParse(val, out var bTemp) ? bTemp : default;
+        }
+
+        public int Version => 5;
+        public void ParseVersion(CsvReader csvReader, TestSetupImportData tsid)
+        {
+            var foundHeader = false;
+            List<string> tokens = new List<string>();
+            while (!foundHeader && csvReader.Read())
+            {
+                tokens = CsvUtil.ReadFields(csvReader, false);
+
+                if (null == tokens) { return; }
+                if (0 == tokens.Count || string.IsNullOrEmpty(tokens[0])) { continue; }
+                var field = CSVImportTags.GetTagForString(tokens[0]);
+                var version = CSVImportTags.GetVersionForTag(field);
+                if (version != 5) { return; } //no version 5 tokens in here ...
+                foundHeader = true;
+            }
+
+            var tokens2 = CsvUtil.ReadFields(csvReader);
+
+            if (null == tokens2) { return; }
+
+            for (var i = 0; i < tokens.Count && i < tokens2.Count; i++)
+            {
+                GetValueForField(tsid, tokens, tokens2, i);
+            }
+        }
+
+        private void GetValueForField(TestSetupImportData tsid, List<string> tokens, List<string> tokens2, int index)
+        {
+            var field = CSVImportTags.GetTagForString(tokens[index]);
+            var val = tokens2[index];
+            switch (field)
+            {
+                case CSVImportTags.Tags.ClockMasterInputType:
+                    {
+                        tsid.ClockMasterInput = ParseInputClockSource(val);
+                    }
+                    break;
+                case CSVImportTags.Tags.ClockMasterOutputType:
+                    {
+                        tsid.ClockMasterOutput = ParseOutputClockSource(val);
+                    }
+                    break;
+                case CSVImportTags.Tags.ManageClocksOutsideDPMaster:
+                    {
+                        tsid.ManageClocksOutsideOfDataPROMaster = ParseBoolValue(val);
+                    }
+                    break;
+                case CSVImportTags.Tags.ManageClocksOutsideDPSlave:
+                    {
+                        tsid.ManageClocksOutsideOfDataPROSlave = ParseBoolValue(val);
+                    }
+                    break;
+                case CSVImportTags.Tags.ClockSlaveInputType:
+                    {
+                        tsid.ClockSlaveInput = ParseOutputClockSource(val);
+                    }
+                    break;
+                case CSVImportTags.Tags.ClockSlaveOutputType:
+                    {
+                        tsid.ClockSlaveOutput = ParseOutputClockSource(val);
+                    }
+                    break;
+            }
+        }
+    }
+}

Common/DTS.Common.Import/Parsers/CSV/Version6CSVTestParser.cs

@@ -0,0 +1,80 @@
+using CsvHelper;
+using DTS.Common.Classes;
+using DTS.Common.Enums.Sensors;
+using DTS.Common.Import.Interfaces;
+using System.Collections.Generic;
+
+namespace DTS.Common.Import.Parsers.CSV
+{
+    public class Version6CSVTestParser : IParseCSVTest
+    {
+        public int Version => 6;
+        public void ParseVersion(CsvReader csvReader, TestSetupImportData tsid)
+        {
+            var foundHeader = false;
+            List<string> tokens = new List<string>();
+            while (!foundHeader && csvReader.Read())
+            {
+                tokens = CsvUtil.ReadFields(csvReader, false);
+                if (null == tokens) { return; }
+                if (0 == tokens.Count || string.IsNullOrEmpty(tokens[0])) { continue; }
+                var field = CSVImportTags.GetTagForString(tokens[0]);
+                var version = CSVImportTags.GetVersionForTag(field);
+                if (version != 6) { return; } //no version 5 tokens in here ...
+                foundHeader = true;
+            }
+
+            ReadBody(csvReader, tsid, tokens);
+        }
+
+        private static int ParseIntValue(string val)
+        {
+            return int.TryParse(val, out var iTemp) ? iTemp : default;
+        }
+        private static bool ParseBoolValue(string val)
+        {
+            return bool.TryParse(val, out var bTemp) ? bTemp : default;
+        }
+
+        private static void ReadBody(CsvReader csvReader, TestSetupImportData testSetupImportData, List<string> tokens)
+        {
+            while (csvReader.Read())
+            {
+                var tokens2 = CsvUtil.ReadFields(csvReader, false);
+                if (null == tokens2 || 0 == tokens2.Count || string.IsNullOrWhiteSpace(tokens2[1]))
+                {
+                    //we found a new line, we are done with this table
+                    break;
+                }
+                var dasSerial = string.Empty;
+                for (var i = 0; i < tokens.Count && i < tokens2.Count; i++)
+                {
+                    var field = CSVImportTags.GetTagForString(tokens[i]);
+                    var val = tokens2[i];
+
+                    switch (field)
+                    {
+                        case CSVImportTags.Tags.DASSerial:
+                            dasSerial = val;
+                            break;
+                        case CSVImportTags.Tags.DASSampleRate:
+                            {
+                                testSetupImportData.SampleRateForDAS[dasSerial] = ParseIntValue(val);
+                            }
+                            break;
+                        case CSVImportTags.Tags.PTPDomainId:
+                            {
+                                testSetupImportData.DomainIdForDAS[dasSerial] = (uint)ParseIntValue(val);
+                            }
+                            break;
+                        case CSVImportTags.Tags.ClockMaster:
+                            {
+                                testSetupImportData.IsClockMaster[dasSerial] = ParseBoolValue(val);
+                            }
+                            break;
+                    }
+                }
+            }
+        }
+    }
+}