init

Common/DTS.Common.Import/XML/XMLParseBase.cs

@@ -0,0 +1,48 @@
+using DTS.Common.Import.Interfaces;
+using System;
+using System.Collections.Generic;
+using System.Xml;
+
+namespace DTS.Common.Import.XML
+{
+    public abstract class XMLParseBase : IParseVariant
+    {
+        protected static readonly Dictionary<int, int> _dasIdMapping = new Dictionary<int, int>();
+        //Use string to handle both new (Id (int.ToString())) and old (Name (string)) exports
+        protected static readonly Dictionary<string, int> _groupIdMapping = new Dictionary<string, int>();
+        protected static readonly Dictionary<int, int> _sensorIdMapping = new Dictionary<int, int>();
+        protected static readonly Dictionary<long, long> _channelIdMapping = new Dictionary<long, long>();
+
+        protected double _importedVersion;
+
+        protected readonly Func<bool> IsCancelled;
+        protected readonly XmlElement _root;
+        protected XmlWriter _writer;
+
+        protected bool _skipNormalizing;
+        private readonly XmlDocument _doc;
+
+        public string FileName { get; set; }
+        public abstract void Parse(ref ImportObject importObject);
+
+        protected XMLParseBase(XmlElement root, double importedVersion, Func<bool> isCancelled = null, bool skipNormalizing = false)
+        {
+            _importedVersion = importedVersion;
+
+            IsCancelled = isCancelled == null ? () => false : isCancelled;
+
+            _root = root;
+
+            _skipNormalizing = skipNormalizing;
+            _doc = new XmlDocument();
+            _writer = _doc.CreateNavigator().AppendChild();
+        }
+
+        protected XmlElement GetXmlElement()
+        {
+            _writer.Close();
+            return _doc.DocumentElement;
+        }
+
+    }
+}

Common/DTS.Common.Import/XML/XMLParseCalibrations.cs

@@ -0,0 +1,91 @@
+using DTS.Common.Enums.DBExport;
+using DTS.Common.Enums.Sensors;
+using DTS.Common.Import.Interfaces;
+using DTS.Common.Interface;
+using DTS.Common.Utils;
+using DTS.SensorDB;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using System.Xml;
+
+namespace DTS.Common.Import.XML
+{
+    public class XMLParseCalibrations : XMLParseBase
+    {
+        public XMLParseCalibrations(XmlElement root, double importedVersion, Func<bool> isCancelled = null) : base(root, importedVersion, isCancelled)
+        {
+        }
+        public IImportNotification ImportNotification { get; set; }
+        public override void Parse(ref ImportObject importObject)
+        {
+            ImportNotification?.SetStatus(new ImportStatus { PossibleStatus = Enums.PossibleStatus.Reading, ExtraStatus = Enums.ImportExtraStatus.ReadingCalibrations });
+            var scs = ParseCalibrations(_root);
+            var newRoot = ConvertCalibrations(scs);
+            importObject.AddCalibrations(ParseCalibrations(newRoot));
+
+        }
+        public XmlElement ConvertCalibrations(IEnumerable<SensorCalibration> calibrations)
+        {
+            _writer.WriteStartElement(TopLevelFields.Calibrations.ToString());
+            foreach (var c in calibrations)
+            {
+                _writer.Flush();
+                c.WriteXML(ref _writer);
+                _writer.Flush();
+            }
+            _writer.WriteEndElement();
+            return GetXmlElement();
+        }
+
+        public IEnumerable<SensorCalibration> ParseCalibrations(XmlElement root)
+        {
+            List<SensorCalibration> scs = new List<SensorCalibration>();
+            if (_importedVersion >= FileUtils.DataPROPre20XmlVersion)
+            {
+                foreach (var node in root.ChildNodes)
+                {
+                    if (IsCancelled()) { return scs; }
+                    if (node is XmlElement)
+                    {
+                        var sc = new SensorCalibration();
+                        sc.ReadXML(node as XmlElement);
+                        scs.Add(sc);
+                    }
+                }
+            }
+            if (_importedVersion == 1.0D)
+            {
+                foreach (var node in root.ChildNodes)
+                {
+                    if (IsCancelled()) { return scs; }
+                    if (node is XmlElement)
+                    {
+                        var sc = new SensorCalibration();
+                        sc.ReadXML(node as XmlElement);
+
+                        sc.Records.Records[0].AtCapacity = false;
+
+                        if (sc.NonLinear)
+                        {
+                            sc.Records.Records[0].SensitivityUnits = SensorConstants.SensUnits.NONE;
+                        }
+                        else if (sc.IsProportional)
+                        {
+                            sc.Records.Records[0].SensitivityUnits = SensorConstants.SensUnits.mVperVperEU;
+                        }
+                        else
+                        {
+                            sc.Records.Records[0].SensitivityUnits = SensorConstants.SensUnits.mVperEU;
+                        }
+                        scs.Add(sc);
+                    }
+                }
+            }
+            return scs;
+        }
+
+    }
+}

Common/DTS.Common.Import/XML/XMLParseCustomerDetails.cs

@@ -0,0 +1,55 @@
+using DTS.Common.Enums.DBExport;
+using DTS.Common.Import.Interfaces;
+using DTS.Common.Interface.Groups.GroupList;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using System.Xml;
+
+namespace DTS.Common.Import.XML
+{
+    public class XMLParseCustomerDetails : XMLParseBase
+    {
+        public XMLParseCustomerDetails(XmlElement root, double importedVersion, Func<bool> isCancelled = null) : base(root, importedVersion, isCancelled)
+        {
+        }
+        public IImportNotification ImportNotification { get; set; }
+        public override void Parse(ref ImportObject importObject)
+        {
+            ImportNotification?.SetStatus(new ImportStatus { PossibleStatus = Enums.PossibleStatus.Reading, ExtraStatus = Enums.ImportExtraStatus.ReadingCustomerDetails });
+            var customerDetails = ParseCustomerDetails(_root);
+            var newRoot = ConvertCustomerDetails(customerDetails);
+            customerDetails = ParseCustomerDetails(newRoot);
+            importObject.AddCustomerDetailsList(customerDetails);
+        }
+
+        private XmlElement ConvertCustomerDetails(IEnumerable<ISO.CustomerDetails> customerDetails)
+        {
+            _writer.WriteStartElement(TopLevelFields.CustomerDetails.ToString());
+            foreach (var c in customerDetails)
+            {
+                _writer.Flush();
+                c.WriteXML(ref _writer);
+                _writer.Flush();
+            }
+
+            _writer.WriteEndElement();
+            return GetXmlElement();
+        }
+        private List<ISO.CustomerDetails> ParseCustomerDetails(XmlElement root)
+        {
+            List<ISO.CustomerDetails> customerDetails = new List<ISO.CustomerDetails>();
+            foreach (var node in root.ChildNodes)
+            {
+                if (IsCancelled()) { return customerDetails; }
+                if (node is XmlElement)
+                {
+                    customerDetails.Add(ISO.CustomerDetails.ReadXML(node as XmlElement));
+                }
+            }
+            return customerDetails;
+        }
+    }
+}

Common/DTS.Common.Import/XML/XMLParseDASList.cs

@@ -0,0 +1,78 @@
+using DataPROWin7.DataModel;
+using DTS.Common.Enums.DBExport;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Xml;
+
+namespace DTS.Common.Import.XML
+{
+    public class XMLParseDASList : XMLParseBase
+    {
+        public XMLParseDASList(XmlElement root, double importedVersion, Func<bool> isCancelled = null, bool skipNormalizing=false) : base(root, importedVersion, isCancelled, skipNormalizing)
+        {
+            _dasIdMapping.Clear();
+        }
+        public IImportNotification ImportNotification { get; set; }
+        public List<DASHardware> ParseDASList(XmlElement root)
+        {
+            List<DASHardware> dasList = new List<DASHardware>();
+            var invalidDAS = new List<string>();
+            foreach (var node in root.ChildNodes)
+            {
+                if (IsCancelled()) { return dasList; }
+                if (node is XmlElement)
+                {
+                    var isoHardware = DASHardware.ReadXML(node as XmlElement);
+                    if (Enum.IsDefined(typeof(DTS.Common.Enums.Hardware.HardwareTypes), isoHardware.DASType))
+                    {
+                        dasList.Add(new DASHardware(isoHardware));
+                    }
+                    else
+                    {
+                        invalidDAS.Add(isoHardware.SerialNumber);
+                    }
+                }
+            }
+            if (invalidDAS.Any())
+            {
+                //???
+            }
+            return dasList;
+        }
+
+        private XmlElement ConvertDASList(List<DASHardware> dasList)
+        {
+            _writer.WriteStartElement(TopLevelFields.DASList.ToString());
+            var count = -2; //Start the normalization at -2, since channels have a DASId of -1 if unassigned (FB 13544)
+            foreach (var h in dasList)
+            {
+                _dasIdMapping[h.DASId] = count;
+                h.SetDASId(count);
+                count--;
+
+                _writer.Flush();
+                h.WriteXML(ref _writer);
+                _writer.Flush();
+            }
+            _writer.WriteEndElement();
+
+            return GetXmlElement();
+        }
+
+
+        public override void Parse(ref ImportObject importObject)
+        {
+            ImportNotification?.SetStatus(new ImportStatus { PossibleStatus = Enums.PossibleStatus.Reading, ExtraStatus = Enums.ImportExtraStatus.ReadingHardware });
+            var dasList = ParseDASList(_root);
+            if (!_skipNormalizing)
+            {
+                var newRoot = ConvertDASList(dasList);
+                dasList = ParseDASList(newRoot);
+            }
+            importObject.AddHardwareList(dasList);
+        }
+
+    }
+}
+

Common/DTS.Common.Import/XML/XMLParseGlobalSettings.cs

@@ -0,0 +1,62 @@
+using DTS.Common.Import.Interfaces;
+using DTS.Common.Interface;
+using System;
+using System.Collections.Generic;
+using System.Xml;
+
+namespace DTS.Common.Import.XML
+{
+    public class XMLParseGlobalSettings : XMLParseBase
+    {
+        public XMLParseGlobalSettings(XmlElement root, double importedVersion, Func<bool> isCancelled = null) : base(root, importedVersion, isCancelled)
+        {
+        }
+        public IImportNotification ImportNotification { get; set; }
+        public override void Parse(ref ImportObject importObject)
+        {
+            importObject.AssignGlobalSettings(ParseGlobalSettings(_root));
+        }
+
+        private Dictionary<string, string> ParseGlobalSettings(XmlElement root)
+        {
+            Dictionary<string, string> settings = new Dictionary<string, string>();
+
+            foreach (var child in root.ChildNodes)
+            {
+                if (IsCancelled()) { return settings; }
+                if (child is XmlElement)
+                {
+                    GetGlobalSetting(child as XmlElement, ref settings);
+                }
+            }
+            return settings;
+        }
+
+        private void GetGlobalSetting(XmlElement node, ref Dictionary<string, string> settings)
+        {
+            string sName = "", sValue = "";
+            foreach (var child in node.ChildNodes)
+            {
+                if (child is XmlElement)
+                {
+                    var childNode = child as XmlElement;
+                    switch (childNode.Name)
+                    {
+                        case "SettingName":
+                            sName = childNode.InnerText;
+                            break;
+                        case "SettingValue":
+                            sValue = childNode.InnerText;
+                            break;
+                    }
+                }
+            }
+            if (!string.IsNullOrWhiteSpace(sName))
+            {
+                settings[sName] = sValue;
+            }
+        }
+    }
+}
+
+

Common/DTS.Common.Import/XML/XMLParseGroupTemplates.cs

@@ -0,0 +1,62 @@
+using DTS.Common.Import.Interfaces;
+using DTS.Common.SharedResource.Strings;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using System.Xml;
+
+namespace DTS.Common.Import.XML
+{
+    public class XMLParseGroupTemplates : XMLParseBase
+    {
+        private ISO.ISO13499FileDb _iSO13499FileDb;
+        public XMLParseGroupTemplates(XmlElement root, double importedVersion, ISO.ISO13499FileDb iSO13499FileDb,
+           Func<bool> isCancelled = null) : base(root, importedVersion, isCancelled)
+        {
+            _iSO13499FileDb = iSO13499FileDb;
+        }
+        public override void Parse(ref ImportObject importObject)
+        {
+            var groupTemplates = ParseGroupTemplates(ref importObject, _root);
+            importObject.AddGroupTemplates(groupTemplates);
+        }
+        public IEnumerable<DataPROWin7.DataModel.TestObjectTemplate> ParseGroupTemplates(ref ImportObject importObject, XmlElement root)
+        {
+            List<DataPROWin7.DataModel.TestObjectTemplate> groupTemplates = new List<DataPROWin7.DataModel.TestObjectTemplate>();
+
+            var importChannels = new Dictionary<long, ISO.MMEPossibleChannels>();
+            foreach (var channel in importObject.CustomChannels())
+            {
+                if (IsCancelled())
+                {
+                    return groupTemplates;
+                }
+                importChannels[channel.Id] = channel;
+            }
+
+            foreach (var node in root.ChildNodes)
+            {
+                if (IsCancelled())
+                {
+                    return groupTemplates;
+                }
+                if (!(node is XmlElement)) continue;
+                var template = DataPROWin7.DataModel.TestObjectTemplate.ReadXML(node as XmlElement, importChannels);
+                template.Embedded = template.SysBuilt || template.Embedded; // If this is an old Dynamic Group or a new Added Group, by definition it's embedded.
+                if (template.SysBuilt)
+                {
+                    template.OriginalTemplateName = template.TemplateName;
+                }
+                groupTemplates.Add(new DataPROWin7.DataModel.TestObjectTemplate(template, ref _iSO13499FileDb, importObject.TestObjects()?.ToList()));
+                if (null == groupTemplates.Last().TestObject)
+                {
+                    //FB8790 - TestSetup with a custom ISO testobject that is not available in the export file has an ambiguous error message.
+                    throw new NotSupportedException(string.Format(StringResources.ImportTestSetup_ISOTestObjectNotFoundInImportFile, template.TemplateNameOrOriginalTemplateName, template.TestObject));
+                }
+            }
+            return groupTemplates;
+        }
+    }
+}

Common/DTS.Common.Import/XML/XMLParseGroups.cs

@@ -0,0 +1,128 @@
+using DTS.Common.Enums.DBExport;
+using DTS.Common.Interface.Groups.GroupList;
+using DTS.Common.Utils;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Xml;
+
+namespace DTS.Common.Import.XML
+{
+    public class XMLParseGroups : XMLParseBase
+    {
+
+        public XMLParseGroups(XmlElement root, double importedVersion, Func<bool> isCancelled = null) : base(root, importedVersion, isCancelled)
+        {
+            _groupIdMapping.Clear();
+        }
+        public IImportNotification ImportNotification { get; set; }
+        public override void Parse(ref ImportObject importObject)
+        {
+            ImportNotification?.SetStatus(new ImportStatus { PossibleStatus = Enums.PossibleStatus.Reading, ExtraStatus = Enums.ImportExtraStatus.ReadingGroups });
+            var staticGroups = ParseGroups(_root, ref importObject);
+            if (!staticGroups.Any())
+            {
+                return;
+            }
+            var newRoot = ConvertGroups(staticGroups);
+            if (newRoot == null)
+            {
+                return;
+            }
+            staticGroups = ParseGroups(newRoot, ref importObject);
+            importObject.AddStaticGroups(staticGroups);
+
+        }
+        private XmlElement ConvertGroups(List<IGroup> staticGroups)
+        {
+            _writer.WriteStartElement(TopLevelFields.Groups.ToString());
+            var count = -2; //Start the normalization at -2, to be consistent with channel mapping(?)
+            foreach (var g in staticGroups)
+            {
+                if (_importedVersion >= FileUtils.DataPRO21XmlVersion)
+                {
+                    _groupIdMapping[g.Id.ToString()] = count;
+                }
+                else
+                {
+                    //Must be an export from 2.0 or earlier
+                    _groupIdMapping[g.Name] = count;
+                }
+                g.Id = count;
+                count--;
+                foreach (var channel in g.GroupChannelList)
+                {
+                    if (_dasIdMapping.ContainsKey(channel.DASId))
+                    {
+                        channel.DASId = _dasIdMapping[channel.DASId];
+                    }
+                    if (_sensorIdMapping.ContainsKey(channel.SensorId))
+                    {
+                        channel.SensorId = _sensorIdMapping[channel.SensorId];
+                    }
+                    else
+                    {
+                        //FB 14308 - Don't fail Group import if it was 
+                        //exported with a deleted sensor.
+                        channel.SensorId = 0;
+                    }
+                }
+                _writer.Flush();
+                g.WriteXML(ref _writer);
+                _writer.Flush();
+            }
+            _writer.WriteEndElement();
+            return GetXmlElement();
+
+        }
+
+        public List<IGroup> ParseGroups(XmlElement root, ref ImportObject importObject)
+        {
+            List<IGroup> staticGroups = new List<IGroup>();
+            var importedHardware = new Dictionary<string, DataPROWin7.DataModel.DASHardware>();
+            foreach (var h in importObject.Hardware())
+            {
+                importedHardware[h.GetHardware().GetId()] = h;
+            }
+            foreach (var node in root.ChildNodes)
+            {
+                if (IsCancelled()) { return staticGroups; }
+                if (!(node is XmlElement)) continue;
+
+                IGroup groupInstance = GroupHelper.CreateEmptyGroup();
+                if (groupInstance != null)
+                {
+                    var channelLookup = new Dictionary<long, Interface.Channels.IGroupChannel>();
+                    var iSensors = new List<Interface.Sensors.ISensorData>();
+                    foreach (var sensor in importObject.Sensors())
+                    {
+                        iSensors.Add(sensor);
+                    }
+                    var g = groupInstance.ReadXML(node as XmlElement, channelLookup, iSensors);
+                    if (!string.IsNullOrWhiteSpace(g.Name))
+                    {
+                        var groupCopy = GroupHelper.CreateEmptyGroup();
+                        groupCopy.Name = g.Name;
+                        //FB 44143 assign description
+                        groupCopy.Description = g.Description;
+                        groupCopy.DisplayName = g.Name;
+                        groupCopy.LastModified = g.LastModified;
+                        groupCopy.Embedded = g.Embedded;
+                        groupCopy.IncludedHardwareStringList = g.IncludedHardwareStringList;
+                        groupCopy.Id = g.Id;
+                        groupCopy.Tags = g.Tags;
+                        staticGroups.Add(groupCopy);
+
+                        foreach (var channel in channelLookup.Select(p => p.Value))
+                        {
+                            channel.Group = groupCopy;
+                            groupCopy.GroupChannelList.Add(channel);
+                        }
+                    }
+                }
+            }
+            return staticGroups;
+
+        }
+    }
+}

Common/DTS.Common.Import/XML/XMLParseLabDetails.cs

@@ -0,0 +1,58 @@
+using DTS.Common.Enums.DBExport;
+using DTS.Common.Import.Interfaces;
+using DTS.Common.Interface.Groups.GroupList;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using System.Xml;
+
+namespace DTS.Common.Import.XML
+{
+    public class XMLParseLabDetails : XMLParseBase
+    {
+        public XMLParseLabDetails(XmlElement root, double importedVersion, Func<bool> isCancelled = null) : base(root, importedVersion, isCancelled)
+        {
+        }
+        public IImportNotification ImportNotification { get; set; }
+
+        public override void Parse(ref ImportObject importObject)
+        {
+            ImportNotification?.SetStatus(new ImportStatus { PossibleStatus = Enums.PossibleStatus.Reading, ExtraStatus = Enums.ImportExtraStatus.ReadingLabDetails });
+            var details = ParseLabDetails(_root);
+            var newRoot = ConvertLabDetails(details);
+            details = ParseLabDetails(newRoot);
+            importObject.AddLabDetailsList(details);
+        }
+
+        private XmlElement ConvertLabDetails(IEnumerable<ISO.LabratoryDetails> details)
+        {
+            _writer.WriteStartElement(TopLevelFields.LabDetails.ToString());
+            foreach (var c in details)
+            {
+                _writer.Flush();
+                c.WriteXML(ref _writer);
+                _writer.Flush();
+            }
+
+            _writer.WriteEndElement();
+            return GetXmlElement();
+        }
+        private List<ISO.LabratoryDetails> ParseLabDetails(XmlElement root)
+        {
+            List<ISO.LabratoryDetails> details = new List<ISO.LabratoryDetails>();
+            foreach (var node in root.ChildNodes)
+            {
+                if (IsCancelled()) { return details; }
+                if (node is XmlElement)
+                {
+                    details.Add(ISO.LabratoryDetails.ReadXML(node as XmlElement));
+                }
+            }
+            return details;
+        }
+    }
+}
+
+

Common/DTS.Common.Import/XML/XMLParseMMECustomChannels.cs

@@ -0,0 +1,33 @@
+using DTS.Common.Import.Interfaces;
+using System;
+using System.Collections.Generic;
+using System.Xml;
+
+namespace DTS.Common.Import.XML
+{
+    public class XMLParseMMECustomChannels : XMLParseBase
+    {
+        public XMLParseMMECustomChannels(XmlElement root, double importedVersion, Func<bool> isCancelled = null) : base(root, importedVersion, isCancelled)
+        {
+        }
+        public IImportNotification ImportNotification { get; set; }
+        public override void Parse(ref ImportObject importObject)
+        {
+            importObject.AddCustomChannels(ParseCustomChannels(_root));
+        }
+
+        public IEnumerable<ISO.MMEPossibleChannels> ParseCustomChannels(XmlElement root)
+        {
+            List<ISO.MMEPossibleChannels> channels = new List<ISO.MMEPossibleChannels>();
+            foreach (var node in root.ChildNodes)
+            {
+                if (node is XmlElement)
+                {
+                    channels.Add(ISO.MMEPossibleChannels.ReadXML(node as XmlElement));
+                }
+            }
+            return channels;
+        }
+
+    }
+}

Common/DTS.Common.Import/XML/XMLParseMMECustomDirections.cs

@@ -0,0 +1,35 @@
+using DTS.Common.Import.Interfaces;
+using System;
+using System.Collections.Generic;
+using System.Xml;
+
+namespace DTS.Common.Import.XML
+{
+    public class XMLParseMMECustomDirections : XMLParseBase
+    {
+        public XMLParseMMECustomDirections(XmlElement root, double importedVersion, Func<bool> isCancelled = null) : base(root, importedVersion, isCancelled)
+        {
+        }
+
+        public override void Parse(ref ImportObject importObject)
+        {
+            importObject.AddDirections(ParseCustomDirections(_root));
+        }
+
+        private IEnumerable<ISO.MMEDirections> ParseCustomDirections(XmlElement root)
+        {
+            List<ISO.MMEDirections> list = new List<ISO.MMEDirections>();
+
+            foreach (var child in root.ChildNodes)
+            {
+                if (IsCancelled()) { return list; }
+                if (child is XmlElement)
+                {
+                    list.Add(ISO.MMEDirections.ReadXML(child as XmlElement));
+                }
+            }
+            return list;
+        }
+    }
+}
+

Common/DTS.Common.Import/XML/XMLParseMMECustomFilterClasses.cs

@@ -0,0 +1,35 @@
+using DTS.Common.Import.Interfaces;
+using System;
+using System.Collections.Generic;
+using System.Xml;
+
+namespace DTS.Common.Import.XML
+{
+    public class XMLParseMMECustomFilterClasses : XMLParseBase
+    {
+        public XMLParseMMECustomFilterClasses(XmlElement root, double importedVersion, Func<bool> isCancelled = null) : base(root, importedVersion, isCancelled)
+        {
+        }
+
+        public override void Parse(ref ImportObject importObject)
+        {
+            importObject.AddCustomFilterClasses(ParseMMECustomFilterClasses(_root));
+        }
+
+        private IEnumerable<ISO.MMEFilterClasses> ParseMMECustomFilterClasses(XmlElement root)
+        {
+            List<ISO.MMEFilterClasses> list = new List<ISO.MMEFilterClasses>();
+
+            foreach (var child in root.ChildNodes)
+            {
+                if (IsCancelled()) { return list; }
+                if (child is XmlElement)
+                {
+                    list.Add(ISO.MMEFilterClasses.ReadXML(child as XmlElement));
+                }
+            }
+            return list;
+        }
+    }
+}
+

Common/DTS.Common.Import/XML/XMLParseMMECustomFineLoc1s.cs

@@ -0,0 +1,35 @@
+using DTS.Common.Import.Interfaces;
+using System;
+using System.Collections.Generic;
+using System.Xml;
+
+namespace DTS.Common.Import.XML
+{
+    public class XMLParseMMECustomFineLoc1s : XMLParseBase
+    {
+        public XMLParseMMECustomFineLoc1s(XmlElement root, double importedVersion, Func<bool> isCancelled = null) : base(root, importedVersion, isCancelled)
+        {
+        }
+
+        public override void Parse(ref ImportObject importObject)
+        {
+            importObject.AddCustomFineLoc1s(ParseCustomFineLoc1s(_root));
+        }
+
+        private IEnumerable<ISO.MMEFineLocations1> ParseCustomFineLoc1s(XmlElement root)
+        {
+            List<ISO.MMEFineLocations1> list = new List<ISO.MMEFineLocations1>();
+
+            foreach (var child in root.ChildNodes)
+            {
+                if (IsCancelled()) { return list; }
+                if (child is XmlElement)
+                {
+                    list.Add(ISO.MMEFineLocations1.ReadXML(child as XmlElement));
+                }
+            }
+            return list;
+        }
+    }
+}
+

Common/DTS.Common.Import/XML/XMLParseMMECustomFineLoc2s.cs

@@ -0,0 +1,35 @@
+using DTS.Common.Import.Interfaces;
+using System;
+using System.Collections.Generic;
+using System.Xml;
+
+namespace DTS.Common.Import.XML
+{
+    public class XMLParseMMECustomFineLoc2s : XMLParseBase
+    {
+        public XMLParseMMECustomFineLoc2s(XmlElement root, double importedVersion, Func<bool> isCancelled = null) : base(root, importedVersion, isCancelled)
+        {
+        }
+
+        public override void Parse(ref ImportObject importObject)
+        {
+            importObject.AddCustomFineLoc2s(ParseCustomFineLoc2s(_root));
+        }
+
+        private IEnumerable<ISO.MMEFineLocations2> ParseCustomFineLoc2s(XmlElement root)
+        {
+            List<ISO.MMEFineLocations2> list = new List<ISO.MMEFineLocations2>();
+
+            foreach (var child in root.ChildNodes)
+            {
+                if (IsCancelled()) { return list; }
+                if (child is XmlElement)
+                {
+                    list.Add(ISO.MMEFineLocations2.ReadXML(child as XmlElement));
+                }
+            }
+            return list;
+        }
+    }
+}
+

Common/DTS.Common.Import/XML/XMLParseMMECustomFineLoc3s.cs

@@ -0,0 +1,35 @@
+using DTS.Common.Import.Interfaces;
+using System;
+using System.Collections.Generic;
+using System.Xml;
+
+namespace DTS.Common.Import.XML
+{
+    public class XMLParseMMECustomFineLoc3s : XMLParseBase
+    {
+        public XMLParseMMECustomFineLoc3s(XmlElement root, double importedVersion, Func<bool> isCancelled = null) : base(root, importedVersion, isCancelled)
+        {
+        }
+
+        public override void Parse(ref ImportObject importObject)
+        {
+            importObject.AddCustomFineLoc3s(ParseCustomFineLoc3s(_root));
+        }
+
+        private IEnumerable<ISO.MMEFineLocations3> ParseCustomFineLoc3s(XmlElement root)
+        {
+            List<ISO.MMEFineLocations3> list = new List<ISO.MMEFineLocations3>();
+
+            foreach (var child in root.ChildNodes)
+            {
+                if (IsCancelled()) { return list; }
+                if (child is XmlElement)
+                {
+                    list.Add(ISO.MMEFineLocations3.ReadXML(child as XmlElement));
+                }
+            }
+            return list;
+        }
+    }
+}
+

Common/DTS.Common.Import/XML/XMLParseMMECustomMainLocations.cs

@@ -0,0 +1,33 @@
+using DTS.Common.Import.Interfaces;
+using System;
+using System.Collections.Generic;
+using System.Xml;
+
+namespace DTS.Common.Import.XML
+{
+    public class XMLParseMMECustomMainLocations : XMLParseBase
+    {
+        public XMLParseMMECustomMainLocations(XmlElement root, double importedVersion, Func<bool> isCancelled = null) : base(root, importedVersion, isCancelled)
+        {
+        }
+        public override void Parse(ref ImportObject importObject)
+        {
+            importObject.AddCustomMainLocations(ParseCustomMainLocations(_root));
+        }
+
+        public IEnumerable<ISO.MMETransducerMainLocation> ParseCustomMainLocations(XmlElement root)
+        {
+            List<ISO.MMETransducerMainLocation> list = new List<ISO.MMETransducerMainLocation>();
+            foreach (var node in root.ChildNodes)
+            {
+                if (IsCancelled()) { return list; }
+                if (node is XmlElement)
+                {
+                    list.Add(ISO.MMETransducerMainLocation.ReadXML(node as XmlElement));
+                }
+            }
+            return list;
+        }
+
+    }
+}

Common/DTS.Common.Import/XML/XMLParseMMECustomPhysicalDimensions.cs

@@ -0,0 +1,35 @@
+using DTS.Common.Import.Interfaces;
+using System;
+using System.Collections.Generic;
+using System.Xml;
+
+namespace DTS.Common.Import.XML
+{
+    public class XMLParseMMECustomPhysicalDimensions : XMLParseBase
+    {
+        public XMLParseMMECustomPhysicalDimensions(XmlElement root, double importedVersion, Func<bool> isCancelled = null) : base(root, importedVersion, isCancelled)
+        {
+        }
+
+        public override void Parse(ref ImportObject importObject)
+        {
+            importObject.AddCustomPhysicalDimensions(ParsePhysicalDimensions(_root));
+        }
+
+        private IEnumerable<ISO.MMEPhysicalDimensions> ParsePhysicalDimensions(XmlElement root)
+        {
+            List<ISO.MMEPhysicalDimensions> list = new List<ISO.MMEPhysicalDimensions>();
+
+            foreach (var child in root.ChildNodes)
+            {
+                if (IsCancelled()) { return list; }
+                if (child is XmlElement)
+                {
+                    list.Add(ISO.MMEPhysicalDimensions.ReadXML(child as XmlElement));
+                }
+            }
+            return list;
+        }
+    }
+}
+

Common/DTS.Common.Import/XML/XMLParseMMECustomPositions.cs

@@ -0,0 +1,35 @@
+using DTS.Common.Import.Interfaces;
+using System;
+using System.Collections.Generic;
+using System.Xml;
+
+namespace DTS.Common.Import.XML
+{
+    public class XMLParseMMECustomPositions : XMLParseBase
+    {
+        public XMLParseMMECustomPositions(XmlElement root, double importedVersion, Func<bool> isCancelled = null) : base(root, importedVersion, isCancelled)
+        {
+        }
+
+        public override void Parse(ref ImportObject importObject)
+        {
+            importObject.AddCustomPositions(ParsePhysicalDimensions(_root));
+        }
+
+        private IEnumerable<ISO.MMEPositions> ParsePhysicalDimensions(XmlElement root)
+        {
+            List<ISO.MMEPositions> list = new List<ISO.MMEPositions>();
+
+            foreach (var child in root.ChildNodes)
+            {
+                if (IsCancelled()) { return list; }
+                if (child is XmlElement)
+                {
+                    list.Add(ISO.MMEPositions.ReadXML(child as XmlElement));
+                }
+            }
+            return list;
+        }
+    }
+}
+

Common/DTS.Common.Import/XML/XMLParseMMECustomTestObjects.cs

@@ -0,0 +1,34 @@
+
+using DTS.Common.Import.Interfaces;
+using System;
+using System.Collections.Generic;
+using System.Xml;
+
+namespace DTS.Common.Import.XML
+{
+    public class XMLParseMMECustomTestObjects : XMLParseBase
+    {
+        public XMLParseMMECustomTestObjects(XmlElement root, double importedVersion, Func<bool> isCancelled = null) : base(root, importedVersion, isCancelled)
+        {
+        }
+        public override void Parse(ref ImportObject importObject)
+        {
+            importObject.AddTestObjects(ParseCustomTestObjects(_root));
+        }
+
+        public IEnumerable<ISO.MMETestObjects> ParseCustomTestObjects(XmlElement root)
+        {
+            List<ISO.MMETestObjects> list = new List<ISO.MMETestObjects>();
+            foreach (var node in root.ChildNodes)
+            {
+                if (IsCancelled()) { return list; }
+                if (node is XmlElement)
+                {
+                    list.Add(ISO.MMETestObjects.ReadXML(node as XmlElement));
+                }
+            }
+            return list;
+        }
+
+    }
+}

Common/DTS.Common.Import/XML/XMLParseSensorModels.cs

@@ -0,0 +1,38 @@
+using DTS.Common.Import.Interfaces;
+using DTS.Common.Interface;
+using DTS.SensorDB;
+using System;
+using System.Collections.Generic;
+using System.Xml;
+
+namespace DTS.Common.Import.XML
+{
+    public class XMLParseSensorModels : XMLParseBase
+    {
+        public XMLParseSensorModels(XmlElement root, double importedVersion, Func<bool> isCancelled = null) : base(root, importedVersion, isCancelled)
+        {
+        }
+
+        public override void Parse(ref ImportObject importObject)
+        {
+            importObject.AddSensorModels(ParseSensorModels(_root));
+        }
+
+        private List<SensorModel> ParseSensorModels(XmlElement root)
+        {
+            List<SensorModel> list = new List<SensorModel>();
+
+            foreach (var node in root.ChildNodes)
+            {
+                if (IsCancelled()) { return list; }
+                if (!(node is XmlElement)) continue;
+                var sm = new SensorModel();
+                sm.ReadXML(node as XmlElement);
+                list.Add(sm);
+            }
+            return list;
+        }
+    }
+}
+
+

Common/DTS.Common.Import/XML/XMLParseSensors.cs

@@ -0,0 +1,63 @@
+using DTS.Common.Enums.DBExport;
+using DTS.SensorDB;
+using System;
+using System.Collections.Generic;
+using System.Xml;
+
+namespace DTS.Common.Import.XML
+{
+    public class XMLParseSensors : XMLParseBase
+    {
+        public XMLParseSensors(XmlElement root, double importedVersion, Func<bool> isCancelled = null,bool skipNormalizing=false) : base(root, importedVersion, isCancelled, skipNormalizing) { }
+
+        public IImportNotification ImportNotification { get; set; }
+        public override void Parse(ref ImportObject importObject)
+        {
+            ImportNotification?.SetStatus(new ImportStatus { PossibleStatus = Enums.PossibleStatus.Reading, ExtraStatus = Enums.ImportExtraStatus.ReadingSensors });
+            var sensors = ParseSensors(_root);
+            if (!_skipNormalizing)
+            {
+                var newRoot = ConvertSensors(sensors);
+                sensors = ParseSensors(newRoot);
+            }
+            importObject.AddSensors(sensors);
+        }
+        public XmlElement ConvertSensors(IEnumerable<SensorData> sensors)
+        {
+            _writer.WriteStartElement(TopLevelFields.Sensors.ToString());
+            //normalize to -2 ... -n (preserve -1 for invalid)
+            var count = -2;
+            foreach (var sd in sensors)
+            {
+                _sensorIdMapping[sd.DatabaseId] = count;
+                sd.DatabaseId = count;
+                count--;
+                _writer.Flush();
+                sd.WriteXML(ref _writer);
+                _writer.Flush();
+            }
+            _writer.WriteEndElement();
+
+            return GetXmlElement();
+        }
+
+        public IEnumerable<SensorData> ParseSensors(XmlElement root)
+        {
+            List<SensorData> sensors = new List<SensorData>();
+            foreach (var node in root.ChildNodes)
+            {
+                if (IsCancelled())
+                {
+                    return sensors;
+                }
+
+                if (!(node is XmlElement)) continue;
+                var sd = new SensorData();
+                sd.ReadXML(node as XmlElement);
+
+                sensors.Add(sd);
+            }
+            return sensors;
+        }
+    }
+}

Common/DTS.Common.Import/XML/XMLParseTestEngineerDetails.cs

@@ -0,0 +1,56 @@
+
+using DTS.Common.Enums.DBExport;
+using DTS.Common.Import.Interfaces;
+using DTS.Common.Interface.Groups.GroupList;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using System.Xml;
+
+namespace DTS.Common.Import.XML
+{
+    public class XMLParseTestEngineerDetails : XMLParseBase
+    {
+        public XMLParseTestEngineerDetails(XmlElement root, double importedVersion, Func<bool> isCancelled = null) : base(root, importedVersion, isCancelled)
+        {
+        }
+        public IImportNotification ImportNotification { get; set; }
+        public override void Parse(ref ImportObject importObject)
+        {
+            var details = ParseTestEngineerDetails(_root);
+            var newRoot = ConvertTestEngineerDetails(details);
+            details = ParseTestEngineerDetails(newRoot);
+            importObject.AddTestEngineerDetailsList(details);
+        }
+
+        private XmlElement ConvertTestEngineerDetails(IEnumerable<ISO.TestEngineerDetails> details)
+        {
+            _writer.WriteStartElement(TopLevelFields.TestEngineerDetails.ToString());
+            foreach (var c in details)
+            {
+                _writer.Flush();
+                c.WriteXML(ref _writer);
+                _writer.Flush();
+            }
+
+            _writer.WriteEndElement();
+            return GetXmlElement();
+        }
+        private List<ISO.TestEngineerDetails> ParseTestEngineerDetails(XmlElement root)
+        {
+            List<ISO.TestEngineerDetails> details = new List<ISO.TestEngineerDetails>();
+            foreach (var node in root.ChildNodes)
+            {
+                if (IsCancelled()) { return details; }
+                if (node is XmlElement)
+                {
+                    details.Add(ISO.TestEngineerDetails.ReadXML(node as XmlElement));
+                }
+            }
+            return details;
+        }
+    }
+}
+

Common/DTS.Common.Import/XML/XMLParseTestSetups.cs

@@ -0,0 +1,201 @@
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Xml;
+using DataPROWin7.DataModel;
+using DTS.Common.Classes.TestSetups;
+using DTS.Common.Enums.DBExport;
+using DTS.Common.Interface.Groups.GroupList;
+using DTS.Common.Utils;
+using DTS.SensorDB;
+
+namespace DTS.Common.Import.XML
+{
+
+    public class XMLParseTestSetups : XMLParseBase
+    {
+        public XMLParseTestSetups(XmlElement root, double importedVersion, Func<bool> isCancelled = null, bool skipNormalizing= false) : base(root, importedVersion, isCancelled, skipNormalizing)
+        {
+            _channelIdMapping.Clear();
+        }
+
+        public IImportNotification ImportNotification { get; set; }
+
+        public override void Parse(ref ImportObject importObject)
+        {
+            ImportNotification?.SetStatus(new ImportStatus { PossibleStatus = Enums.PossibleStatus.Reading, ExtraStatus = Enums.ImportExtraStatus.ReadingTestSetups });
+            var testTemplates = ParseTestTemplate(importObject, _root);
+            if (!_skipNormalizing)
+            {
+                var newRoot = ConvertTestTemplates(testTemplates, importObject);
+                testTemplates = ParseTestTemplate(importObject, newRoot);
+            }
+            importObject.TestSetupImportFileFormat = ImportObject.GetImportFileFormat(testTemplates.Count());
+            importObject.AddTestSetups(testTemplates);
+        }
+        private XmlElement ConvertTestTemplates(IEnumerable<TestTemplate> testTemplates, ImportObject importObject)
+        {
+            _writer.WriteStartElement(TopLevelFields.TestSetups.ToString());
+            foreach (var t in testTemplates)
+            {
+                var groupCount = -1;
+                foreach (var group in t.Groups)
+                {
+                    group.Id = groupCount;
+
+                    if (group.StaticGroupId != null)
+                    {
+                        if (_groupIdMapping.ContainsKey(group.StaticGroupId.ToString()))
+                        {
+                            group.StaticGroupId = _groupIdMapping[group.StaticGroupId.ToString()];
+                        }
+                        else
+                        {
+                            //This can occur if an old (buggy) Test Setup export includes an embedded
+                            //Group which was created from a static Group which was later deleted.
+                            group.StaticGroupId = null;
+                        }
+                    }
+
+                    groupCount--;
+                }
+                var channelCount = -1;
+                foreach (var group in t.ChannelsForGroup)
+                {
+                    foreach (var channel in group.Value)
+                    {
+                        if (_dasIdMapping.ContainsKey(channel.DASId))
+                        {
+                            channel.DASId = _dasIdMapping[channel.DASId];
+                        }
+                        if (_sensorIdMapping.ContainsKey(channel.SensorId))
+                        {
+                            var match = importObject.Sensors().FirstOrDefault(s => s.DatabaseId == _sensorIdMapping[channel.SensorId]);
+                            //setting the sensor just so IsUart, etc is populated
+                            if (null != match) { channel.SetSensorData(match, null, false); }
+                            channel.SensorId = _sensorIdMapping[channel.SensorId];
+                        }
+                        else
+                        {
+                            //FB 14308 - Don't fail Test Setup import if it was 
+                            //exported when out-of-date due to a deleted sensor.
+                            channel.SensorId = 0;
+                        }
+                        _channelIdMapping[channel.Id] = channelCount;
+                        channel.Id = channelCount;
+                        channelCount--;
+                    }
+                }
+
+                var addedHardwareList = new List<int>();
+                foreach (var dasId in t.AddedHardware)
+                {
+                    addedHardwareList.Add(_dasIdMapping[dasId]);
+                }
+                t.AddedHardware = addedHardwareList.ToArray();
+
+                var removedHardwareList = new List<int>();
+                foreach (var dasId in t.RemovedHardware)
+                {
+                    if (_dasIdMapping.ContainsKey(dasId))
+                    {
+                        removedHardwareList.Add(_dasIdMapping[dasId]);
+                    }
+                }
+                t.RemovedHardware = removedHardwareList.ToArray();
+
+                _writer.Flush();
+                t.WriteXML(ref _writer);
+                _writer.Flush();
+            }
+            _writer.WriteEndElement();
+            return GetXmlElement();
+        }
+
+        public IEnumerable<TestTemplate> ParseTestTemplate(ImportObject importObject, XmlElement root)
+        {
+            List<TestTemplate> testTemplates = new List<TestTemplate>();
+            var testobjectLookup = new Dictionary<string, TestObject>();
+            var groupLookup = new Dictionary<string, IGroup>();
+
+            foreach (var to in importObject.Groups())
+            {
+                if (IsCancelled()) { return testTemplates; }
+                testobjectLookup[to.SerialNumber] = to;
+            }
+
+            //Static Groups
+            foreach (var g in importObject.StaticGroups())
+            {
+                if (IsCancelled()) { return testTemplates; }
+                groupLookup[g.Name] = g;
+            }
+
+            var customerDetailsLookup = new Dictionary<string, ISO.CustomerDetails>();
+            foreach (var c in importObject.CustomerDetails())
+            {
+                if (IsCancelled()) { return testTemplates; }
+                customerDetailsLookup[c.Name] = c;
+            }
+
+            var testEngineerDetailsLookup = new Dictionary<string, ISO.TestEngineerDetails>();
+            foreach (var t in importObject.TestEngineerDetails())
+            {
+                if (IsCancelled()) { return testTemplates; }
+                testEngineerDetailsLookup[t.Name] = t;
+            }
+
+            var labDetailsLookup = new Dictionary<string, ISO.LabratoryDetails>();
+            foreach (var l in importObject.LabDetails())
+            {
+                if (IsCancelled()) { return testTemplates; }
+                labDetailsLookup[l.Name] = l;
+            }
+
+            var sensorLookup = new Dictionary<string, SensorData>();
+            foreach (var s in importObject.Sensors())
+            {
+                if (IsCancelled()) { return testTemplates; }
+                sensorLookup[s.SerialNumber] = s;
+            }
+
+
+            foreach (var node in root.ChildNodes)
+            {
+                if (IsCancelled()) { return testTemplates; }
+                if (node is XmlElement)
+                {
+                    //18868 Pass the list of DAS from this import, instead of getting all of the DAS in the database.
+                    var simpleImportedHardwareList = new List<SimpleHardware>();
+                    foreach (var h in importObject.Hardware())
+                    {
+                        simpleImportedHardwareList.Add(new SimpleHardware(h.SerialNumber, h.ParentDAS, -1, Convert.ToInt32(h.DASTypeEnum)));
+                    }
+
+                    try
+                    {
+                        var d = new TestTemplate(null, true, simpleImportedHardwareList.ToArray());
+                        var hardware = importObject.Hardware()?.ToList();
+                        var calibration = importObject.Calibrations()?.ToList();
+                        d.ReadXML(node as XmlElement, testobjectLookup, groupLookup, labDetailsLookup, customerDetailsLookup, testEngineerDetailsLookup, sensorLookup,hardware,
+                            calibration);
+                        d.SetGroupsListOrder(); //If any were just imported and have a DisplayOrder of -1, fix them up
+                        testTemplates.Add(d);
+                    }
+                    catch (Exception ex)
+                    {
+                        //FB 36879 If can't read the xml report the error
+                        importObject.AddError(new ImportError
+                        {
+                            Message = ex.Message,
+                            Severity = ImportSeverityError.Warning,
+                            ContinueImportOnError = true
+                        });
+                    }
+                }
+            }
+            return testTemplates;
+        }
+    }
+}

Common/DTS.Common.Import/XML/XMLParseUsers.cs

@@ -0,0 +1,46 @@
+using DTS.Common.Enums.DBExport;
+using DTS.Common.Import.Interfaces;
+using DTS.Common.Interface.Groups.GroupList;
+using DTS.Slice.Users;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using System.Xml;
+using static System.Net.Mime.MediaTypeNames;
+
+namespace DTS.Common.Import.XML
+{
+    public class XMLParseUsers : XMLParseBase
+    {
+        private readonly IEnumerable<IUIItems> _uiItems;
+        public XMLParseUsers(XmlElement root, double importedVersion, IEnumerable<IUIItems> uiItems, Func<bool> isCancelled = null) : base(root, importedVersion, isCancelled)
+        {
+            _uiItems = uiItems;
+        }
+        public IImportNotification ImportNotification { get; set; }
+        public override void Parse(ref ImportObject importObject)
+        {
+            ImportNotification?.SetStatus(new ImportStatus { PossibleStatus = Enums.PossibleStatus.Reading, ExtraStatus = Enums.ImportExtraStatus.ReadingUsers });
+            importObject.AddUsers(ParseUsers(_root, _uiItems));
+        }
+
+        private IEnumerable<User> ParseUsers(XmlElement root, IEnumerable<IUIItems> iUItems)
+        {
+            List<User> users = new List<User>();
+
+            foreach (var node in root.ChildNodes)
+            {
+                if (IsCancelled()) { return users; }
+                if (node is XmlElement)
+                {
+                    users.Add(User.ReadXML(node as XmlElement, iUItems?.ToArray()));
+                }
+            }
+            return users;
+        }
+    }
+}
+
+

Common/DTS.Common.Import/XML/XMLPre20ParseCalibrations.cs

@@ -0,0 +1,95 @@
+using DTS.Common.Enums;
+using DTS.Common.Enums.DBExport;
+using DTS.Common.Enums.Sensors;
+using DTS.Common.Import.Interfaces;
+using DTS.Common.Utils;
+using DTS.SensorDB;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using System.Xml;
+
+namespace DTS.Common.Import.XML
+{
+    public class XMLPre20ParseCalibrations : XMLParseBase
+    {
+        private readonly XMLParseCalibrations _xmlParseCalibrations;
+        public XMLPre20ParseCalibrations(XmlElement root, double importedVersion, XMLParseCalibrations xmlParseCalibrations, Func<bool> isCancelled = null) : base(root, importedVersion, isCancelled)
+        {
+            _xmlParseCalibrations = xmlParseCalibrations;
+        }
+
+        public override void Parse(ref ImportObject importObject)
+        {
+            var calibrations = ParsePre20Calibrations(ref importObject);
+            if (calibrations == null)
+            {
+                return;
+            }
+            var newRoot = _xmlParseCalibrations.ConvertCalibrations(calibrations);
+            if (newRoot == null)
+            {
+                return;
+            }
+            importObject.AddCalibrations(_xmlParseCalibrations.ParseCalibrations(newRoot));
+        }
+
+        private void AddToSensor(SensorCalibration sc, ref ImportObject importObject)
+        {
+            if (sc == null) { return; }
+            var sensor = importObject.Sensors().FirstOrDefault(s => s.SerialNumber == sc.SerialNumber);
+            if (sensor != null)
+            {
+                sensor.Calibration = sc;
+            }
+        }
+        private IEnumerable<SensorCalibration> ParsePre20Calibrations(ref ImportObject importObject)
+        {
+            List<SensorCalibration> scs = new List<SensorCalibration>();
+            if (_importedVersion >= FileUtils.DataPROPre20XmlVersion)
+            {
+                foreach (var node in _root.ChildNodes)
+                {
+                    if (node is XmlElement)
+                    {
+                        var sc = new SensorCalibration();
+                        sc.ReadXML(node as XmlElement);
+                        scs.Add(sc);
+                        AddToSensor(sc, ref importObject);
+                    }
+                }
+            }
+            if (_importedVersion == 1.0D)
+            {
+                foreach (var node in _root.ChildNodes)
+                {
+                    if (node is XmlElement)
+                    {
+                        var sc = new SensorCalibration();
+                        sc.ReadXML(node as XmlElement);
+
+                        sc.Records.Records[0].AtCapacity = false;
+
+                        if (sc.NonLinear)
+                        {
+                            sc.Records.Records[0].SensitivityUnits = SensorConstants.SensUnits.NONE;
+                        }
+                        else if (sc.IsProportional)
+                        {
+                            sc.Records.Records[0].SensitivityUnits = SensorConstants.SensUnits.mVperVperEU;
+                        }
+                        else
+                        {
+                            sc.Records.Records[0].SensitivityUnits = SensorConstants.SensUnits.mVperEU;
+                        }
+                        scs.Add(sc);
+                    }
+                }
+            }
+            return scs;
+
+        }
+    }
+}

Common/DTS.Common.Import/XML/XMLPre20ParseDASList.cs

@@ -0,0 +1,63 @@
+using DataPROWin7.DataModel;
+using DTS.Common.Enums.DBExport;
+using DTS.Common.Import.Interfaces;
+using DTS.Common.Interface.Groups.GroupList;
+using DTS.Common.ISO;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using System.Xml;
+
+namespace DTS.Common.Import.XML
+{
+    public class XMLPre20ParseDASList : XMLParseBase
+    {
+        private readonly XMLParseDASList _xmlParseDASList;
+        public XMLPre20ParseDASList(XmlElement root, double importedVersion, XMLParseDASList xmlParseDASList, Func<bool> isCancelled = null) : base(root, importedVersion, isCancelled)
+        {
+            _xmlParseDASList = xmlParseDASList;
+        }
+        public List<DASHardware> ParsePre20DASList(XmlElement root)
+        {
+            List<DASHardware> dasList = new List<DASHardware>();
+            foreach (var node in root.ChildNodes)
+            {
+                if (node is XmlElement)
+                {
+                    var isoHardware = DataPROWin7.DataModel.DASHardware.ReadXML(node as XmlElement);
+                    dasList.Add(new DASHardware(isoHardware));
+                }
+            }
+            return dasList;
+        }
+
+        private XmlElement MigratePre20DASList(List<DASHardware> dasList)
+        {
+            _writer.WriteStartElement(TopLevelFields.DASList.ToString());
+            var count = -1;
+            foreach (var h in dasList)
+            {
+                h.SetDASId(count);
+                count--;
+
+                _writer.Flush();
+                h.WriteXML(ref _writer);
+                _writer.Flush();
+            }
+            _writer.WriteEndElement();
+            return GetXmlElement();
+        }
+
+
+        public override void Parse(ref ImportObject importObject)
+        {
+            var dasList = ParsePre20DASList(_root);
+            var newRoot = MigratePre20DASList(dasList);
+            importObject.AddHardwareList(_xmlParseDASList.ParseDASList(newRoot));
+        }
+
+    }
+}
+

Common/DTS.Common.Import/XML/XMLPre20ParseGroupTemplates.cs

@@ -0,0 +1,28 @@
+using DTS.Common.Import.Interfaces;
+using DTS.Common.Interface.GroupTemplate;
+using DTS.Common.SharedResource.Strings;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using System.Xml;
+using static System.Net.Mime.MediaTypeNames;
+
+namespace DTS.Common.Import.XML
+{
+    public class XMLPre20ParseGroupTemplates : XMLParseBase
+    {
+        private XMLParseGroupTemplates _xmlParseGroupTemplates;
+        public XMLPre20ParseGroupTemplates(XmlElement root, double importedVersion,
+           XMLParseGroupTemplates xmlParseGroupTemplates, Func<bool> isCancelled = null) : base(root, importedVersion, isCancelled)
+        {
+            _xmlParseGroupTemplates = xmlParseGroupTemplates;
+        }
+        public override void Parse(ref ImportObject importObject)
+        {
+            var groupTemplates = _xmlParseGroupTemplates.ParseGroupTemplates(ref importObject, _root);
+            importObject.AddGroupTemplates(groupTemplates);
+        }
+    }
+}

Common/DTS.Common.Import/XML/XMLPre20ParseGroups.cs

@@ -0,0 +1,220 @@
+using DTS.Common.Classes.Groups.ChannelSettings;
+using DTS.Common.Classes.Groups;
+using DTS.Common.Enums.Sensors;
+using DTS.Common.Import.Interfaces;
+using DTS.Common.Interface.Channels;
+using DTS.Common.Interface.Groups.GroupList;
+using DTS.Common.Interface.GroupTemplate;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using System.Xml;
+using static System.Net.Mime.MediaTypeNames;
+using DTS.Common.Enums.DBExport;
+using DTS.Common.Classes.Sensors;
+
+namespace DTS.Common.Import.XML
+{
+    public class XMLPre20ParseGroups : XMLParseBase
+    {
+        private readonly ISO.ISO13499FileDb _iSO13499FileDb;
+        private readonly XMLParseGroups _xmlParseGroups;
+        public XMLPre20ParseGroups(XmlElement root, double importedVersion, DTS.Common.ISO.ISO13499FileDb iSO13499FileDb,
+            XMLParseGroups xmlParseGroups, Func<bool> isCancelled = null) : base(root, importedVersion, isCancelled)
+        {
+            _iSO13499FileDb = iSO13499FileDb;
+            _xmlParseGroups = xmlParseGroups;
+        }
+
+        public override void Parse(ref ImportObject importObject)
+        {
+            var groups = ParsePre20Groups(ref importObject);
+            importObject.AddGroups(groups);
+
+            var newRoot = MigratePre20Groups(groups, ref importObject);
+            var staticGroups = _xmlParseGroups.ParseGroups(newRoot, ref importObject);
+            importObject.AddStaticGroups(staticGroups);
+        }
+
+        private XmlElement MigratePre20Groups(IEnumerable<DataPROWin7.DataModel.TestObject> groups, ref ImportObject importObject)
+        {
+            _writer.WriteStartElement(TopLevelFields.Groups.ToString());
+            var count = -1;
+            foreach (var g in groups)
+            {
+                if (!g.GetISOTestObject().Embedded && !g.SysBuilt)
+                {
+                    //Only make static Groups out of non-embedded and non-Added Groups
+                    IGroup iGroup = GroupHelper.CreateEmptyGroup();
+                    iGroup.Name = g.SerialNumber;
+
+                    iGroup.LastModified = g.LastModified;
+                    iGroup.LastModifiedBy = g.LastModifiedBy;
+                    iGroup.Embedded = false;
+
+                    iGroup.Id = count;
+                    count--;
+                    _groupIdMapping[iGroup.Name] = iGroup.Id;
+
+                    iGroup.IncludedHardwareStringList = g.GetISOTestObject().HardwareIds;
+                    var dasIdList = new List<string>();
+                    foreach (var hardwareString in iGroup.IncludedHardwareStringList)
+                    {
+                        dasIdList.Add(hardwareString.Substring(0, hardwareString.IndexOf('_')));
+                    }
+                    iGroup.IncludedHardwareStringList = dasIdList.ToArray();
+                    foreach (var ch in g.GetISOTestObject().AllChannels)
+                    {
+                        if (!ch.Required || string.IsNullOrEmpty(ch.SensorSerialNumber)) continue;
+
+                        var groupChannel = new GroupChannel(true, iGroup.Name, iGroup, new IChannelSetting[0]);
+                        groupChannel.IsoChannelName = ch.NameOfTheChannel; //???
+                        groupChannel.UserChannelName = ch.NameOfTheChannel; //???
+                        groupChannel.UserCode = string.Empty;
+                        if (!string.IsNullOrWhiteSpace(ch.HardwareId))
+                        {
+                            var hardwareUnderscoreSplit = ch.HardwareId.Split('_');
+                            groupChannel.Hardware = hardwareUnderscoreSplit[0];
+
+                            foreach (var hardware in importObject.Hardware())
+                            {
+                                if (hardware.SerialNumber == groupChannel.Hardware)
+                                {
+                                    groupChannel.DASId = hardware.DASId;
+                                    break;
+                                }
+                            }
+
+                            var hardwareXSplit = ch.HardwareId.Split('x');
+                            groupChannel.DASChannelIndex = Convert.ToInt32(hardwareXSplit[1]) - 1;
+                        }
+                        var channelParts = ch.GetId().Split('_');
+                        groupChannel.GroupChannelOrder = Convert.ToInt32(channelParts[channelParts.Length - 1]);
+                        groupChannel.TestSetupOrder = -1;
+                        foreach (var sensor in importObject.Sensors())
+                        {
+                            if (sensor.SerialNumber == ch.SensorSerialNumber)
+                            {
+                                groupChannel.SetSensorData(sensor, null);
+                                groupChannel.SensorId = sensor.DatabaseId;
+                                break;
+                            }
+                        }
+                        groupChannel.IsDisabled = false;
+                        groupChannel.LastModified = g.LastModified;
+                        groupChannel.LastModifiedBy = g.LastModifiedBy;
+                        var sensorSettings = g.GetISOTestObject().GetSensorSettings(ch.GetId(), ch.SensorSerialNumber);
+                        var channelSettingList = new List<DTS.Common.Interface.Channels.IChannelSetting>();
+                        foreach (var sensorSetting in sensorSettings)
+                        {
+                            var channelSettingBase = new ChannelSettingBase((int)sensorSetting.Setting + 1,
+                                                                            sensorSetting.Setting.ToString(),
+                                                                            sensorSetting.Value);
+                            switch (sensorSetting.Setting)
+                            {
+                                case SensorConstants.SensorSettings.OutputMode:
+                                case SensorConstants.SensorSettings.SQMode:
+                                case SensorConstants.SensorSettings.DIMode:
+                                case SensorConstants.SensorSettings.UartBaudRate:
+                                case SensorConstants.SensorSettings.UartDataBits:
+                                    if (int.TryParse(sensorSetting.Value, out var tmp))
+                                    {
+                                        channelSettingBase.IntValue = tmp;
+                                    }
+                                    else
+                                    {
+
+                                        continue;
+                                    }
+                                    break;
+                                case SensorConstants.SensorSettings.CFC:
+                                    //FB 15574 convert cfc iso to FilterClass and replace the cfc setting with filter class
+                                    var cfc = sensorSetting.Value;
+                                    var filterClass = FilterClass.GetFilterClassSettingFromCFC(cfc);
+
+                                    channelSettingBase = new ChannelSettingBase((int)SensorConstants.SensorSettings.FilterClass + 1,
+                                                                            SensorConstants.SensorSettings.FilterClass.ToString(), filterClass);
+                                    channelSettingBase.Value = filterClass;
+
+                                    groupChannel.IsoCode = ch.ISOCode.Substring(0, 15) + cfc;
+                                    break;
+                                case SensorConstants.SensorSettings.Polarity:
+                                case SensorConstants.SensorSettings.Position:
+                                case SensorConstants.SensorSettings.ZeroMethod:
+                                case SensorConstants.SensorSettings.UserValue1:
+                                case SensorConstants.SensorSettings.UserValue2:
+                                case SensorConstants.SensorSettings.UserValue3:
+                                case SensorConstants.SensorSettings.InitialOffset:
+                                case SensorConstants.SensorSettings.UartStopBits:
+                                case SensorConstants.SensorSettings.UartParity:
+                                case SensorConstants.SensorSettings.UartFlowControl:
+                                case SensorConstants.SensorSettings.UartDataFormat:
+                                    channelSettingBase.Value = sensorSetting.Value;
+                                    break;
+                                case SensorConstants.SensorSettings.LimitDuration:
+                                    channelSettingBase.BoolValue = Convert.ToBoolean(sensorSetting.Value);
+                                    break;
+                                case SensorConstants.SensorSettings.Range:
+                                case SensorConstants.SensorSettings.Duration:
+                                case SensorConstants.SensorSettings.Delay:
+                                case SensorConstants.SensorSettings.DefaultValue:
+                                case SensorConstants.SensorSettings.ActiveValue:
+                                case SensorConstants.SensorSettings.ZeroMethodStart:
+                                case SensorConstants.SensorSettings.ZeroMethodEnd:
+                                    channelSettingBase.DoubleValue = Convert.ToDouble(sensorSetting.Value);
+                                    break;
+                                default:
+                                    break;
+                            }
+                            channelSettingList.Add(channelSettingBase);
+
+                        }
+                        groupChannel.ChannelSettings = channelSettingList.ToArray();
+
+                        iGroup.GroupChannelList.Add(groupChannel);
+                    }
+
+                    _writer.Flush();
+                    iGroup.WriteXML(ref _writer);
+                    _writer.Flush();
+                }
+            }
+            _writer.WriteEndElement();
+            return GetXmlElement();
+        }
+        private IEnumerable<DataPROWin7.DataModel.TestObject> ParsePre20Groups(ref ImportObject importObject)
+        {
+            List<DataPROWin7.DataModel.TestObject> groups = new List<DataPROWin7.DataModel.TestObject>();
+            var importedHardware = new Dictionary<string, DataPROWin7.DataModel.DASHardware>();
+            foreach (var h in importObject.Hardware())
+            {
+                importedHardware[h.GetHardware().GetId()] = h;
+            }
+
+            var templateLookup = new Dictionary<string, ISO.TestObjectTemplate>();
+            var templateLookup2 = new Dictionary<string, DataPROWin7.DataModel.TestObjectTemplate>();
+
+            foreach (var template in importObject.GroupTemplates())
+            {
+                templateLookup[template.TemplateName] = template.ToISOTestObjectTemplate();
+                templateLookup2[template.TemplateName] = template;
+            }
+            foreach (var node in _root.ChildNodes)
+            {
+                if (!(node is XmlElement)) continue;
+                var to = DataPROWin7.DataModel.TestObject.ReadXML(node as XmlElement, templateLookup, importObject.Calibrations()?.ToList(), importObject.Sensors()?.ToList());
+                if (string.IsNullOrEmpty(to.Template)) continue;
+                if (!templateLookup2.ContainsKey(to.Template))
+                {
+                    var db = _iSO13499FileDb;
+                    var template = new DataPROWin7.DataModel.TestObjectTemplate(templateLookup[to.Template], ref db);
+                    templateLookup2[to.Template] = template;
+                }
+                groups.Add(new DataPROWin7.DataModel.TestObject(to, to.SysBuilt, templateLookup2[to.Template], importedHardware));
+            }
+            return groups;
+        }
+    }
+}

Common/DTS.Common.Import/XML/XMLPre20ParseSensors.cs

@@ -0,0 +1,43 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using System.Xml;
+using DTS.Common.Enums.DBExport;
+using DTS.Common.Import.Interfaces;
+using DTS.SensorDB;
+
+namespace DTS.Common.Import.XML
+{
+    public class XMLPre20ParseSensors : XMLParseBase
+    {
+        private readonly XMLParseSensors _xmlParseSensors;
+        public XMLPre20ParseSensors(XmlElement root, double importedVersion, XMLParseSensors xmlParseSensors, Func<bool> isCancelled = null) : base(root, importedVersion, isCancelled)
+        {
+            _xmlParseSensors = xmlParseSensors;
+        }
+        public override void Parse(ref ImportObject importObject)
+        {
+            var sensors = _xmlParseSensors.ParseSensors(_root);
+            var newRoot = MigrateSensors(sensors);
+            importObject.AddSensors(_xmlParseSensors.ParseSensors(newRoot));
+        }
+
+        public XmlElement MigrateSensors(IEnumerable<SensorData> sensors)
+        {
+            _writer.WriteStartElement(TopLevelFields.Sensors.ToString());
+            var count = -1;
+            foreach (var sd in sensors)
+            {
+                sd.DatabaseId = count;
+                count--;
+                _writer.Flush();
+                sd.WriteXML(ref _writer);
+                _writer.Flush();
+            }
+            _writer.WriteEndElement();
+            return GetXmlElement();
+        }
+    }
+}

Common/DTS.Common.Import/XML/XMLPre20ParseTestSetups.cs

@@ -0,0 +1,457 @@
+
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using System.Xml;
+using DataPROWin7.DataModel;
+using DTS.Common.Classes.Groups.ChannelSettings;
+using DTS.Common.Classes.Groups;
+using DTS.Common.Enums.Sensors;
+using DTS.Common.Interface.Channels;
+using DTS.Common.Interface.Groups.GroupList;
+using DTS.Common.SharedResource.Strings;
+using DTS.SensorDB;
+using DTS.Common.Classes.Sensors;
+using DTS.Common.Enums;
+using DTS.Common.Enums.DBExport;
+using DTS.Common.Utils;
+
+namespace DTS.Common.Import.XML
+{
+
+    public class XMLPre20ParseTestSetups : XMLParseBase
+    {
+        private readonly IsoViewMode _isoViewMode;
+        private readonly XMLParseTestSetups _xmlParseTestSetups;
+        public XMLPre20ParseTestSetups(XmlElement root, double importedVersion, IsoViewMode isoViewMode, XMLParseTestSetups xmlParseTestSetups, Func<bool> isCancelled = null) : base(root, importedVersion, isCancelled)
+        {
+            _isoViewMode = isoViewMode;
+            _xmlParseTestSetups = xmlParseTestSetups;
+        }
+
+        private XmlElement MigratePre20TestTemplate(IEnumerable<TestTemplate> testTemplates, ImportObject importObject)
+        {
+
+            _writer.WriteStartElement(TopLevelFields.TestSetups.ToString());
+            foreach (var t in testTemplates)
+            {
+                //Migrate HardwareOverrides to HardwareIncludes and HardwareRemoves
+
+                //Since we're migrating an earlier version of a Test Setup export which does not have
+                //a <DASList> within the <TestSetup>, change this Test Setup's <DASList><SamplesPerSecond> 
+                //from the Test Setup default to this Test Setup's aggregate sample rate
+                //Also, initialize all DAS in the DASClockMasterList to false.
+                var testSetupDAS = importObject.Hardware();
+                foreach (var das in testSetupDAS)
+                {
+                    t.DASSampleRateList[das.SerialNumber] = t.SamplesPerSecondAggregate;
+                    t.DASAAFRateList[das.SerialNumber] = TestTemplate.GetAAFForHardware(das, (int)t.SamplesPerSecondAggregate);
+                    t.DASClockMasterList[das.SerialNumber] = false;
+                    t.DASPTPDomainIDList[das.SerialNumber] = 0;
+                }
+
+                //Migrate Groups
+                var count = -1;
+                var oldToNewChannelIds = new Dictionary<string, int>();
+
+                foreach (var testObject in t.TestObjectsAndAddedGroupsList)
+                {
+                    //FB14086: Don't import channel-less groups
+                    if (!t.SensorLookup.ContainsKey(testObject.SerialNumber)) continue;
+                    IGroup newGroup = GroupHelper.CreateEmptyGroup();
+
+
+                    newGroup.StaticGroupId = GroupHelper.GetGroupId(testObject, _groupIdMapping, importObject.Groups()?.ToList());
+
+                    newGroup.Name = testObject.SerialNumber;
+                    newGroup.DisplayName = testObject.DisplaySerialNumber == TestTemplate.NON_ISO_INTERNAL_GROUP_NAME
+                            ? StringResources.TestChannels
+                            : testObject.DisplaySerialNumber;
+                    newGroup.DisplayOrder = testObject.DisplayOrder;
+                    newGroup.Position = testObject.Position.Position;
+                    newGroup.TestObject = testObject.TestObjectType;
+
+                    //13203 DataPRO failed on XML test setup import
+                    //13558 Imported test setup missing included hardware.
+                    //Get the embedded Group's hardware
+                    var hardwareStringList = new List<string>();
+                    foreach (var serialNumber in testObject.Hardware.Select(s => s.SerialNumber))
+                    {
+                        if (!hardwareStringList.Contains(serialNumber))
+                        {
+                            hardwareStringList.Add(serialNumber);
+                        }
+                    }
+                    newGroup.IncludedHardwareStringList = hardwareStringList.ToArray();
+
+                    t.Groups.Add(newGroup);
+
+                    var groupChannelsList = new List<IGroupChannel>();
+                    foreach (var groupName in t.SensorLookup.Keys)
+                    {
+                        if (groupName == newGroup.Name)
+                        {
+                            var channels = t.SensorLookup[groupName];
+                            foreach (var channelName in channels.Keys)
+                            {
+                                var sensors = channels[channelName];
+                                foreach (var sensorName in sensors.Keys) //Really only 1
+                                {
+                                    var groupChannel = new GroupChannel(true, newGroup.DisplayName, newGroup, new IChannelSetting[0]);
+                                    groupChannel.IsoChannelName = channelName.StartsWith("TSD_")
+                                            ? StringResources.SensorTableControl_DigitalOutputSetting
+                                            : channelName;
+                                    var isoCode = sensors[sensorName].ISOCode;
+                                    isoCode = isoCode.Remove(12, 2).Insert(12, sensors[sensorName].PhysicalDimension);
+                                    isoCode = isoCode.Remove(14, 1).Insert(14, sensors[sensorName].Direction);
+                                    groupChannel.IsoCode = isoCode;
+                                    groupChannel.UserChannelName = channelName.StartsWith("TSD_")
+                                        ? StringResources.SensorTableControl_DigitalOutputSetting
+                                        : channelName;
+                                    groupChannel.UserCode = string.Empty;
+                                    groupChannel.IsDisabled = false;
+
+                                    //Migrate the Settings string from the XML (0=2400,1=A, etc.)
+                                    var settings = new List<IChannelSetting>();
+
+
+                                    switch (sensors[sensorName].Bridge)
+                                    {
+                                        case SensorConstants.BridgeType.IEPE:
+                                        case SensorConstants.BridgeType.QuarterBridge:
+                                        case SensorConstants.BridgeType.HalfBridge:
+                                        case SensorConstants.BridgeType.FullBridge:
+                                        case SensorConstants.BridgeType.HalfBridge_SigPlus:
+                                            settings.Add(new ChannelSettingBase((int)SensorConstants.SensorSettings.Range + 1, ChannelSettingBase.RANGE, "2400")
+                                            { DoubleValue = sensors[sensorName].Capacity });
+                                            //FB 15574 use filter class instead of cfc 
+                                            settings.Add(new ChannelSettingBase((int)SensorConstants.SensorSettings.FilterClass + 1, ChannelSettingBase.FilterClass, "None,0")
+                                            { Value = FilterClass.GetFilterClassSettingFromFilterClass(sensors[sensorName].FilterClass) });
+                                            settings.Add(new ChannelSettingBase((int)SensorConstants.SensorSettings.Polarity + 1, ChannelSettingBase.POLARITY, "+")
+                                            { Value = sensors[sensorName].Invert ? "-" : "+" });
+                                            settings.Add(new ChannelSettingBase((int)SensorConstants.SensorSettings.Position + 1, ChannelSettingBase.POSITION, "?")
+                                            { Value = sensors[sensorName].Position });
+
+                                            //18861 When migrating from pre-2.0 add these settings
+                                            ZeroMethod zeroMethod = sensors[sensorName].Calibration.ZeroMethods.Methods.LastOrDefault();
+                                            settings.Add(new ChannelSettingBase((int)SensorConstants.SensorSettings.ZeroMethod + 1, ChannelSettingBase.ZEROMETHOD, "AverageOverTime")
+                                            { Value = zeroMethod.Method.ToString() });
+                                            settings.Add(new ChannelSettingBase((int)SensorConstants.SensorSettings.ZeroMethodStart + 1, ChannelSettingBase.ZEROMETHODSTART, "-0.05")
+                                            { DoubleValue = zeroMethod.Start });
+                                            settings.Add(new ChannelSettingBase((int)SensorConstants.SensorSettings.ZeroMethodEnd + 1, ChannelSettingBase.ZEROMETHODEND, "-0.02")
+                                            { DoubleValue = zeroMethod.End });
+
+                                            settings.Add(new ChannelSettingBase((int)SensorConstants.SensorSettings.UserValue1 + 1, ChannelSettingBase.USERVALUE1, "")
+                                            { Value = sensors[sensorName].UserValue1 });
+                                            settings.Add(new ChannelSettingBase((int)SensorConstants.SensorSettings.UserValue2 + 1, ChannelSettingBase.USERVALUE2, "")
+                                            { Value = sensors[sensorName].UserValue2 });
+                                            settings.Add(new ChannelSettingBase((int)SensorConstants.SensorSettings.UserValue3 + 1, ChannelSettingBase.USERVALUE3, "")
+                                            { Value = sensors[sensorName].UserValue3 });
+
+                                            InitialOffset initialOffset = sensors[sensorName].Calibration.InitialOffsets.Offsets.LastOrDefault();
+                                            settings.Add(new ChannelSettingBase((int)SensorConstants.SensorSettings.InitialOffset + 1, ChannelSettingBase.INITIAL_OFFSET, "None,0,0")
+                                            { Value = $"{initialOffset.Form},{initialOffset.EU},{initialOffset.MV}" });
+
+                                            settings.Add(new ChannelSettingBase((int)SensorConstants.SensorSettings.ACCouplingEnabled + 1, ChannelSettingBase.ACCouplingEnabled, "0")
+                                            {
+                                                Value = "FALSE"
+                                            });
+                                            break;
+
+                                        case SensorConstants.BridgeType.DigitalInput:
+                                            settings.Add(new ChannelSettingBase((int)SensorConstants.SensorSettings.DefaultValue + 1, ChannelSettingBase.DEFAULT_VALUE, "0")
+                                            { DoubleValue = sensors[sensorName].ScaleMultiplier.DefaultValue });
+                                            settings.Add(new ChannelSettingBase((int)SensorConstants.SensorSettings.ActiveValue + 1, ChannelSettingBase.ACTIVE_VALUE, "1")
+                                            { DoubleValue = sensors[sensorName].ScaleMultiplier.ActiveValue });
+                                            settings.Add(new ChannelSettingBase((int)SensorConstants.SensorSettings.DIMode + 1, ChannelSettingBase.DIMODE, "8")
+                                            { IntValue = (int)sensors[sensorName].InputMode });
+                                            break;
+
+                                        case SensorConstants.BridgeType.SQUIB:
+                                            settings.Add(new ChannelSettingBase((int)SensorConstants.SensorSettings.SQMode + 1, ChannelSettingBase.SQMODE, "1")
+                                            { IntValue = (int)sensors[sensorName].SquibFireMode });
+                                            settings.Add(new ChannelSettingBase((int)SensorConstants.SensorSettings.SquibDelay + 1, ChannelSettingBase.SQUIB_DELAY, "0")
+                                            { DoubleValue = sensors[sensorName].SquibFireDelayMS });
+                                            settings.Add(new ChannelSettingBase((int)SensorConstants.SensorSettings.SquibDuration + 1, ChannelSettingBase.SQUIB_DURATION, "100")
+                                            { DoubleValue = sensors[sensorName].SquibFireDurationMS });
+                                            settings.Add(new ChannelSettingBase((int)SensorConstants.SensorSettings.SquibLimitDuration + 1, ChannelSettingBase.SQUIB_LIMIT_DURATION, "1")
+                                            { BoolValue = sensors[sensorName].LimitSquibFireDuration });
+                                            settings.Add(new ChannelSettingBase((int)SensorConstants.SensorSettings.SquibCurrent + 1, ChannelSettingBase.SQUIB_CURRENT, "1.5")
+                                            { DoubleValue = sensors[sensorName].SquibOutputCurrent });
+                                            break;
+
+                                        case SensorConstants.BridgeType.TOMDigital:
+                                            settings.Add(new ChannelSettingBase((int)SensorConstants.SensorSettings.OutputMode + 1, ChannelSettingBase.OUTPUT_MODE, "1")
+                                            { IntValue = (int)sensors[sensorName].DigitalOutputMode });
+                                            settings.Add(new ChannelSettingBase((int)SensorConstants.SensorSettings.DigitalOutLimitDuration + 1, ChannelSettingBase.DIGITALOUT_LIMIT_DURATION, "1")
+                                            { BoolValue = sensors[sensorName].DigitalOutputLimitDuration });
+                                            settings.Add(new ChannelSettingBase((int)SensorConstants.SensorSettings.DigitalOutDuration + 1, ChannelSettingBase.DIGITALOUT_DURATION, "100")
+                                            { DoubleValue = sensors[sensorName].DigitalOutputDurationMS });
+                                            settings.Add(new ChannelSettingBase((int)SensorConstants.SensorSettings.DigitalOutDelay + 1, ChannelSettingBase.DIGITALOUT_DELAY, "0")
+                                            { DoubleValue = sensors[sensorName].DigitalOutputDelayMS });
+                                            break;
+
+                                        case SensorConstants.BridgeType.UART:
+                                            settings.Add(new ChannelSettingBase((int)SensorConstants.SensorSettings.UartBaudRate + 1, ChannelSettingBase.BAUD_RATE, "57600")
+                                            { IntValue = (int)sensors[sensorName].UartBaudRate });
+                                            settings.Add(new ChannelSettingBase((int)SensorConstants.SensorSettings.UartDataBits + 1, ChannelSettingBase.DATA_BITS, "8")
+                                            { IntValue = (int)sensors[sensorName].UartDataBits });
+                                            settings.Add(new ChannelSettingBase((int)SensorConstants.SensorSettings.UartStopBits + 1, ChannelSettingBase.STOP_BITS, "None")
+                                            { Value = sensors[sensorName].UartStopBits.ToString() });
+                                            settings.Add(new ChannelSettingBase((int)SensorConstants.SensorSettings.UartParity + 1, ChannelSettingBase.PARITY, "None")
+                                            { Value = sensors[sensorName].UartParity.ToString() });
+                                            settings.Add(new ChannelSettingBase((int)SensorConstants.SensorSettings.UartFlowControl + 1, ChannelSettingBase.FLOW_CONTROL, "None")
+                                            { Value = sensors[sensorName].UartFlowControl.ToString() });
+                                            settings.Add(new ChannelSettingBase((int)SensorConstants.SensorSettings.UartDataFormat + 1, ChannelSettingBase.DATA_FORMAT, "Binary")
+                                            { Value = sensors[sensorName].UartDataFormat.ToString() });
+                                            break;
+                                    }
+
+                                    groupChannel.ChannelSettings = settings.ToArray();
+
+                                    foreach (var sensor in importObject.Sensors())
+                                    {
+                                        if (sensor.SerialNumber == sensors[sensorName].SerialNumber)
+                                        {
+                                            groupChannel.SetSensorData(sensors[sensorName], null);
+                                            groupChannel.SensorId = sensor.DatabaseId;
+                                            break;
+                                        }
+                                    }
+                                    foreach (var hardware in importObject.Hardware())
+                                    {
+                                        foreach (var group in importObject.Groups())
+                                        {
+                                            foreach (var channel in group.GetISOTestObject().AllChannels)
+                                            {
+                                                var hardwareUnderscoreSplit = channel.HardwareId.Split('_');
+
+                                                if (hardwareUnderscoreSplit[0] == hardware.SerialNumber &&
+                                                    group.SerialNumber == groupChannel.Group.Name &&
+                                                    sensorName == channel.SensorSerialNumber)
+                                                {
+                                                    groupChannel.DASId = hardware.DASId;
+                                                    var hardwareXSplit = channel.HardwareId.Split('x');
+                                                    groupChannel.DASChannelIndex = Convert.ToInt32(hardwareXSplit[1]) - 1;
+                                                }
+                                            }
+                                        }
+                                    }
+
+                                    foreach (var g in importObject.Groups())
+                                    {
+                                        if (g.SerialNumber == groupName)
+                                        {
+                                            foreach (var ch in g.GetISOTestObject().AllChannels)
+                                            {
+                                                if (ch.Name == channelName)
+                                                {
+                                                    groupChannel.Id = count;
+                                                    var channelParts = ch.GetId().Split('_');
+                                                    groupChannel.GroupChannelOrder = Convert.ToInt32(channelParts[channelParts.Length - 1]);
+                                                    oldToNewChannelIds[ch.GetId()] = count;
+                                                    count--;
+                                                }
+                                            }
+                                        }
+                                    }
+
+                                    groupChannelsList.Add(groupChannel);
+                                }
+                            }
+                        }
+                    }
+                    t.ChannelsForGroup[newGroup] = groupChannelsList.ToArray();
+                }
+
+                //Migrate Graphs
+                foreach (var testGraph in t.TestGraphs)
+                {
+                    foreach (var testGraphChannel in testGraph.Channels)
+                    {
+                        foreach (var group in t.Groups)
+                        {
+                            foreach (var channel in t.ChannelsForGroup[group])
+                            {
+                                if (channel.GetChannelName(_isoViewMode) == testGraphChannel.Name)
+                                {
+                                    testGraph.AddChannel(channel);
+                                }
+                            }
+                        }
+                    }
+                }
+
+                //Migrate CalculatedChannels
+                foreach (var calculatedChannel in t.CalculatedChannels)
+                {
+                    var groupChannelsList = new List<IGroupChannel>();
+                    foreach (var calculatedChannelInputChannel in calculatedChannel.TestObjectChannels)
+                    {
+                        foreach (var group in t.Groups)
+                        {
+                            foreach (var channel in t.ChannelsForGroup[group])
+                            {
+                                //15242 Sensors swapped on calculated channel when importing test setup.
+                                //use name of the channel to match between test channels and calculated input channel ...
+                                if (channel.GetChannelName(_isoViewMode) == calculatedChannelInputChannel.NameOfTheChannel)
+                                {
+                                    groupChannelsList.Add(channel);
+                                }
+                            }
+                        }
+                    }
+                    calculatedChannel.SetChannels(groupChannelsList.ToArray());
+                }
+
+                //Migrate LevelTriggers
+                foreach (var levelTrigger in t.LevelTriggerChannels.Select(l => l.Value))
+                {
+                    foreach (var group in t.Groups)
+                    {
+                        foreach (var channel in t.ChannelsForGroup[group])
+                        {
+                            if ((channel.SensorData != null) && (channel.SensorData.SerialNumber == levelTrigger.SensorSerialNumber))
+                            {
+                                levelTrigger.GroupChannelId = channel.Id.ToString(CultureInfo.InvariantCulture);
+                                levelTrigger.GroupChannel = channel;
+                                channel.HardwareId = levelTrigger.HardwareChannelId;
+                            }
+                        }
+                    }
+                }
+                //first go through all groups, add any hardware from any groups in the test setup
+                var addedHardwareList = new List<int>();
+                var removedHardwareList = new List<int>();
+                foreach (var group in t.Groups)
+                {
+                    foreach (var h in group.IncludedHardwareStringList)
+                    {
+                        var matches = from hw in importObject.Hardware() where hw.SerialNumber == h select hw;
+                        if (matches.Any())
+                        {
+                            foreach (var match in matches)
+                            {
+                                if (!addedHardwareList.Contains(match.DASId))
+                                {
+                                    addedHardwareList.Add(match.DASId);
+                                }
+                            }
+                        }
+                    }
+                }
+                //finally add any hardware add/remove specific instructions
+                foreach (var hardwareOverride in t.HardwareOverrides.Select(p => p.Value))
+                {
+                    var dasId = 0;
+                    var dasParts = hardwareOverride.HardwareId.Split('_');
+                    foreach (var hardware in importObject.Hardware())
+                    {
+                        if (hardware.SerialNumber == dasParts[0])
+                        {
+                            dasId = hardware.DASId;
+                            if (hardwareOverride.Action == HardwareInclusionInstruction.Actions.Add)
+                            {
+                                addedHardwareList.Add(dasId);
+                            }
+                            else if (hardwareOverride.Action == HardwareInclusionInstruction.Actions.Remove)
+                            {
+                                if (addedHardwareList.Contains(dasId))
+                                {
+                                    addedHardwareList.Remove(dasId);
+                                }
+
+                                removedHardwareList.Add(dasId);
+                            }
+                            break;
+                        }
+                    }
+                }
+                t.AddedHardware = addedHardwareList.ToArray();
+                t.RemovedHardware = removedHardwareList.ToArray();
+                t.HardwareOverrides.Clear();
+
+                _writer.Flush();
+                t.WriteXML(ref _writer);
+                _writer.Flush();
+            }
+            _writer.WriteEndElement();
+            return GetXmlElement();
+        }
+        private IEnumerable<TestTemplate> ParsePre20TestTemplate(ImportObject importObject)
+        {
+            List<TestTemplate> testTemplates = new List<TestTemplate>();
+
+            var testobjectLookup = new Dictionary<string, TestObject>();
+
+            foreach (var to in importObject.Groups())
+            {
+                if (IsCancelled()) { return testTemplates; }
+                testobjectLookup[to.SerialNumber] = to;
+            }
+
+            var customerDetailsLookup = new Dictionary<string, ISO.CustomerDetails>();
+            foreach (var c in importObject.CustomerDetails())
+            {
+                if (IsCancelled()) { return testTemplates; }
+                customerDetailsLookup[c.Name] = c;
+            }
+
+            var testEngineerDetailsLookup = new Dictionary<string, ISO.TestEngineerDetails>();
+            foreach (var t in importObject.TestEngineerDetails())
+            {
+                if (IsCancelled()) { return testTemplates; }
+                testEngineerDetailsLookup[t.Name] = t;
+            }
+
+            var labDetailsLookup = new Dictionary<string, ISO.LabratoryDetails>();
+            foreach (var l in importObject.LabDetails())
+            {
+                if (IsCancelled()) { return testTemplates; }
+                labDetailsLookup[l.Name] = l;
+            }
+
+            var sensorLookup = new Dictionary<string, SensorData>();
+            foreach (var s in importObject.Sensors())
+            {
+                if (IsCancelled()) { return testTemplates; }
+                sensorLookup[s.SerialNumber] = s;
+            }
+
+            foreach (var node in _root.ChildNodes)
+            {
+                if (IsCancelled()) { return testTemplates; }
+                if (node is XmlElement)
+                {
+                    var d = new TestTemplate();
+                    d.ReadXMLPre20(node as XmlElement, testobjectLookup, labDetailsLookup, customerDetailsLookup, testEngineerDetailsLookup, sensorLookup, importObject.Hardware()?.ToList());
+                    testTemplates.Add(d);
+
+                }
+            }
+
+            return testTemplates;
+        }
+
+
+        public override void Parse(ref ImportObject importObject)
+        {
+            var testTemplates = ParsePre20TestTemplate(importObject);
+            if (!testTemplates.Any())
+            {
+                return;
+            }
+            XmlElement newRoot = MigratePre20TestTemplate(testTemplates, importObject);
+            if (newRoot == null)
+            {
+                return;
+            }
+
+            importObject.AddTestSetups(_xmlParseTestSetups.ParseTestTemplate(importObject, newRoot));
+            //FB 38039,40758 Identify test setup type
+            importObject.TestSetupImportFileFormat = importObject.GetImportFileFormat();
+
+        }
+    }
+}