init

DataPRO/Modules/PreviousDBVersions/Version57/DatabaseExport/ISO/AbstractOLEDbWrapper.cs

@@ -0,0 +1,20 @@
+using System;
+using System.Data;
+using System.Data.OleDb;
+
+namespace DatabaseExport
+{
+    public abstract class AbstractOLEDbWrapper
+    {
+        public static long GetLong(IDataReader reader, string field)
+        {
+            if (DBNull.Value == reader[field]) { return long.MinValue; }
+            else { return Convert.ToInt64(reader[field]); }
+        }
+        public static DateTime GetDate(IDataReader reader, string field)
+        {
+            if (DBNull.Value != reader[field]) { return (DateTime)reader[field]; }
+            else { return DateTime.MinValue; }
+        }
+    }
+}

DataPRO/Modules/PreviousDBVersions/Version57/DatabaseExport/ISO/CalculatedValueClass.cs

@@ -0,0 +1,98 @@
+/* Copyright 2017 Diversified Technical Systems
+*/
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace DatabaseExport
+{
+    /// <summary>
+    /// this class will probably become an abstract base class in the future but for now since we only have
+    /// summed realtime channels, we can be a little less formal
+    /// </summary>
+    public class CalculatedValueClass
+    {
+        public CalculatedValueClass(System.Data.DataRow dr)
+        {
+            var fields = Enum.GetValues(typeof(DbOperations.CalculatedChannels.Fields))
+                .Cast<DbOperations.CalculatedChannels.Fields>().ToArray();
+
+            foreach (var field in fields)
+            {
+                var o = dr[field.ToString()];
+                if (DBNull.Value.Equals(o)) { continue; }
+                switch (field)
+                {
+                    case DbOperations.CalculatedChannels.Fields.TestSetupName:
+                        TestSetupName = Convert.ToString(o);
+                        break;
+                    case DbOperations.CalculatedChannels.Fields.Operation:
+                        Operation = (Operations)Convert.ToInt32(o);
+                        break;
+                    case DbOperations.CalculatedChannels.Fields.InputChannelIds:
+                        InputChannelIdsBlob = (byte[])o;
+                        break;
+                    case DbOperations.CalculatedChannels.Fields.Id:
+                        Id = Convert.ToInt32(o);
+                        break;
+                    case DbOperations.CalculatedChannels.Fields.CFCForOutput:
+                        ChannelFilterClassForOutput = Convert.ToString(o);
+                        break;
+                    case DbOperations.CalculatedChannels.Fields.CFCForInputChannels:
+                        CFCForInputChannels = Convert.ToString(o);
+                        break;
+                    case DbOperations.CalculatedChannels.Fields.CCName:
+                        Name = Convert.ToString(o);
+                        break;
+                    case DbOperations.CalculatedChannels.Fields.CalculatedChannelValueCode:
+                        CalculatedValueCode = Convert.ToString(o);
+                        break;
+                }
+            }
+        }
+
+        public int Id { get; set; } = -1;
+
+        public enum Operations
+        {
+            SUM = 1,
+            AVERAGE = 2,
+            IRTRACC3D = 3,
+            IRTRACC3D_ABDOMEN = 4,
+            IRTRACC3D_LOWERTHORAX = 5
+        }
+
+        public Operations Operation { get; set; } = Operations.SUM;
+
+        public string CalculatedValueCode { get; set; } = "???????????????X";
+
+        private List<string> _inputChannelIds = new List<string>();
+        public string[] InputChannelIds
+        {
+            get => _inputChannelIds.ToArray();
+            set => _inputChannelIds = new List<string>(value);
+        }
+        public byte[] InputChannelIdsBlob
+        {
+            get
+            {
+                var text = string.Join(System.Globalization.CultureInfo.InvariantCulture.TextInfo.ListSeparator, InputChannelIds);
+                return System.Text.Encoding.UTF8.GetBytes(text);
+            }
+            set
+            {
+                _inputChannelIds.Clear();
+                var text = System.Text.Encoding.UTF8.GetString(value);
+                InputChannelIds = text.Split(new[] { System.Globalization.CultureInfo.InvariantCulture.TextInfo.ListSeparator }, StringSplitOptions.None);
+            }
+        }
+
+        public string CFCForInputChannels { get; set; } = "";
+
+        public string ChannelFilterClassForOutput { get; set; } = "";
+
+        public string TestSetupName { get; set; }
+
+        public string Name { get; set; }
+    }
+}

DataPRO/Modules/PreviousDBVersions/Version57/DatabaseExport/ISO/CustomerDetails.cs

@@ -0,0 +1,201 @@
+using System;
+using System.Collections.Generic;
+using System.Data;
+
+namespace DatabaseExport.ISO
+{
+    [Serializable()]
+    public class CustomerDetails //: ISerializableFile
+    {
+        private enum Fields
+        {
+            Name,
+            CustomerName,
+            CustomerTestRefNumber,
+            ProjectRefNumber,
+            CustomerOrderNumber,
+            CustomerCostUnit,
+            LocalOnly,
+            LastModified,
+            LastModifiedBy,
+            Version
+        }
+        public Dictionary<string, string> GetValues()
+        {
+            var elementNameValuePairs = new Dictionary<string, string>();
+
+            elementNameValuePairs[Fields.Name.ToString()] = Name;
+            elementNameValuePairs[Fields.CustomerName.ToString()] = CustomerName;
+            elementNameValuePairs[Fields.CustomerTestRefNumber.ToString()] = CustomerTestRefNumber;
+            elementNameValuePairs[Fields.ProjectRefNumber.ToString()] = ProjectRefNumber;
+            elementNameValuePairs[Fields.CustomerOrderNumber.ToString()] = CustomerOrderNumber;
+            elementNameValuePairs[Fields.CustomerCostUnit.ToString()] = CustomerCostUnit;
+            elementNameValuePairs[Fields.LocalOnly.ToString()] = LocalOnly.ToString();
+            elementNameValuePairs[Fields.LastModified.ToString()] = LastModified.ToString(System.Globalization.CultureInfo.InvariantCulture);
+            elementNameValuePairs[Fields.LastModifiedBy.ToString()] = LastModifiedBy;
+            elementNameValuePairs[Fields.Version.ToString()] = Version.ToString(System.Globalization.CultureInfo.InvariantCulture);
+
+            return elementNameValuePairs;
+        }
+        private string _customerName = string.Empty;
+        public string CustomerName
+        {
+            get => _customerName;
+            set => _customerName = value;
+        }
+
+        private string _customerTestRefNumber = string.Empty;
+        public string CustomerTestRefNumber
+        {
+            get => _customerTestRefNumber;
+            set => _customerTestRefNumber = value;
+        }
+
+        private string _projectRefNumber = "NOVALUE";
+        public string ProjectRefNumber
+        {
+            get => _projectRefNumber;
+            set
+            {
+                if (value != string.Empty)
+                {
+                    _projectRefNumber = value;
+                }
+            }
+        }
+
+        private string _customerOrderNumber = "NOVALUE";
+        public string CustomerOrderNumber
+        {
+            get => _customerOrderNumber;
+            set
+            {
+                if (value != string.Empty)
+                {
+                    _customerOrderNumber = value;
+                }
+            }
+        }
+
+        private string _customerCostUnit = "NOVALUE";
+        public string CustomerCostUnit
+        {
+            get => _customerCostUnit;
+            set
+            {
+                if (value != string.Empty)
+                {
+                    _customerCostUnit = value;
+                }
+            }
+        }
+        private bool _localOnly = false;
+        public bool LocalOnly
+        {
+            get => _localOnly;
+            set => _localOnly = value;
+        }
+
+        private string _name = "";
+        public string Name
+        {
+            get => _name;
+            set => _name = value;
+        }
+
+        private DateTime _lastModified;
+        public DateTime LastModified
+        {
+            get => _lastModified;
+            set => _lastModified = value;
+        }
+
+        private string _lastModifiedBy;
+        public string LastModifiedBy
+        {
+            get => _lastModifiedBy;
+            set => _lastModifiedBy = value;
+        }
+        private int _version = 1;
+        public int Version
+        {
+            get => _version;
+            set => _version = value;
+        }
+
+        public CustomerDetails()
+        {
+        }
+        public CustomerDetails(DataRow dr)
+        {
+            _name = (string)dr["Name"];
+            CustomerName = (string)dr["CustomerName"];
+            CustomerTestRefNumber = (string)dr["CustomerTestRefNumber"];
+            ProjectRefNumber = (string)dr["ProjectRefNumber"];
+            CustomerOrderNumber = (string)dr["CustomerOrderNumber"];
+            CustomerCostUnit = (string)dr["CustomerCostUnit"];
+            _localOnly = Convert.ToBoolean(dr["LocalOnly"]);
+            _lastModified = Convert.ToDateTime(dr["LastModified"]);
+            _lastModifiedBy = (string)dr["LastModifiedBy"];
+            _version = Convert.ToInt32(dr["Version"]);
+        }
+        public CustomerDetails(CustomerDetails copy)
+        {
+            _name = copy.Name;
+            CustomerName = copy.CustomerName;
+            CustomerTestRefNumber = copy.CustomerTestRefNumber;
+            ProjectRefNumber = copy.ProjectRefNumber;
+            CustomerOrderNumber = copy.CustomerOrderNumber;
+            CustomerCostUnit = copy.CustomerCostUnit;
+            _localOnly = copy.LocalOnly;
+            _lastModified = copy.LastModified;
+            _lastModifiedBy = copy.LastModifiedBy;
+            _version = copy.Version;
+        }
+        public static CustomerDetails[] GetAllCustomerDetails()
+        {
+            var list = new List<CustomerDetails>();
+            try
+            {
+                using (var sql = DbOperations.GetCommand())
+                {
+                    /* always optimize sql statement! */
+                    sql.CommandText = @"SELECT Name" +
+                                      ",CustomerName" +
+                                      ",CustomerTestRefNumber" +
+                                      ",ProjectRefNumber" +
+                                      ",CustomerOrderNumber" +
+                                      ",CustomerCostUnit" +
+                                      ",LocalOnly" +
+                                      ",LastModified" +
+                                      ",LastModifiedBy" +
+                                      ",Version " +
+                                      "from [tblCustomerDetails]";
+
+                    using (var ds = DbOperations.Connection.QueryDataSet(sql))
+                    {
+                        if (ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0)
+                        {
+                            foreach (DataRow dr in ds.Tables[0].Rows)
+                            {
+                                try
+                                {
+                                    list.Add(new CustomerDetails(dr));
+                                }
+                                catch (Exception)
+                                {
+                                    //DTS.Utilities.Logging.APILogger.Log("failed to get customer details", ex);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            catch (Exception)
+            {
+                //DTS.Utilities.Logging.APILogger.Log("Failed to retrieve customer details", ex);
+            }
+            return list.ToArray();
+        }
+    }
+}

DataPRO/Modules/PreviousDBVersions/Version57/DatabaseExport/ISO/Hardware.cs

@@ -0,0 +1,334 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Data;
+
+namespace DatabaseExport
+{
+    public class Hardware //: INotifyPropertyChanged
+    {
+        public enum HardwareTypes
+        {
+            SLICE_Base = 0,
+            SLICE_Bridge = 1,
+            SLICE_Distributor = 2,
+            TDAS_Pro_Rack = 3,
+            SLICE2_IEPE_Hi = 4,
+            SLICE2_IEPE_Lo = 5,
+            SLICE2_Bridge_Hi = 6,
+            SLICE2_Bridge_Lo = 7,
+            SLICE2_Base = 8,
+            TOM = 9,
+            SIM = 10,
+            DIM = 11,
+            G5VDS = 12,
+            Ribeye = 13,
+            RibeyeLED = 14,
+            SLICE_IEPE = 15,
+            SLICE1_5_Nano_Base = 16,
+            SLICE_Micro_Base = 17,
+            SLICE_NANO_Base = 18,
+            SLICE2_SIM = 19,
+            SLICE2_DIM = 20,
+            SLICE2_TOM = 21,
+            //G5IPORT=22,
+            G5INDUMMY = 23,
+            SLICE_EthernetController = 24,
+            SLICE1_5_Micro_Base = 25,
+            SLICE_LabEthernet = 26,
+            SLICE2_SLS = 27,
+            SLICE1_G5Stack = 28,
+            SLICE2_SLT = 29,
+            SLICE2_SLD = 30,
+            TDAS_LabRack = 31,
+            SLICE6_Base = 32
+        }
+        public static DateTime INVALIDDATE => new DateTime(1970, 1, 1);
+        public string SerialNumber { get; set; } = "";
+        public int CalInterval { get; set; } = 365;
+
+        public int DASType { get; set; } = 0;
+
+        public int MaxModules { get; set; } = 0;
+
+        public long MaxMemory { get; set; } = 0;
+
+        public double MinSampleRate { get; set; } = 0;
+
+        public double MaxSampleRate { get; set; } = 1000000;
+
+        public string FirmwareVersion { get; set; } = "";
+
+        private DateTime _calDate = INVALIDDATE;
+        public DateTime CalDate
+        {
+            get
+            {
+                if (_calDate < INVALIDDATE) { return INVALIDDATE; }
+                return _calDate;
+            }
+            set => _calDate = value;
+        }
+
+        public int ProtocolVersion { get; set; } = 0;
+
+        public DateTime LastModified { get; set; } = DateTime.Now;
+
+        public string LastModifiedBy { get; set; } = "";
+
+        public int Version { get; set; } = 1;
+
+        public bool LocalOnly { get; set; } = false;
+
+        public DateTime LastUsed { get; set; } = INVALIDDATE;
+
+        public string LastUsedBy { get; set; } = "";
+
+        public string IPAddress { get; set; } = "";
+
+        public int Channels { get; set; } = 0;
+
+        public string Position { get; set; } = "";
+
+        public bool IsProgrammable { get; set; } = false;
+
+        public bool IsModule { get; set; } = false;
+
+        public bool IsReconfigurable { get; set; } = false;
+
+        private int[] _channelTypes = null;
+        public int[] ChannelTypes
+        {
+            get
+            {
+                if (null == _channelTypes) { _channelTypes = new int[0]; }
+                return _channelTypes;
+            }
+            set => _channelTypes = value;
+        }
+
+        public Hardware()
+        {
+
+        }
+        public Hardware(Hardware copy)
+        {
+            Version = copy.Version;
+            SerialNumber = copy.SerialNumber;
+            ProtocolVersion = copy.ProtocolVersion;
+            Position = copy.Position;
+            MinSampleRate = copy.MinSampleRate;
+            MaxSampleRate = copy.MaxSampleRate;
+            MaxModules = copy.MaxModules;
+            MaxMemory = copy.MaxMemory;
+            LocalOnly = copy.LocalOnly;
+            LastUsedBy = copy.LastUsedBy;
+            LastUsed = copy.LastUsed;
+            LastModifiedBy = copy.LastModifiedBy;
+            LastModified = copy.LastModified;
+            IsReconfigurable = copy.IsReconfigurable;
+            IsProgrammable = copy.IsProgrammable;
+            var channels = new List<ISOHardwareChannel>();
+            foreach (var c in copy.ISOChannels)
+            {
+                channels.Add(new ISOHardwareChannel(c, this));
+            }
+            ISOChannels = channels.ToArray();
+            IPAddress = copy.IPAddress;
+            FirmwareVersion = copy.FirmwareVersion;
+            DASType = copy.DASType;
+            var channeltypes = new int[copy.ChannelTypes.Length];
+            Array.Copy(copy.ChannelTypes, channeltypes, copy.ChannelTypes.Length);
+            ChannelTypes = channeltypes;
+            Channels = copy.Channels;
+            CalInterval = copy.CalInterval;
+            CalDate = copy.CalDate;
+            IsModule = copy.IsModule;
+        }
+        public Hardware(DataRow dr)
+        {
+            var fields = Enum.GetValues(typeof(DbOperations.DAS.Fields)).Cast<DbOperations.DAS.Fields>().ToArray();
+            foreach (var field in fields)
+            {
+                var o = dr[field.ToString()];
+                if (DBNull.Value.Equals(o)) { continue; }
+                switch (field)
+                {
+                    case DbOperations.DAS.Fields.CalDate:
+                        CalDate = Convert.ToDateTime(o);
+                        break;
+                    case DbOperations.DAS.Fields.Channels:
+                        Channels = Convert.ToInt32(o);
+                        break;
+                    case DbOperations.DAS.Fields.Connection:
+                        IPAddress = Convert.ToString(o);
+                        break;
+                    case DbOperations.DAS.Fields.FirmwareVersion:
+                        FirmwareVersion = Convert.ToString(o);
+                        break;
+                    case DbOperations.DAS.Fields.LastModified:
+                        LastModified = Convert.ToDateTime(o);
+                        break;
+                    case DbOperations.DAS.Fields.LastModifiedBy:
+                        LastModifiedBy = Convert.ToString(o);
+                        break;
+                    case DbOperations.DAS.Fields.LastUsed:
+                        LastUsed = Convert.ToDateTime(o);
+                        break;
+                    case DbOperations.DAS.Fields.LastUsedBy:
+                        LastUsedBy = Convert.ToString(o);
+                        break;
+                    case DbOperations.DAS.Fields.LocalOnly:
+                        LocalOnly = Convert.ToBoolean(o);
+                        break;
+                    case DbOperations.DAS.Fields.MaxMemory:
+                        MaxMemory = Convert.ToInt64(o);
+                        break;
+                    case DbOperations.DAS.Fields.MaxModules:
+                        MaxModules = Convert.ToInt32(o);
+                        break;
+                    case DbOperations.DAS.Fields.MaxSampleRate:
+                        MaxSampleRate = Convert.ToDouble(o);
+                        break;
+                    case DbOperations.DAS.Fields.MinSampleRate:
+                        MinSampleRate = Convert.ToDouble(o);
+                        break;
+                    case DbOperations.DAS.Fields.Position:
+                        Position = Convert.ToString(o);
+                        break;
+                    case DbOperations.DAS.Fields.Reconfigurable:
+                        IsReconfigurable = Convert.ToBoolean(o);
+                        break;
+                    case DbOperations.DAS.Fields.IsModule:
+                        IsModule = Convert.ToBoolean(o);
+                        break;
+                    case DbOperations.DAS.Fields.Reprogramable:
+                        IsProgrammable = Convert.ToBoolean(o);
+                        break;
+                    case DbOperations.DAS.Fields.ProtocolVersion:
+                        ProtocolVersion = Convert.ToInt32(o);
+                        break;
+                    case DbOperations.DAS.Fields.SerialNumber:
+                        SerialNumber = Convert.ToString(o);
+                        break;
+                    case DbOperations.DAS.Fields.Type:
+                        DASType = Convert.ToInt32(o);
+                        break;
+                    case DbOperations.DAS.Fields.ChannelTypes:
+                        {
+                            var s = o as string;
+                            var tokens = s.Split(new char[] { ',' });
+                            var types = new List<int>();
+                            foreach (var token in tokens)
+                            {
+                                if (int.TryParse(token, out var itemp)) { types.Add(itemp); }
+                            }
+                            ChannelTypes = types.ToArray();
+                        }
+                        break;
+                    case DbOperations.DAS.Fields.Version:
+                        Version = Convert.ToInt32(o);
+                        break;
+                    default:
+                        throw new NotSupportedException("Unknown field: " + field.ToString());
+
+                }
+            }
+            var channels = new List<ISOHardwareChannel>();
+            var requery = true;
+            using (var sql = DbOperations.GetCommand())
+            {
+                sql.CommandText = string.Format("SELECT * FROM [{0}] WHERE [{1}]=@{1}", DbOperations.DAS.TableDASChannels, DbOperations.DAS.DASChannelFields.HardwareId.ToString());
+                DbOperations.CreateParam(sql, string.Format("@{0}", DbOperations.DAS.DASChannelFields.HardwareId.ToString()), SqlDbType.NVarChar, GetId());
+                using (var ds = DbOperations.Connection.QueryDataSet(sql))
+                {
+                    if (null != ds.Tables && ds.Tables.Count > 0)
+                    {
+
+                        foreach (DataRow row in ds.Tables[0].Rows)
+                        {
+                            requery = false;
+                            channels.Add(new ISOHardwareChannel(row, this));
+                        }
+                    }
+                }
+            }
+            if (requery)
+            {
+                using (var sql = DbOperations.GetCommand())
+                {
+                    sql.CommandText = string.Format("SELECT * FROM [{0}] WHERE [{1}]=@{1}", DbOperations.DAS.TableDASChannels, DbOperations.DAS.DASChannelFields.HardwareId.ToString());
+                    DbOperations.CreateParam(sql, string.Format("@{0}", DbOperations.DAS.DASChannelFields.HardwareId.ToString()), SqlDbType.NVarChar, GetIdOld());
+                    using (var ds = DbOperations.Connection.QueryDataSet(sql))
+                    {
+                        if (null != ds.Tables && ds.Tables.Count > 0)
+                        {
+                            foreach (DataRow row in ds.Tables[0].Rows)
+                            {
+                                channels.Add(new ISOHardwareChannel(row, this));
+                            }
+                        }
+                    }
+                }
+            }
+            channels.Sort(ISOHardwareChannel.PhysicalCompare);
+            _isoChannels = channels;
+        }
+        private List<ISOHardwareChannel> _isoChannels = new List<ISOHardwareChannel>();
+        public ISOHardwareChannel[] ISOChannels
+        {
+            get => _isoChannels.ToArray();
+            set => _isoChannels = new List<ISOHardwareChannel>(value);
+        }
+
+        public static Hardware[] GetAllDAS()
+        {
+            var list = new List<Hardware>();
+            try
+            {
+                using (var sql = DbOperations.GetCommand())
+                {
+                    sql.CommandText = string.Format("SELECT * FROM [{0}]", DbOperations.DAS.Table);
+                    using (var ds = DbOperations.Connection.QueryDataSet(sql))
+                    {
+                        if (null != ds.Tables && ds.Tables.Count > 0)
+                        {
+                            foreach (DataRow dr in ds.Tables[0].Rows)
+                            {
+                                list.Add(new Hardware(dr));
+                            }
+                        }
+                    }
+                }
+            }
+            catch (Exception)
+            {
+                //DTS.Utilities.Logging.APILogger.Log("failed to retrieve all das, ", ex);
+            }
+            list.Sort(new HardwareCompare());
+            return list.ToArray();
+        }
+        public class HardwareCompare : Comparer<Hardware>
+        {
+            public override int Compare(Hardware x, Hardware y)
+            {
+                var ret = x.SerialNumber.CompareTo(y.SerialNumber);
+                if (0 == ret) { ret = x.IPAddress.CompareTo(y.IPAddress); }
+                return ret;
+            }
+        }
+        public string GetId()
+        {
+            return GetId(SerialNumber, DASType.ToString(), IPAddress);
+        }
+        public string GetIdOld()
+        {
+            return string.Format("{0}_{1}_{2}", SerialNumber, DASType.ToString(), IPAddress);
+        }
+        public static string GetId(string sn, string dastype, string ip)
+        {
+            return string.Format("{0}_{1}", sn, dastype);
+        }
+    }
+
+}

DataPRO/Modules/PreviousDBVersions/Version57/DatabaseExport/ISO/HardwareChannel.cs

@@ -0,0 +1,104 @@
+using System;
+using System.Linq;
+using System.Data;
+
+namespace DatabaseExport
+{
+    public class ISOHardwareChannel //: INotifyPropertyChanged
+    {
+        public Hardware ParentDAS { get; set; }
+
+        public int SupportedBridges { get; set; } = 12;
+
+        public int SupportedSquibFireModes { get; set; } = 16;
+
+        public int SupportedExcitations { get; set; } = 16;
+
+        public int SupportedDigitalInputModes { get; set; } = 16;
+
+        public int SupportedDigitalOutputModes { get; set; } = 16;
+
+        public int ChannelIdx { get; set; }
+
+        public int DASDisplayOrder { get; set; }
+
+        public string ModuleSerialNumber { get; set; } = "";
+
+        public int ModuleArrayIndex { get; set; } = 0;
+
+        public ISOHardwareChannel(ISOHardwareChannel copy, Hardware h)
+        {
+            SupportedSquibFireModes = copy.SupportedSquibFireModes;
+            SupportedExcitations = copy.SupportedExcitations;
+            SupportedDigitalOutputModes = copy.SupportedDigitalOutputModes;
+            SupportedDigitalInputModes = copy.SupportedDigitalInputModes;
+            SupportedBridges = copy.SupportedBridges;
+            ParentDAS = h;
+            LocalOnly = copy.LocalOnly;
+            DASDisplayOrder = copy.DASDisplayOrder;
+            ChannelIdx = copy.ChannelIdx;
+            ModuleArrayIndex = copy.ModuleArrayIndex;
+            ModuleSerialNumber = copy.ModuleSerialNumber;
+        }
+
+        public ISOHardwareChannel(DataRow dr, Hardware hardware)
+        {
+            ParentDAS = hardware;
+
+            var fields = Enum.GetValues(typeof(DbOperations.DAS.DASChannelFields)).Cast<DbOperations.DAS.DASChannelFields>().ToArray();
+            foreach (var field in fields)
+            {
+                var o = dr[field.ToString()];
+                if (DBNull.Value.Equals(o)) { continue; }
+                switch (field)
+                {
+                    case DbOperations.DAS.DASChannelFields.ChannelIdx:
+                        ChannelIdx = Convert.ToInt32(o);
+                        break;
+                    case DbOperations.DAS.DASChannelFields.HardwareId:
+                        //don't need, it gets it from the hardware passed in
+                        break;
+                    case DbOperations.DAS.DASChannelFields.SupportedBridges:
+                        SupportedBridges = Convert.ToInt32(o);
+                        break;
+                    case DbOperations.DAS.DASChannelFields.SupportedExcitations:
+                        SupportedExcitations = Convert.ToInt32(o);
+                        break;
+                    case DbOperations.DAS.DASChannelFields.SupportedDigitalInputModes:
+                        SupportedDigitalInputModes = Convert.ToInt32(o);
+                        break;
+                    case DbOperations.DAS.DASChannelFields.SupportedDigitalOutputModes:
+                        SupportedDigitalOutputModes = Convert.ToInt32(o);
+                        break;
+                    case DbOperations.DAS.DASChannelFields.SupportedSquibFireModes:
+                        SupportedSquibFireModes = Convert.ToInt32(o);
+                        break;
+                    case DbOperations.DAS.DASChannelFields.DASDisplayOrder:
+                        DASDisplayOrder = Convert.ToInt32(o);
+                        break;
+                    case DbOperations.DAS.DASChannelFields.ModuleSerialNumber:
+                        ModuleSerialNumber = o as string;
+                        break;
+                    case DbOperations.DAS.DASChannelFields.LocalOnly:
+                        LocalOnly = Convert.ToBoolean(o);
+                        break;
+                    case DbOperations.DAS.DASChannelFields.ModuleArrayIndex:
+                        ModuleArrayIndex = Convert.ToInt32(o);
+                        break;
+                    default:
+                        throw new NotSupportedException("Unknown field:" + field.ToString());
+                }
+            }
+        }
+
+        public bool LocalOnly { get; set; } = false;
+
+        public static int PhysicalCompare(ISOHardwareChannel left, ISOHardwareChannel right)
+        {
+            if (left == right) { return 0; }
+            if (null == left) { return -1; }
+            if (null == right) { return 1; }
+            return left.ChannelIdx.CompareTo(right.ChannelIdx);
+        }
+    }
+}

DataPRO/Modules/PreviousDBVersions/Version57/DatabaseExport/ISO/ISO13499FileDb.cs

@@ -0,0 +1,488 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Data.OleDb;
+using DatabaseExport.Properties;
+
+namespace DatabaseExport
+{
+    /// <summary>
+    /// this is a helper class wrapping access to the iso13499 access db
+    /// it also now makes use of datapro database tables which mimic the access db
+    /// </summary>
+    public class ISO13499FileDb
+    {
+        public class ExpiredISOFieldException : System.Exception
+        {
+            public ExpiredISOFieldException(string remark) : base(remark) { }
+        }
+        #region dictionaries
+        /// <summary>
+        /// list of directions, populated when first loaded
+        /// </summary>
+        private Dictionary<string, MMEDirections> _directionsDictionary = new Dictionary<string, MMEDirections>();
+        /// <summary>
+        /// list of filter classes, populated when first loaded
+        /// </summary>
+        private Dictionary<string, MMEFilterClasses> _filterClassesDictionary = new Dictionary<string, MMEFilterClasses>();
+        /// <summary>
+        /// list of figures, populated when first loaded
+        /// </summary>
+        private List<MMEFigures> _figures = new List<MMEFigures>();
+        /// <summary>
+        /// list of all known fine 1 locations, populated when first loaded 
+        /// </summary>
+        private Dictionary<string, MMEFineLocations1> _fineLoc1Dictionary = new Dictionary<string, MMEFineLocations1>();
+        /// <summary>
+        /// list of all known fine 2 locations, populated when first loaded
+        /// </summary>
+        private Dictionary<string, MMEFineLocations2> _fineLoc2Dictionary = new Dictionary<string, MMEFineLocations2>();
+        /// <summary>
+        /// list of all known fine 3 locations, populated when first loaded
+        /// </summary>
+        private Dictionary<string, MMEFineLocations3> _fineLoc3Dictionary = new Dictionary<string, MMEFineLocations3>();
+        /// <summary>
+        /// list of all known physical dimensions, populated when first loaded
+        /// </summary>
+        private Dictionary<string, MMEPhysicalDimensions> _physicalDimensionsDictionary = new Dictionary<string, MMEPhysicalDimensions>();
+        /// <summary>
+        /// list of all known positions, populated when first loaded
+        /// </summary>
+        private Dictionary<string, MMEPositions> _positionsDictionary = new Dictionary<string, MMEPositions>();
+        /// <summary>
+        /// list of all known possible channels, populated when first loaded
+        /// </summary>
+        private List<MMEPossibleChannels> _possibleChannels = new List<MMEPossibleChannels>();
+        /// <summary>
+        /// list of possible test objects, populated when first loaded
+        /// </summary>
+        private Dictionary<string, MMETestObjects> _testObjectsDictionary = new Dictionary<string, MMETestObjects>();
+        /// <summary>
+        /// list of all possible transducer locations, populated when first loaded
+        /// </summary>
+        private Dictionary<string, MMETransducerMainLocation> _transducerMainLoc = new Dictionary<string, MMETransducerMainLocation>();
+        #endregion
+
+        /// <summary>
+        /// connection string for the iso13499 database
+        /// you must also call refreshall to load data
+        /// </summary>
+        public string ConnectionStr { get; set; } = "";
+
+        /// <summary>
+        /// constructs an iso13499file db, you must still set the connection str
+        /// </summary>
+        public ISO13499FileDb()
+        {
+        }
+
+        public static bool Is646bitProcess { get; } = (IntPtr.Size == 8);
+
+        private static ISO13499FileDb _isoDb;
+        public static ISO13499FileDb IsoDb
+        {
+            get
+            {
+                var log = new System.Diagnostics.EventLog { Source = "DataPROInstaller" };
+                if (null == _isoDb)
+                {
+                    log.WriteEntry("_isoDb is null");
+                    _isoDb = new ISO13499FileDb();
+                    log.WriteEntry("Got a new ISO13499FileDb");
+
+                    _isoDb.RefreshAllData();
+                    log.WriteEntry("Back from RefreshAllData");
+                }
+                //log.WriteEntry("Returning from IsoDb get");
+                return _isoDb;
+            }
+        }
+
+        /// <summary>
+        /// scans all possible channels for unique types, returns the list of unique types
+        /// </summary>
+        private List<string> _uniquePossibleChannelTypes = null;
+        public string[] GetUniquePossibleChannelTypes()
+        {
+            RefreshIfNeeded();
+            if (null == _uniquePossibleChannelTypes)
+            {
+                _uniquePossibleChannelTypes = new List<string>();
+                var uniquetypes = (from pc in _possibleChannels where !pc.Expired orderby pc.Text_L1 select pc.Type).Distinct().ToArray();
+                if (null != uniquetypes && uniquetypes.Length > 0)
+                {
+                    _uniquePossibleChannelTypes.AddRange(uniquetypes);
+                    _uniquePossibleChannelTypes.Sort();
+                }
+            }
+            return _uniquePossibleChannelTypes.ToArray();
+        }
+        public string[] GetUniquePossibleChannelTypes(string typeToRemove)
+        {
+            return GetUniquePossibleChannelTypes().Where(uniquePossibleChannelType => !uniquePossibleChannelType.StartsWith(typeToRemove)).ToArray();
+        }
+        private void RefreshIfNeeded()
+        {
+            lock (RefreshLock)
+            {
+                if (!_bLoaded) { RefreshAllData(); }
+            }
+        }
+        /// <summary>
+        /// gets a list of all possible channels given a type
+        /// </summary>
+        /// <param name="type"></param>
+        /// <returns></returns>
+        public MMEPossibleChannels[] GetPossibleChannelsForType(string type)
+        {
+            RefreshIfNeeded();
+            //Don't include 2535, the Thoracic Compression Criterion channel which contains an expired main location (TCCR), but isn't itself marked as expired (FB 9891).
+            return (from pc in _possibleChannels.AsParallel() where pc.Type == type && pc.Id != 2535 && (pc.Direction != "R" || pc.Text_L1.ToLower().Contains("seat") || pc.Text_L1.ToLower().Contains("load")) && !pc.Expired && pc.Default_Filter_Class != "V" orderby pc.Text_L1 select pc).ToArray();
+        }
+
+        /// <summary>
+        /// gets the possible channels just from DataPRO exclusive (so excluding ISO13499 origined channels)
+        /// </summary>
+        /// <returns></returns>
+        public MMEPossibleChannels[] GetSQLPossibleChannels()
+        {
+            RefreshIfNeeded();
+            var list = (from pc in _possibleChannels.AsParallel() where pc.MMEChannelType == (int)MMEPossibleChannels.MMEChannelTypes.SQL select pc).ToArray();
+
+            if (null != list && list.Any())
+            {
+                return list.Select(li => new MMEPossibleChannels(li)).ToArray();
+            }
+            return new MMEPossibleChannels[0];
+        }
+        /// <summary>
+        /// gets the "type" field from all possible channels where the channel test object matchines the input string in to
+        /// </summary>
+        /// <param name="to"></param>
+        /// <returns></returns>
+        public string[] GetTestObjectTypeForTestObject(string to)
+        {
+            RefreshIfNeeded();
+            return (from pc in _possibleChannels.AsParallel() where pc.Test_Object == to orderby pc.Type select pc.Type).Distinct().ToArray();
+        }
+
+        /// <summary>
+        /// dictionary of possible channels keyed by id, there's a separate dictionary for iso13499 origined channels
+        /// and DataPRO origined channels
+        /// </summary>
+        private Dictionary<long, MMEPossibleChannels> _mmePossibleChannelsDict = null;
+        private Dictionary<long, MMEPossibleChannels> _mmePossibleChannelsDictOurs = null;
+        public MMEPossibleChannels GetPossibleChannel(long id, int channelType)
+        {
+            RefreshIfNeeded();
+            if (1 == channelType)
+            {
+                if (null == _mmePossibleChannelsDictOurs)
+                {
+                    _mmePossibleChannelsDictOurs = new Dictionary<long, MMEPossibleChannels>();
+                    foreach (var channel in _possibleChannels)
+                    {
+                        if (channel.MMEChannelType != channelType) { continue; }
+                        if (!_mmePossibleChannelsDictOurs.ContainsKey(channel.Id)) { _mmePossibleChannelsDictOurs.Add(channel.Id, channel); }
+                    }
+                }
+                return _mmePossibleChannelsDictOurs.ContainsKey(id) ? _mmePossibleChannelsDictOurs[id] : null;
+            }
+            if (null == _mmePossibleChannelsDict)
+            {
+                _mmePossibleChannelsDict = new Dictionary<long, MMEPossibleChannels>();
+                foreach (var channel in _possibleChannels)
+                {
+                    if (channel.MMEChannelType != channelType) { continue; }
+                    if (!_mmePossibleChannelsDict.ContainsKey(channel.Id)) { _mmePossibleChannelsDict.Add(channel.Id, channel); }
+                }
+            }
+            return _mmePossibleChannelsDict.ContainsKey(id) ? _mmePossibleChannelsDict[id] : null;
+        }
+
+        /// <summary>
+        /// gets all possible test objects from test object tables
+        /// </summary>
+        /// <param name="bIncludeExpired"></param>
+        /// <returns></returns>
+        public MMETestObjects[] GetTestObjects(bool bIncludeExpired)
+        {
+            RefreshIfNeeded();
+            return bIncludeExpired ? _testObjectsDictionary.Values.ToArray() : (from to in _testObjectsDictionary.Values.ToArray().AsParallel() where !to.Expired select to).ToArray();
+        }
+
+        /// <summary>
+        /// returns any test objects which match test object test object iso code.
+        /// returns null if not found
+        /// </summary>
+        /// <param name="iso"></param>
+        /// <returns></returns>
+        public MMETestObjects GetTestObjectByIso(string iso)
+        {
+            RefreshIfNeeded();
+            return _testObjectsDictionary.ContainsKey(iso) ? _testObjectsDictionary[iso] : null;
+        }
+        /// <summary>
+        /// returns a position if any that has a matching iso code position field
+        /// returns null if not found
+        /// </summary>
+        /// <param name="key">position code to look for</param>
+        /// <returns></returns>
+        public MMEPositions GetPositionByISO(string key)
+        {
+            RefreshIfNeeded();
+            return _positionsDictionary.ContainsKey(key) ? _positionsDictionary[key] : null;
+        }
+
+        /// <summary>
+        /// returns the first position with a guid which matches the requested guid
+        /// returns null if not found
+        /// </summary>
+        /// <param name="GUID">guid to look for</param>
+        /// <returns></returns>
+        public MMEPositions GetPosition(string GUID)
+        {
+            RefreshIfNeeded();
+            var positions = (from p in _positionsDictionary.Values.ToArray().AsParallel() where p.S_GUID == GUID select p);
+            if (null != positions && positions.Any()) { return positions.First(); }
+            return null;
+        }
+        /// <summary>
+        /// gets all possible filter classes
+        /// </summary>
+        /// <returns></returns>
+        public MMEFilterClasses[] GetFilterClasses()
+        {
+            RefreshIfNeeded();
+            return _filterClassesDictionary.Values.ToArray();
+        }
+        /// <summary>
+        /// returns filter class matching the iso code filter class field
+        /// </summary>
+        /// <param name="key"></param>
+        /// <returns></returns>
+        public MMEFilterClasses GetFilterClassByIso(string key)
+        {
+            RefreshIfNeeded();
+            return _filterClassesDictionary.ContainsKey(key) ? _filterClassesDictionary[key] : null;
+        }
+
+        /// <summary>
+        /// gets all possible directions
+        /// </summary>
+        /// <returns></returns>
+        public MMEDirections[] GetDirections()
+        {
+            RefreshIfNeeded();
+            return _directionsDictionary.Values.ToArray();
+        }
+        /// <summary>
+        /// returns a direction given the isocode direction field
+        /// </summary>
+        /// <param name="key"></param>
+        /// <returns></returns>
+        public MMEDirections GetDirectionByIso(string key)
+        {
+            RefreshIfNeeded();
+            return _directionsDictionary.ContainsKey(key) ? _directionsDictionary[key] : null;
+        }
+        /// <summary>
+        /// returns all possible fine location 1
+        /// </summary>
+        /// <returns></returns>
+        public MMEFineLocations1[] GetFineLocations1()
+        {
+            RefreshIfNeeded();
+            return _fineLoc1Dictionary.Values.ToArray();
+        }
+        /// <summary>
+        /// returns a fine location 1, given a matching iso fine location field
+        /// </summary>
+        /// <param name="key"></param>
+        /// <returns></returns>
+        public MMEFineLocations1 GetFineLocation1ByIso(string key)
+        {
+            RefreshIfNeeded();
+            return _fineLoc1Dictionary.ContainsKey(key) ? _fineLoc1Dictionary[key] : null;
+        }
+        /// <summary>
+        /// returns all possible fine location 2
+        /// </summary>
+        /// <returns></returns>
+        public MMEFineLocations2[] GetFineLocations2()
+        {
+            RefreshIfNeeded();
+            return _fineLoc2Dictionary.Values.ToArray();
+        }
+        /// <summary>
+        /// returns a fine location 2 based on fine location 2 iso code field
+        /// </summary>
+        /// <param name="key"></param>
+        /// <returns></returns>
+        public MMEFineLocations2 GetFineLocation2ByIso(string key)
+        {
+            RefreshIfNeeded();
+            return _fineLoc2Dictionary.ContainsKey(key) ? _fineLoc2Dictionary[key] : null;
+        }
+        /// <summary>
+        /// gets all possible fine locations 3
+        /// </summary>
+        /// <returns></returns>
+        public MMEFineLocations3[] GetFineLocations3()
+        {
+            RefreshIfNeeded();
+            return _fineLoc3Dictionary.Values.ToArray();
+        }
+        /// <summary>
+        /// gets fine location 3 based on fine location 3 isocode field
+        /// </summary>
+        /// <param name="key"></param>
+        /// <returns></returns>
+        public MMEFineLocations3 GetFineLocation3ByIso(string key)
+        {
+            RefreshIfNeeded();
+            if (_fineLoc3Dictionary.ContainsKey(key)) { return _fineLoc3Dictionary[key]; }
+            else { return null; }
+        }
+        /// <summary>
+        /// gets all possible physical dimensions
+        /// </summary>
+        /// <returns></returns>
+        public MMEPhysicalDimensions[] GetPhysicalDimensions()
+        {
+            RefreshIfNeeded();
+            return _physicalDimensionsDictionary.Values.ToArray();
+        }
+        /// <summary>
+        /// gets physical dimension by isocode physical dimension field
+        /// </summary>
+        /// <param name="key"></param>
+        /// <returns></returns>
+        public MMEPhysicalDimensions GetPhysicalDimensionByIso(string key)
+        {
+            RefreshIfNeeded();
+            return _physicalDimensionsDictionary.ContainsKey(key) ? _physicalDimensionsDictionary[key] : null;
+        }
+        public MMEPositions[] GetPositions()
+        {
+            RefreshIfNeeded();
+            return _positionsDictionary.Values.ToArray();
+        }
+        /// <summary>
+        /// gets all possible main locations
+        /// </summary>
+        /// <returns></returns>
+        public MMETransducerMainLocation[] GetMainLocations()
+        {
+            RefreshIfNeeded();
+            return _transducerMainLoc.Values.ToArray();
+        }
+
+        Dictionary<string, MMETransducerMainLocation> _expiredMainLocations = new Dictionary<string, MMETransducerMainLocation>();
+        /// <summary>
+        /// gets a main location given an isocode main location field
+        /// </summary>
+        /// <param name="key"></param>
+        /// <returns></returns>
+        public MMETransducerMainLocation GetMainLocationByIso(string key)
+        {
+            RefreshIfNeeded();
+            if (_transducerMainLoc.ContainsKey(key)) { return _transducerMainLoc[key]; }
+            if (_expiredMainLocations.ContainsKey(key)) { throw new Exception(/*ExpiredISOFieldException*/_expiredMainLocations[key].Remarks); }
+            return null;
+        }
+        private bool _bLoaded = false;
+        private static readonly object RefreshLock = new object();
+        /// <summary>
+        /// loads all data from iso13499 and datapro databases
+        /// </summary>
+        public void RefreshAllData()
+        {
+            var log = new System.Diagnostics.EventLog { Source = "DataPROInstaller" };
+            log.WriteEntry("In RefreshAllData");
+            lock (RefreshLock)
+            {
+                try
+                {
+                    _mmePossibleChannelsDict = new Dictionary<long, MMEPossibleChannels>();
+                    _mmePossibleChannelsDictOurs = new Dictionary<long, MMEPossibleChannels>();
+                    _uniquePossibleChannelTypes = null;
+                    _directionsDictionary.Clear();
+                    _figures.Clear();
+                    _filterClassesDictionary.Clear();
+                    _fineLoc1Dictionary.Clear();
+                    _fineLoc2Dictionary.Clear();
+                    _fineLoc3Dictionary.Clear();
+                    _physicalDimensionsDictionary.Clear();
+                    _positionsDictionary.Clear();
+                    _possibleChannels.Clear();
+                    _testObjectsDictionary.Clear();
+                    _transducerMainLoc.Clear();
+                    _expiredMainLocations.Clear();
+
+                    log.WriteEntry("Entering try");
+                    try
+                    {
+                        foreach (var dir in MMEDirections.GetDirections()) { if (!_directionsDictionary.ContainsKey(dir.Direction)) { _directionsDictionary.Add(dir.Direction, dir); } }
+
+                        _figures.AddRange(MMEFigures.GetFigures());
+
+                        foreach (var fc in MMEFilterClasses.GetFilterClasses()) { if (!_filterClassesDictionary.ContainsKey(fc.Filter_Class)) { _filterClassesDictionary.Add(fc.Filter_Class, fc); } }
+
+                        foreach (var loc in MMEFineLocations1.GetFineLocations1()) { if (!_fineLoc1Dictionary.ContainsKey(loc.Fine_Loc_1)) { _fineLoc1Dictionary.Add(loc.Fine_Loc_1, loc); } }
+
+                        foreach (var loc in MMEFineLocations2.GetFineLocations2()) { if (!_fineLoc2Dictionary.ContainsKey(loc.FINE_LOC_2)) { _fineLoc2Dictionary.Add(loc.FINE_LOC_2, loc); } }
+
+                        foreach (var loc in MMEFineLocations3.GetFineLocations3()) { if (!_fineLoc3Dictionary.ContainsKey(loc.FINE_LOC_3)) { _fineLoc3Dictionary.Add(loc.FINE_LOC_3, loc); } }
+
+                        foreach (var pd in MMEPhysicalDimensions.GetPhysicalDimensions()) { if (!_physicalDimensionsDictionary.ContainsKey(pd.Physical_Dimension)) { _physicalDimensionsDictionary.Add(pd.Physical_Dimension, pd); } }
+
+                        foreach (var pos in MMEPositions.GetPositions()) { if (!_positionsDictionary.ContainsKey(pos.Position)) { _positionsDictionary.Add(pos.Position, pos); } }
+
+                        _possibleChannels.AddRange(MMEPossibleChannels.GetPossibleChannels());
+
+                        log.WriteEntry("Getting TestObjects");
+                        foreach (var to in MMETestObjects.GetTestObjects())
+                        {
+                            log.WriteEntry("Checking " + to.ToString());
+                            if (!_testObjectsDictionary.ContainsKey(to.Test_Object))
+                            {
+                                log.WriteEntry("Adding " + to.ToString());
+                                _testObjectsDictionary.Add(to.Test_Object, to);
+                            }
+                        }
+                        log.WriteEntry("Done Getting TestObjects");
+                        foreach (var mainloc in MMETransducerMainLocation.GetTransducerMainLocations())
+                        {
+                            if (mainloc.Expired)
+                            {
+                                if (!_expiredMainLocations.ContainsKey(mainloc.Trans_Main_Loc)) { _expiredMainLocations.Add(mainloc.Trans_Main_Loc, mainloc); }
+                            }
+                            else
+                            {
+                                if (!_transducerMainLoc.ContainsKey(mainloc.Trans_Main_Loc)) { _transducerMainLoc.Add(mainloc.Trans_Main_Loc, mainloc); }
+                            }
+                        }
+                        foreach (var pc in _possibleChannels)
+                        {
+                            if (pc.MMEChannelType == (int)MMEPossibleChannels.MMEChannelTypes.SQL) { _mmePossibleChannelsDictOurs[pc.Id] = pc; }
+                            else { _mmePossibleChannelsDict[pc.Id] = pc; }
+                        }
+                    }
+                    catch (Exception ex)
+                    {
+                        log.WriteEntry("Exception before setting _bLoaded to True: " + ex.Message);
+                        //DTS.Utilities.Logging.APILogger.Log("failure to load ISO tables", ex);
+                    }
+                    _bLoaded = true;
+                }
+                catch (Exception ex)
+                {
+                    log.WriteEntry("Exception before setting _bLoaded to False: " + ex.Message);
+                    _bLoaded = false;
+                    //DTS.Utilities.Logging.APILogger.Log(ex);
+                }
+            }
+        }
+    }
+}

DataPRO/Modules/PreviousDBVersions/Version57/DatabaseExport/ISO/IsoCode.cs

@@ -0,0 +1,182 @@
+using System.Text;
+
+namespace DatabaseExport.ISO
+{
+    public class IsoCode
+    {
+        private char[] _isoCodeFull = { '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0' };
+        private char _TestObject
+        {
+            get => _isoCodeFull[0];
+            set => _isoCodeFull[0] = value;
+        }
+        public string TestObject
+        {
+            get => new string(new[] { _TestObject });
+            set
+            {
+                if (string.IsNullOrEmpty(value)) { _TestObject = '?'; }
+                else { _TestObject = value[0]; }
+            }
+        }
+
+        private char _Position
+        {
+            get => _isoCodeFull[1];
+            set => _isoCodeFull[1] = value;
+        }
+        public string Position
+        {
+            get => new string(new[] { _Position });
+            set => _Position = string.IsNullOrEmpty(value) ? '?' : value[0];
+        }
+
+        private char[] _MainLocation
+        {
+            get => new[] { _isoCodeFull[2], _isoCodeFull[3], _isoCodeFull[4], _isoCodeFull[5] };
+            set
+            {
+                for (var i = 0; i < 4; i++)
+                {
+                    if (value.Length <= i) { _isoCodeFull[i + 2] = '0'; }
+                    else { _isoCodeFull[i + 2] = value[i]; }
+                }
+            }
+        }
+        private char[] _FineLocation1
+        {
+            get => new[] { _isoCodeFull[6], _isoCodeFull[7] };
+            set
+            {
+                for (var i = 0; i < 2; i++)
+                {
+                    if (value.Length < i) { _isoCodeFull[i + 6] = '0'; }
+                    else { _isoCodeFull[i + 6] = value[i]; }
+                }
+            }
+        }
+        private char[] _FineLocation2
+        {
+            get => new[] { _isoCodeFull[8], _isoCodeFull[9] };
+            set
+            {
+                for (var i = 0; i < 2; i++)
+                {
+                    if (value.Length < i) { _isoCodeFull[i + 8] = '0'; }
+                    else { _isoCodeFull[i + 8] = value[i]; }
+                }
+            }
+        }
+        private char[] _FineLocation3
+        {
+            get => new[] { _isoCodeFull[10], _isoCodeFull[11] };
+            set
+            {
+                for (var i = 0; i < 2; i++)
+                {
+                    if (value.Length < i) { _isoCodeFull[i + 10] = '0'; }
+                    else { _isoCodeFull[i + 10] = value[i]; }
+                }
+            }
+        }
+        private char[] _PhysicalDimension
+        {
+            get => new[] { _isoCodeFull[12], _isoCodeFull[13] };
+            set
+            {
+                for (var i = 0; i < 2; i++)
+                {
+                    if (value.Length < i) { _isoCodeFull[i + 12] = '0'; }
+                    else { _isoCodeFull[i + 12] = value[i]; }
+                }
+            }
+        }
+        private char _Direction
+        {
+            get => _isoCodeFull[14];
+            set => _isoCodeFull[14] = value;
+        }
+        private char _FilterClass
+        {
+            get => _isoCodeFull[15];
+            set => _isoCodeFull[15] = value;
+        }
+        public string FilterClass
+        {
+            get => new string(new[] { _FilterClass });
+            set => _FilterClass = string.IsNullOrEmpty(value) ? '?' : value[0];
+        }
+
+        public IsoCode(string isoCode)
+        {
+            if (null == isoCode) { isoCode = ""; }
+            if (isoCode.Length > 16) { isoCode = isoCode.Substring(0, 16); }
+            if (isoCode.Length < 16)
+            {
+                isoCode = isoCode.PadRight(16, '?');
+            }
+            for (var i = 0; i < 16; i++) { _isoCodeFull[i] = isoCode[i]; }
+        }
+        public string StringRepresentation
+        {
+            get
+            {
+                var sb = new StringBuilder();
+                foreach (var c in _isoCodeFull) { sb.Append(c); }
+                return sb.ToString();
+            }
+            set
+            {
+                for (var i = 0; i < 16; i++)
+                {
+                    if (i >= value.Length) { _isoCodeFull[i] = '0'; }
+                    else { _isoCodeFull[i] = value[i]; }
+                }
+            }
+        }
+        public static string GetString(MMEPossibleChannels channel, MMETestObjects container, MMEPositions position, MMEFilterClasses fc)
+        {
+            var iso = new IsoCode("");
+            iso._Direction = channel.Direction[0];
+            iso._FilterClass = channel.Default_Filter_Class[0];
+            iso._FineLocation1 = channel.Fine_Loc_1.ToCharArray();
+            iso._FineLocation2 = channel.Fine_Loc_2.ToCharArray();
+            iso._FineLocation3 = channel.Fine_Loc_3.ToCharArray();
+            iso._MainLocation = channel.Trans_Main_Loc.ToCharArray();
+            iso._PhysicalDimension = channel.Physical_Dimension.ToCharArray();
+            iso._Position = null == position ? '?' : position.Position[0];
+            iso._TestObject = null == container ? '?' : container.Test_Object[0];
+            iso._FilterClass = null == fc ? '?' : fc.Filter_Class[0];
+            return iso.StringRepresentation;
+        }
+        /// <summary>
+        /// returns the isocode for a channel
+        /// considers whether it should mask the test time fields in the isocode 
+        /// test time fields are test object, and filterclass
+        /// returns isocode
+        /// </summary>
+        /// <param name="channel"></param>
+        /// <param name="careAboutTestTimeFields"></param>
+        /// <returns></returns>
+        public static string GetString(MMEPossibleChannels channel, bool careAboutTestTimeFields)
+        {
+            var iso = new IsoCode("")
+            {
+                _Direction = channel.Direction[0],
+                _FineLocation1 = channel.Fine_Loc_1.ToCharArray(),
+                _FineLocation2 = channel.Fine_Loc_2.ToCharArray(),
+                _FineLocation3 = channel.Fine_Loc_3.ToCharArray(),
+                _MainLocation = channel.Trans_Main_Loc.ToCharArray(),
+                _PhysicalDimension = channel.Physical_Dimension.ToCharArray(),
+                _Position = channel.Position[0],
+                _TestObject = careAboutTestTimeFields ? channel.Test_Object[0] : '?',
+                _FilterClass = careAboutTestTimeFields ? channel.Default_Filter_Class[0] : '?'
+            };
+            return iso.StringRepresentation;
+        }
+        public static string GetString(string testObject, string position, string main, string floc1, string floc2, string floc3, string physdim, string dir, string fc)
+        {
+            return string.Format("{0}{1}{2}{3}{4}{5}{6}{7}{8}", testObject, position, main, floc1, floc2, floc3, physdim, dir, fc);
+        }
+    }
+}

DataPRO/Modules/PreviousDBVersions/Version57/DatabaseExport/ISO/LabratoryDetails.cs

@@ -0,0 +1,245 @@
+using System;
+using System.Collections.Generic;
+
+namespace DatabaseExport.ISO
+{
+    [Serializable()]
+    public class LabratoryDetails //: ISerializableFile
+    {
+        private string _labratoryName = string.Empty;
+
+        public string LabratoryName
+        {
+            get => _labratoryName;
+            set => _labratoryName = value;
+        }
+
+        private string _labratoryContactName = string.Empty;
+
+        public string LabratoryContactName
+        {
+            get => _labratoryContactName;
+            set => _labratoryContactName = value;
+        }
+
+        private string _labratoryContactPhone = "NOVALUE";
+
+        public string LabratoryContactPhone
+        {
+            get => _labratoryContactPhone;
+            set
+            {
+                if (value != string.Empty)
+                {
+                    _labratoryContactPhone = value;
+                }
+            }
+        }
+
+        private string _labratoryContactFax = "NOVALUE";
+
+        public string LabratoryContactFax
+        {
+            get => _labratoryContactFax;
+            set
+            {
+                if (value != string.Empty)
+                {
+                    _labratoryContactFax = value;
+                }
+            }
+        }
+
+        private string _labratoryContactEmail = "NOVALUE";
+
+        public string LabratoryContactEmail
+        {
+            get => _labratoryContactEmail;
+            set
+            {
+                if (value != string.Empty)
+                {
+                    _labratoryContactEmail = value;
+                }
+            }
+        }
+
+        private string _labratoryTestRefNumber = string.Empty;
+
+        public string LabratoryTestRefNumber
+        {
+            get => _labratoryTestRefNumber;
+            set => _labratoryTestRefNumber = value;
+        }
+
+        private string _labratoryProjectRefNumber = string.Empty;
+
+        public string LabratoryProjectRefNumber
+        {
+            get => _labratoryProjectRefNumber;
+            set => _labratoryProjectRefNumber = value;
+        }
+
+        private string _name = "";
+
+        public string Name
+        {
+            get => _name;
+            set => _name = value;
+        }
+
+        public static LabratoryDetails[] GetAllLabratoryDetails()
+        {
+            var labs = new List<LabratoryDetails>();
+            try
+            {
+                using (var cmd = DbOperations.GetCommand())
+                {
+                    cmd.CommandText = "SELECT Name" +
+                                      ",LabratoryName" +
+                                      ",LabratoryContactName" +
+                                      ",LabratoryContactPhone" +
+                                      ",LabratoryContactFax" +
+                                      ",LabratoryContactEmail" +
+                                      ",LabratoryTestRefNumber" +
+                                      ",LabratoryProjectRefNumber" +
+                                      ",LastModified" +
+                                      ",LastModifiedBy" +
+                                      ",LocalOnly" +
+                                      ",Version" +
+                                      ",DbTimeStamp" +
+                                      " from tblLabratoryDetails";
+
+                    using (var ds = DbOperations.Connection.QueryDataSet(cmd))
+                    {
+                        if (ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0)
+                        {
+                            foreach (System.Data.DataRow dr in ds.Tables[0].Rows)
+                            {
+                                try
+                                {
+                                    labs.Add(new LabratoryDetails(dr));
+                                }
+                                catch (Exception)
+                                {
+                                    //DTS.Utilities.Logging.APILogger.Log("Failed to read laboratory details", ex2);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            catch (Exception)
+            {
+                //DTS.Utilities.Logging.APILogger.Log("Failed to retreive laboratory details", ex);
+            }
+            return labs.ToArray();
+        }
+
+        private bool _localOnly = false;
+
+        public bool LocalOnly
+        {
+            get => _localOnly;
+            set => _localOnly = value;
+        }
+
+        private DateTime _lastModified;
+
+        public DateTime LastModified
+        {
+            get => _lastModified;
+            set => _lastModified = value;
+        }
+
+        private string _lastModifiedBy;
+
+        public string LastModifiedBy
+        {
+            get => _lastModifiedBy;
+            set => _lastModifiedBy = value;
+        }
+
+        public LabratoryDetails()
+        {
+        }
+
+        public LabratoryDetails(System.Data.DataRow dr)
+        {
+            _name = (string)dr["Name"];
+            LabratoryName = (string)dr["LabratoryName"];
+            LabratoryContactName = (string)dr["LabratoryContactName"];
+            LabratoryContactPhone = (string)dr["LabratoryContactPhone"];
+            LabratoryContactFax = (string)dr["LabratoryContactFax"];
+            LabratoryContactEmail = (string)dr["LabratoryContactEmail"];
+            LabratoryTestRefNumber = (string)dr["LabratoryTestRefNumber"];
+            LabratoryProjectRefNumber = (string)dr["LabratoryProjectRefNumber"];
+            _lastModified = Convert.ToDateTime(dr["LastModified"]);
+            _lastModifiedBy = (string)dr["LastModifiedBy"];
+            _localOnly = Convert.ToBoolean(dr["LocalOnly"]);
+            _version = Convert.ToInt32(dr["Version"]);
+        }
+
+        public LabratoryDetails(LabratoryDetails copy)
+        {
+            _name = copy.Name;
+            LabratoryName = copy.LabratoryName;
+            LabratoryContactName = copy.LabratoryContactName;
+            LabratoryContactPhone = copy.LabratoryContactPhone;
+            LabratoryContactFax = copy.LabratoryContactFax;
+            LabratoryContactEmail = copy.LabratoryContactEmail;
+            LabratoryTestRefNumber = copy.LabratoryTestRefNumber;
+            LabratoryProjectRefNumber = copy.LabratoryProjectRefNumber;
+            _lastModified = copy.LastModified;
+            _lastModifiedBy = copy.LastModifiedBy;
+            _localOnly = copy.LocalOnly;
+            _version = copy.Version;
+        }
+
+        private enum fields
+        {
+            Name,
+            LaboratoryName,
+            LaboratoryContactName,
+            LaboratoryContactPhone,
+            LaboratoryContactFax,
+            LaboratoryContactEmail,
+            LaboratoryTestRefNumber,
+            LaboratoryProjectRefNumber,
+            LastModified,
+            LastModifiedBy,
+            LocalOnly,
+            Version
+        };
+
+        public Dictionary<string, string> GetValues()
+        {
+            var elementNameValuePairs = new Dictionary<string, string>();
+
+            elementNameValuePairs[fields.Name.ToString()] = Name;
+            elementNameValuePairs[fields.LaboratoryName.ToString()] = LabratoryName;
+            elementNameValuePairs[fields.LaboratoryContactName.ToString()] = LabratoryContactName;
+            elementNameValuePairs[fields.LaboratoryContactPhone.ToString()] = LabratoryContactPhone;
+            elementNameValuePairs[fields.LaboratoryContactFax.ToString()] = LabratoryContactFax;
+            elementNameValuePairs[fields.LaboratoryContactEmail.ToString()] = LabratoryContactEmail;
+            elementNameValuePairs[fields.LaboratoryTestRefNumber.ToString()] = LabratoryTestRefNumber;
+            elementNameValuePairs[fields.LaboratoryProjectRefNumber.ToString()] = LabratoryProjectRefNumber;
+            elementNameValuePairs[fields.LastModified.ToString()] =
+                LastModified.ToString(System.Globalization.CultureInfo.InvariantCulture);
+            elementNameValuePairs[fields.LastModifiedBy.ToString()] = LastModifiedBy;
+            elementNameValuePairs[fields.LocalOnly.ToString()] = LocalOnly.ToString();
+            elementNameValuePairs[fields.Version.ToString()] =
+                Version.ToString(System.Globalization.CultureInfo.InvariantCulture);
+
+            return elementNameValuePairs;
+        }
+
+        private int _version = 1;
+
+        public int Version
+        {
+            get => _version;
+            set => _version = value;
+        }
+    }
+}

DataPRO/Modules/PreviousDBVersions/Version57/DatabaseExport/ISO/LevelTriggerChannel.cs

@@ -0,0 +1,94 @@
+using System;
+using System.Linq;
+
+namespace DatabaseExport
+{
+    /// <summary>
+    /// this is a class for storing directly in and out of the db
+    /// it's simplified and doesn't know about sensors and is just a wrapper for a row in the db
+    /// </summary>
+    public class LevelTriggerChannel
+    {
+        public string TestSetupName { get; set; } = "";
+
+        public string GroupSerialNumber { get; set; } = "";
+
+        public string TestObjectChannelId { get; set; } = "";
+
+        public string HardwareChannelId { get; set; } = "";
+
+        public string SensorSerialNumber { get; set; } = "";
+
+        public bool GreaterThanEnabled { get; set; } = true;
+
+        public double GreaterThanThresholdEU { get; set; } = 0D;
+
+        public bool LessThanEnabled { get; set; } = false;
+
+        public bool TriggerBetweenBounds { get; set; } = false;
+
+        public bool TriggerOutsideBounds { get; set; } = false;
+
+        public double InsideUpperLevelEU { get; set; } = 0D;
+
+        public double InsideLowerLevelEU { get; set; } = 0D;
+
+        public double OutsideUpperLevelEU { get; set; } = 0D;
+
+        public double OutsideLowerLevelEU { get; set; } = 0D;
+
+        public double LessThanThresholdEU { get; set; } = 0D;
+
+        public LevelTriggerChannel(LevelTriggerChannel copy)
+        {
+            TestSetupName = copy.TestSetupName;
+            GroupSerialNumber = copy.GroupSerialNumber;
+            TestObjectChannelId = copy.TestObjectChannelId;
+            HardwareChannelId = copy.HardwareChannelId;
+            SensorSerialNumber = copy.SensorSerialNumber;
+            GreaterThanEnabled = copy.GreaterThanEnabled;
+            GreaterThanThresholdEU = copy.GreaterThanThresholdEU;
+            LessThanEnabled = copy.LessThanEnabled;
+            LessThanThresholdEU = copy.LessThanThresholdEU;
+            InsideUpperLevelEU = copy.InsideUpperLevelEU;
+            InsideLowerLevelEU = copy.InsideLowerLevelEU;
+            OutsideUpperLevelEU = copy.OutsideUpperLevelEU;
+            OutsideLowerLevelEU = copy.OutsideLowerLevelEU;
+            TriggerBetweenBounds = copy.TriggerBetweenBounds;
+            TriggerOutsideBounds = copy.TriggerOutsideBounds;
+        }
+        public LevelTriggerChannel(System.Data.DataRow dr)
+        {
+            var fields = Enum.GetValues(typeof(DbOperations.LevelTriggers.Fields))
+                .Cast<DbOperations.LevelTriggers.Fields>().ToArray();
+            foreach (var field in fields)
+            {
+                try
+                {
+                    var o = dr[field.ToString()];
+                    if (DBNull.Value.Equals(o)) { continue; }
+                    switch (field)
+                    {
+                        case DbOperations.LevelTriggers.Fields.GreaterThanEnabled: GreaterThanEnabled = Convert.ToBoolean(o); break;
+                        case DbOperations.LevelTriggers.Fields.GreaterThanEU: GreaterThanThresholdEU = Convert.ToDouble(o); break;
+                        case DbOperations.LevelTriggers.Fields.GroupSerialNumber: GroupSerialNumber = Convert.ToString(o); break;
+                        case DbOperations.LevelTriggers.Fields.HardwareChannelId: HardwareChannelId = Convert.ToString(o); break;
+                        case DbOperations.LevelTriggers.Fields.LessThanEnabled: LessThanEnabled = Convert.ToBoolean(o); break;
+                        case DbOperations.LevelTriggers.Fields.LessThanEU: LessThanThresholdEU = Convert.ToDouble(o); break;
+                        case DbOperations.LevelTriggers.Fields.SensorSerialNumber: SensorSerialNumber = Convert.ToString(o); break;
+                        case DbOperations.LevelTriggers.Fields.TestObjectChannelId: TestObjectChannelId = Convert.ToString(o); break;
+                        case DbOperations.LevelTriggers.Fields.TestSetupName: TestSetupName = Convert.ToString(o); break;
+                        case DbOperations.LevelTriggers.Fields.TriggerInside: TriggerBetweenBounds = Convert.ToBoolean(o); break;
+                        case DbOperations.LevelTriggers.Fields.TriggerOutside: TriggerOutsideBounds = Convert.ToBoolean(o); break;
+                        case DbOperations.LevelTriggers.Fields.OutsideUpperEU: OutsideUpperLevelEU = Convert.ToDouble(o); break;
+                        case DbOperations.LevelTriggers.Fields.OutsideLowerEU: OutsideLowerLevelEU = Convert.ToDouble(o); break;
+                        case DbOperations.LevelTriggers.Fields.InsideUpperEU: InsideUpperLevelEU = Convert.ToDouble(o); break;
+                        case DbOperations.LevelTriggers.Fields.InsideLowerEU: InsideLowerLevelEU = Convert.ToDouble(o); break;
+                        default: throw new NotSupportedException("unknown level trigger field: " + field.ToString());
+                    }
+                }
+                catch (Exception) { /*DTS.Utilities.Logging.APILogger.Log(ex);*/ }
+            }
+        }
+    }
+}

DataPRO/Modules/PreviousDBVersions/Version57/DatabaseExport/ISO/MMEDirections.cs

@@ -0,0 +1,205 @@
+using System;
+using System.Collections.Generic;
+using System.Data;
+using System.Linq;
+using System.Data.OleDb;
+
+namespace DatabaseExport
+{
+    public class MMEDirections : AbstractOLEDbWrapper
+    {
+        public string S_GUID { get; }
+
+        public string Direction { get; }
+
+        public string Text_L1 { get; }
+
+        public string Text_L2 { get; }
+
+        public DateTime Date { get; }
+
+        public long Version { get; }
+
+        public bool Expired { get; }
+
+        public string Remarks { get; }
+
+        public DateTime Last_Change { get; }
+
+        public string Last_Change_Text { get; }
+
+        public string History { get; }
+
+        public string SortKey { get; }
+
+        public MMEPossibleChannels.MMEChannelTypes RecordType { get; }
+
+        public MMEDirections(string sGuid, string direction, string textL1, string textL2, DateTime date, long version,
+            bool bExpired, string remarks, DateTime lastChange, string lastChangeText, string history, string sortkey,
+            MMEPossibleChannels.MMEChannelTypes type)
+        {
+            RecordType = type;
+            S_GUID = sGuid;
+            Direction = direction;
+            Text_L1 = textL1;
+            Text_L2 = textL2;
+            Date = date;
+            Version = version;
+            Expired = bExpired;
+            Remarks = remarks;
+            Last_Change = lastChange;
+            Last_Change_Text = lastChangeText;
+            History = history;
+            SortKey = sortkey;
+        }
+
+        public static MMEDirections[] GetDirections()
+        {
+            var directions = new List<MMEDirections>();
+            try
+            {
+                using (var cmd = DbOperations.GetISOCommand())
+                {
+                    cmd.CommandText = "SELECT * FROM MMEDirections";
+                    cmd.CommandType = CommandType.Text;
+                    try
+                    {
+                        using (var ISOReader = cmd.ExecuteReader())
+                        {
+                            while (ISOReader.Read())
+                            {
+                                try
+                                {
+                                    var version = Convert.ToInt32(ISOReader[DbOperations.MMETables.MMEDirectionsFields.VERSION.ToString()]);
+                                    var text2 = Convert.ToString(ISOReader[DbOperations.MMETables.MMEDirectionsFields.TEXT_L2.ToString()]);
+                                    var text1 = Convert.ToString(ISOReader[DbOperations.MMETables.MMEDirectionsFields.TEXT_L1.ToString()]);
+                                    var sortKey = Convert.ToString(ISOReader[DbOperations.MMETables.MMEDirectionsFields.SORTKEY.ToString()]);
+                                    var sGuid = Convert.ToString(ISOReader[DbOperations.MMETables.MMEDirectionsFields.s_GUID.ToString()]);
+                                    var remarks = Convert.ToString(ISOReader[DbOperations.MMETables.MMEDirectionsFields.REMARKS.ToString()]);
+                                    var lastChangeText = Convert.ToString(ISOReader[DbOperations.MMETables.MMEDirectionsFields.LAST_CHANGE_TEXT.ToString()]);
+                                    var lastChange = GetDate(ISOReader, DbOperations.MMETables.MMEDirectionsFields.LAST_CHANGE.ToString());
+                                    var history = Convert.ToString(ISOReader[DbOperations.MMETables.MMEDirectionsFields.HISTORY.ToString()]);
+                                    var expired = Convert.ToBoolean(ISOReader[DbOperations.MMETables.MMEDirectionsFields.EXPIRED.ToString()]);
+                                    var direction = Convert.ToString(ISOReader[DbOperations.MMETables.MMEDirectionsFields.DIRECTION.ToString()]);
+                                    var date = Convert.ToDateTime(ISOReader[DbOperations.MMETables.MMEDirectionsFields.DATE.ToString()]);
+                                    var mmedirection = new MMEDirections(sGuid, direction, text1, text2, date, Convert.ToInt64(version), expired, remarks, lastChange,
+                                        lastChangeText, history, sortKey, MMEPossibleChannels.MMEChannelTypes.ISO13499_106);
+                                    directions.Add(mmedirection);
+                                }
+                                catch (Exception )
+                                {
+                                    //ignore
+                                }
+                            }
+
+                            ISOReader.Close();
+                        }
+                    }
+                    finally
+                    {
+                        cmd.Connection.Dispose();
+                    }
+                }
+                try
+                {
+                    using (var cmd = DbOperations.GetCommand())
+                    {
+                        try
+                        {
+                            cmd.CommandText = string.Format("SELECT * from {0}", DbOperations.MMETables.MMEDirectionsTable);
+                            using (var ds = DbOperations.Connection.QueryDataSet(cmd))
+                            {
+                                if (ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0)
+                                {
+                                    var fields = Enum.GetValues(typeof(
+                                        DbOperations.MMETables.MMEDirectionsFields)).Cast<DbOperations.MMETables.MMEDirectionsFields>().ToArray();
+                                    foreach (System.Data.DataRow dr in ds.Tables[0].Rows)
+                                    {
+
+                                        var date = DateTime.Now;
+                                        var direction = "?";
+                                        var expired = false;
+                                        var history = "";
+                                        var lastChange = DateTime.Now;
+                                        var lastChangeText = "";
+                                        var remarks = "";
+                                        var sGuid = "";
+                                        var sortKey = "";
+                                        var text1 = "";
+                                        var text2 = "";
+                                        var version = 0;
+                                        foreach (var field in fields)
+                                        {
+                                            try
+                                            {
+                                                if (DBNull.Value.Equals(dr[field.ToString()])) { continue; }
+                                                switch (field)
+                                                {
+                                                    case DbOperations.MMETables.MMEDirectionsFields.VERSION:
+                                                        version = Convert.ToInt32(dr[field.ToString()]);
+                                                        break;
+                                                    case DbOperations.MMETables.MMEDirectionsFields.TEXT_L2:
+                                                        text2 = Convert.ToString(dr[field.ToString()]);
+                                                        break;
+                                                    case DbOperations.MMETables.MMEDirectionsFields.TEXT_L1:
+                                                        text1 = Convert.ToString(dr[field.ToString()]);
+                                                        break;
+                                                    case DbOperations.MMETables.MMEDirectionsFields.SORTKEY:
+                                                        sortKey = Convert.ToString(dr[field.ToString()]);
+                                                        break;
+                                                    case DbOperations.MMETables.MMEDirectionsFields.s_GUID:
+                                                        sGuid = Convert.ToString(dr[field.ToString()]);
+                                                        break;
+                                                    case DbOperations.MMETables.MMEDirectionsFields.REMARKS:
+                                                        remarks = Convert.ToString(dr[field.ToString()]);
+                                                        break;
+                                                    case DbOperations.MMETables.MMEDirectionsFields.LAST_CHANGE_TEXT:
+                                                        lastChangeText = Convert.ToString(dr[field.ToString()]);
+                                                        break;
+                                                    case DbOperations.MMETables.MMEDirectionsFields.LAST_CHANGE:
+                                                        lastChange = Convert.ToDateTime(dr[field.ToString()]);
+                                                        break;
+                                                    case DbOperations.MMETables.MMEDirectionsFields.HISTORY:
+                                                        history = Convert.ToString(dr[field.ToString()]);
+                                                        break;
+                                                    case DbOperations.MMETables.MMEDirectionsFields.EXPIRED:
+                                                        expired = Convert.ToBoolean(dr[field.ToString()]);
+                                                        break;
+                                                    case DbOperations.MMETables.MMEDirectionsFields.DIRECTION:
+                                                        direction = Convert.ToString(dr[field.ToString()]);
+                                                        break;
+                                                    case DbOperations.MMETables.MMEDirectionsFields.DATE:
+                                                        date = Convert.ToDateTime(dr[field.ToString()]);
+                                                        break;
+                                                }
+                                            }
+                                            catch (Exception) 
+                                            {
+                                                //ignore
+                                            }
+                                        }
+                                        directions.Add(new MMEDirections(sGuid.ToString(), direction, text1, text2, date, Convert.ToInt64(version),
+                                            expired, remarks, lastChange, lastChangeText, history, sortKey, MMEPossibleChannels.MMEChannelTypes.SQL));
+                                    }
+                                }
+                            }
+                        }
+                        finally
+                        {
+                            cmd.Connection.Dispose();
+                        }
+                    }
+                }
+                catch (Exception) 
+                {
+                    //ignore
+                }
+            }
+            catch (Exception)
+            {
+                //ignore
+            }
+            return directions.ToArray();
+        }
+    }
+}

DataPRO/Modules/PreviousDBVersions/Version57/DatabaseExport/ISO/MMEFigures.cs

@@ -0,0 +1,131 @@
+using System;
+using System.Collections.Generic;
+using System.Data;
+using System.Data.OleDb;
+
+namespace DatabaseExport
+{
+    public class MMEFigures : AbstractOLEDbWrapper
+    {
+        public long ID { get; }
+
+        public string TxtShortName { get; }
+
+        public string TxtDescription { get; }
+
+        public string TxtRemarks { get; }
+
+        public DateTime DatRevision { get; }
+
+        public long IntAuthor { get; }
+
+        public ushort IntPage { get; }
+
+        public ushort IntPages { get; }
+
+        public string TxtImageFile { get; }
+
+        public long IntVersion { get; }
+
+        public bool BolExpired { get; }
+
+        public string TxtSortKey { get; }
+
+        public bool BitStdPath { get; }
+
+        public long IntIDStdPath { get; }
+
+        public string TxtPath { get; }
+
+        public DateTime Last_Change { get; }
+
+        public string Last_Change_Text { get; }
+
+        public string History { get; }
+
+        public MMEFigures(long id, string txtShortName, string txtDescription, string txtRemarks, DateTime datRevision, long intAuthor,
+            ushort intPage, ushort intPages, string txtImageFile, long version, bool bExpired, string txtSortKey,
+            bool bitStdPath, long intIDStdPath, string txtPath, DateTime lastChange, string lastChangeText, string history)
+        {
+            ID = id;
+            TxtShortName = txtShortName;
+            TxtDescription = txtDescription;
+            TxtRemarks = txtRemarks;
+            DatRevision = datRevision;
+            IntAuthor = intAuthor;
+            IntPage = intPage;
+            IntPages = intPages;
+            TxtImageFile = txtImageFile;
+            IntVersion = version;
+            BolExpired = bExpired;
+            TxtSortKey = txtSortKey;
+            BitStdPath = bitStdPath;
+            IntIDStdPath = intIDStdPath;
+            TxtPath = txtPath;
+            Last_Change = lastChange;
+            Last_Change_Text = lastChangeText;
+            History = history;
+
+        }
+        public static MMEFigures[] GetFigures()
+        {
+            var figures = new List<MMEFigures>();
+            using (var cmd = DbOperations.GetISOCommand())
+            {
+                cmd.CommandText = "SELECT * FROM MMEFIGURES";
+                cmd.CommandType = CommandType.Text;
+                try
+                {
+                    using (var ISOReader = cmd.ExecuteReader())
+                    {
+                        while (ISOReader.Read())
+                        {
+                            try
+                            {
+                                var id = Convert.ToInt64(ISOReader["ID"]);
+                                var txtShortName = ISOReader["txtShortName"].ToString();
+                                var txtDescription = ISOReader["txtDescription"].ToString();
+                                var txtRemarks = ISOReader["txtRemarks"].ToString();
+                                var datRevision = DateTime.MinValue;
+                                if (!DBNull.Value.Equals(ISOReader["datRevision"]))
+                                {
+                                    datRevision = (DateTime)ISOReader["datRevision"];
+                                }
+                                var intAuthor = Convert.ToInt64(ISOReader["intAuthor"]);
+                                var intPage = Convert.ToUInt16(ISOReader["intPage"]);
+                                var intPages = Convert.ToUInt16(ISOReader["intPages"]);
+                                var txtImageFile = ISOReader["txtImageFile"].ToString();
+                                var version = Convert.ToInt64(ISOReader["intVersion"]);
+                                var bExpired = (bool)ISOReader["bolExpired"];
+                                var txtSortKey = ISOReader["txtSortKey"].ToString();
+                                var bitStdPath = (bool)ISOReader["bitStdPath"];
+                                var intIDStdPath = Convert.ToInt64(ISOReader["IntIDStdPath"]);
+                                var txtPath = ISOReader["txtPath"].ToString();
+                                var lastChange = DateTime.MinValue;
+                                if (!DBNull.Value.Equals(ISOReader["LAST_CHANGE"]))
+                                {
+                                    datRevision = (DateTime)ISOReader["LAST_CHANGE"];
+                                }
+                                var lastChangeText = ISOReader["LAST_CHANGE_TEXT"].ToString();
+                                var history = ISOReader["HISTORY"].ToString();
+                                figures.Add(new MMEFigures(id, txtShortName, txtDescription, txtRemarks, datRevision, intAuthor, intPage,
+                                    intPages, txtImageFile, version, bExpired, txtSortKey, bitStdPath, intIDStdPath, txtPath, lastChange,
+                                    lastChangeText, history));
+                            }
+                            catch (Exception)
+                            {
+                                //ignore
+                            }
+                        }
+                        ISOReader.Close();
+                    }
+                }
+                finally
+                {
+                    cmd.Connection.Dispose();
+                }
+            }
+            return figures.ToArray();
+        }
+    }
+}

DataPRO/Modules/PreviousDBVersions/Version57/DatabaseExport/ISO/MMEFilterClasses.cs

@@ -0,0 +1,217 @@
+using System;
+using System.Collections.Generic;
+using System.Data;
+using System.Linq;
+using System.Data.OleDb;
+
+namespace DatabaseExport
+{
+    public class MMEFilterClasses : AbstractOLEDbWrapper
+    {
+        public string S_GUID { get; }
+
+        public string Filter_Class { get; }
+
+        public string Text_L1 { get; }
+
+        public string Text_L2 { get; }
+
+        public long Version { get; }
+
+        public DateTime Date { get; }
+
+        public string Remarks { get; }
+
+        public bool Expired { get; }
+
+        public string SortKey { get; }
+
+        public DateTime Last_Change { get; }
+
+        public string Last_Change_Text { get; }
+
+        public string History { get; }
+
+        public MMEPossibleChannels.MMEChannelTypes RecordType { get; } = MMEPossibleChannels.MMEChannelTypes.ISO13499_106;
+
+        public MMEFilterClasses(string textL1)
+        {
+            Filter_Class = textL1;
+            Text_L1 = textL1;
+        }
+
+        public MMEFilterClasses(string sGuid, string filterClass, string textL1, string textL2, long version,
+            DateTime date, string remarks, bool bExpired, string sortKey, DateTime lastChange, string lastChangeText, string history,
+            MMEPossibleChannels.MMEChannelTypes type)
+        {
+            RecordType = type;
+            S_GUID = sGuid;
+            Filter_Class = filterClass;
+            Text_L1 = textL1;
+            Text_L2 = textL2;
+            Version = version;
+            Date = date;
+            Remarks = remarks;
+            Expired = bExpired;
+            SortKey = sortKey;
+            Last_Change = lastChange;
+            Last_Change_Text = lastChangeText;
+            History = history;
+        }
+        public static MMEFilterClasses[] GetFilterClasses()
+        {
+            var filterClasses = new List<MMEFilterClasses>();
+            try
+            {
+                using (var cmd = DbOperations.GetISOCommand())
+                {
+                    cmd.CommandType = CommandType.Text;
+                    cmd.CommandText = "SELECT * FROM MMEFilterClasses";
+
+                    try
+                    {
+                        using (var ISOReader = cmd.ExecuteReader())
+                        {
+                            while (ISOReader.Read())
+                            {
+                                try
+                                {
+                                    string sGuid = ISOReader["s_GUID"].ToString();
+                                    string filterClass = ISOReader["FILTER_CLASS"].ToString();
+                                    string textL1 = ISOReader["TEXT_L1"].ToString();
+                                    string textL2 = ISOReader["TEXT_L2"].ToString();
+                                    long version = Convert.ToInt64(ISOReader["VERSION"]);
+                                    DateTime date = (DateTime)ISOReader["DATE"];
+                                    string remarks = ISOReader["REMARKS"].ToString();
+                                    bool expired = (bool)ISOReader["EXPIRED"];
+                                    string sortkey = ISOReader["SORTKEY"].ToString();
+                                    DateTime lastChange = GetDate(ISOReader, "LAST_CHANGE");
+                                    string lastChangeText = ISOReader["LAST_CHANGE_TEXT"].ToString();
+                                    string history = ISOReader["HISTORY"].ToString();
+                                    filterClasses.Add(new MMEFilterClasses(sGuid, filterClass, textL1, textL2, version, date, remarks, expired,
+                                        sortkey, lastChange, lastChangeText, history, MMEPossibleChannels.MMEChannelTypes.ISO13499_106));
+                                }
+                                catch (Exception)
+                                {
+                                    //ignore
+                                }
+                            }
+                        }
+                    }
+                    finally
+                    {
+                        cmd.Connection.Dispose();
+                    }
+                }
+                try
+                {
+                    using (var cmd = DbOperations.GetCommand())
+                    {
+                        try
+                        {
+                            cmd.CommandText = string.Format("SELECT * from {0}", DbOperations.MMETables.MMEFilterClassesTable);
+                            using (var ds = DbOperations.Connection.QueryDataSet(cmd))
+                            {
+                                if (ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0)
+                                {
+                                    var fields = Enum.GetValues(typeof(DbOperations.MMETables.MMEFilterClassesFields))
+                                        .Cast<DbOperations.MMETables.MMEFilterClassesFields>().ToArray();
+
+                                    foreach (System.Data.DataRow dr in ds.Tables[0].Rows)
+                                    {
+                                        var version = 0;
+                                        var text2 = "";
+                                        var text1 = "";
+                                        var sortkey = "";
+                                        var sGuid = "";
+                                        var remarks = "";
+                                        var lastChangeText = "";
+                                        var lastChange = DateTime.Now;
+                                        var history = "";
+                                        var filterclass = "??";
+                                        var expired = false;
+                                        var date = DateTime.Now;
+                                        foreach (var field in fields)
+                                        {
+                                            try
+                                            {
+                                                if (DBNull.Value.Equals(dr[field.ToString()]))
+                                                {
+                                                    continue;
+                                                }
+
+                                                switch (field)
+                                                {
+                                                    case DbOperations.MMETables.MMEFilterClassesFields.DATE:
+                                                        date = Convert.ToDateTime(dr[field.ToString()]);
+                                                        break;
+                                                    case DbOperations.MMETables.MMEFilterClassesFields.EXPIRED:
+                                                        expired = Convert.ToBoolean(dr[field.ToString()]);
+                                                        break;
+                                                    case DbOperations.MMETables.MMEFilterClassesFields.FILTER_CLASS:
+                                                        filterclass = Convert.ToString(dr[field.ToString()]);
+                                                        break;
+                                                    case DbOperations.MMETables.MMEFilterClassesFields.HISTORY:
+                                                        history = Convert.ToString(dr[field.ToString()]);
+                                                        break;
+                                                    case DbOperations.MMETables.MMEFilterClassesFields.LAST_CHANGE:
+                                                        lastChange = Convert.ToDateTime(dr[field.ToString()]);
+                                                        break;
+                                                    case DbOperations.MMETables.MMEFilterClassesFields.LAST_CHANGE_TEXT:
+                                                        lastChangeText = Convert.ToString(dr[field.ToString()]);
+                                                        break;
+                                                    case DbOperations.MMETables.MMEFilterClassesFields.REMARKS:
+                                                        remarks = Convert.ToString(dr[field.ToString()]);
+                                                        break;
+                                                    case DbOperations.MMETables.MMEFilterClassesFields.s_GUID:
+                                                        sGuid = Convert.ToString(dr[field.ToString()]);
+                                                        break;
+                                                    case DbOperations.MMETables.MMEFilterClassesFields.SORTKEY:
+                                                        sortkey = Convert.ToString(dr[field.ToString()]);
+                                                        break;
+                                                    case DbOperations.MMETables.MMEFilterClassesFields.TEXT_L1:
+                                                        text1 = Convert.ToString(dr[field.ToString()]);
+                                                        break;
+                                                    case DbOperations.MMETables.MMEFilterClassesFields.TEXT_L2:
+                                                        text2 = Convert.ToString(dr[field.ToString()]);
+                                                        break;
+                                                    case DbOperations.MMETables.MMEFilterClassesFields.VERSION:
+                                                        version = Convert.ToInt32(dr[field.ToString()]);
+                                                        break;
+                                                }
+                                            }
+                                            catch (Exception)
+                                            {
+                                                //ignore
+                                            }
+                                        }
+                                        filterClasses.Add(new MMEFilterClasses(sGuid.ToString(), filterclass, text1, text2, Convert.ToInt64(version),
+                                            date, remarks, expired, sortkey, lastChange, lastChangeText, history, MMEPossibleChannels.MMEChannelTypes.SQL));
+                                    }
+                                }
+                            }
+                        }
+                        finally
+                        {
+                            cmd.Connection.Dispose();
+                        }
+                    }
+                }
+                catch (Exception) 
+                {
+                    //ignore
+                }
+
+            }
+            catch (Exception)
+            {
+                //ignore
+            }
+            return filterClasses.ToArray();
+        }
+        public override string ToString()
+        {
+            return Text_L1;
+        }
+    }
+}

DataPRO/Modules/PreviousDBVersions/Version57/DatabaseExport/ISO/MMEFineLocations1.cs

@@ -0,0 +1,203 @@
+using System;
+using System.Collections.Generic;
+using System.Data;
+using System.Linq;
+using System.Data.OleDb;
+
+namespace DatabaseExport
+{
+    public class MMEFineLocations1 : AbstractOLEDbWrapper
+    {
+        public string S_GUID { get; }
+
+        public string Fine_Loc_1 { get; }
+
+        public string Text_L1 { get; }
+
+        public string Text_L2 { get; }
+
+        public long Version { get; }
+
+        public DateTime Date { get; }
+
+        public string Remarks { get; }
+
+        public bool Expired { get; }
+
+        public string SortKey { get; }
+
+        public DateTime Last_Change { get; }
+
+        public string Last_Change_Text { get; }
+
+        public string History { get; }
+
+        public MMEPossibleChannels.MMEChannelTypes RecordType { get; } = MMEPossibleChannels.MMEChannelTypes.ISO13499_106;
+
+        public MMEFineLocations1(string sGuid, string fineLoc1, string textL1, string textL2, long version, DateTime date,
+            string remarks, bool expired, string sortKey, DateTime lastChange, string lastChangeText, string history,
+            MMEPossibleChannels.MMEChannelTypes type)
+        {
+            RecordType = type;
+            S_GUID = sGuid;
+            Fine_Loc_1 = fineLoc1;
+            Text_L1 = textL1;
+            Text_L2 = textL2;
+            Version = version;
+            Date = date;
+            Remarks = remarks;
+            Expired = expired;
+            SortKey = sortKey;
+            Last_Change = lastChange;
+            Last_Change_Text = lastChangeText;
+            History = history;
+        }
+        public static MMEFineLocations1[] GetFineLocations1()
+        {
+            var fineLocations1 = new List<MMEFineLocations1>();
+            try
+            {
+                using (var cmd = DbOperations.GetISOCommand())
+                {
+                    cmd.CommandType = CommandType.Text;
+                    cmd.CommandText = "SELECT * FROM MMEFineLocations1";
+                    try
+                    {
+                        using (var ISOReader = cmd.ExecuteReader())
+                        {
+                            while (ISOReader.Read())
+                            {
+                                try
+                                {
+                                    string sGuid = ISOReader["s_GUID"].ToString();
+                                    string sFineLoc1 = ISOReader["FINE_LOC_1"].ToString();
+                                    string textL1 = ISOReader["TEXT_L1"].ToString();
+                                    string textL2 = ISOReader["TEXT_L2"].ToString();
+                                    long version = Convert.ToInt64(ISOReader["VERSION"]);
+                                    DateTime date = (DateTime)ISOReader["DATE"];
+                                    string remarks = ISOReader["REMARKS"].ToString();
+                                    bool expired = (bool)ISOReader["EXPIRED"];
+                                    string sortkey = ISOReader["SORTKEY"].ToString();
+                                    DateTime lastChange = GetDate(ISOReader, "LAST_CHANGE");
+                                    string lastChangeText = ISOReader["LAST_CHANGE_TEXT"].ToString();
+                                    string history = ISOReader["HISTORY"].ToString();
+                                    fineLocations1.Add(new MMEFineLocations1(sGuid, sFineLoc1, textL1, textL2, version, date,
+                                        remarks, expired, sortkey, lastChange, lastChangeText, history, MMEPossibleChannels.MMEChannelTypes.ISO13499_106));
+                                }
+                                catch (Exception)
+                                {
+                                    //ignore
+                                }
+                            }
+                        }
+                    }
+                    finally
+                    {
+                        cmd.Connection.Dispose();
+                    }
+                }
+                try
+                {
+                    using (var cmd = DbOperations.GetCommand())
+                    {
+                        try
+                        {
+                            cmd.CommandText = string.Format("SELECT * FROM {0}", DbOperations.MMETables.MMEFineLocations1Table);
+
+                            using (var ds = DbOperations.Connection.QueryDataSet(cmd))
+                            {
+                                if (ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0)
+                                {
+                                    foreach (System.Data.DataRow dr in ds.Tables[0].Rows)
+                                    {
+                                        var date = DateTime.Now;
+                                        var expired = false;
+                                        var fineLoc1 = "??";
+                                        var history = "";
+                                        var lastChange = DateTime.Now;
+                                        var lastChangeText = "";
+                                        var remarks = "";
+                                        var sGuid = "";
+                                        var sortKey = "";
+                                        var text1 = "";
+                                        var text2 = "";
+                                        var version = 0;
+                                        var fields = Enum.GetValues(typeof(DbOperations.MMETables.MMEFineLocations1Fields))
+                                            .Cast<DbOperations.MMETables.MMEFineLocations1Fields>().ToArray();
+                                        foreach (var field in fields)
+                                        {
+                                            if (DBNull.Value.Equals(dr[field.ToString()])) { continue; }
+                                            try
+                                            {
+                                                switch (field)
+                                                {
+                                                    case DbOperations.MMETables.MMEFineLocations1Fields.DATE:
+                                                        date = Convert.ToDateTime(dr[field.ToString()]);
+                                                        break;
+                                                    case DbOperations.MMETables.MMEFineLocations1Fields.EXPIRED:
+                                                        expired = Convert.ToBoolean(dr[field.ToString()]);
+                                                        break;
+                                                    case DbOperations.MMETables.MMEFineLocations1Fields.FINE_LOC_1:
+                                                        fineLoc1 = Convert.ToString(dr[field.ToString()]);
+                                                        break;
+                                                    case DbOperations.MMETables.MMEFineLocations1Fields.HISTORY:
+                                                        history = Convert.ToString(dr[field.ToString()]);
+                                                        break;
+                                                    case DbOperations.MMETables.MMEFineLocations1Fields.LAST_CHANGE:
+                                                        lastChange = Convert.ToDateTime(dr[field.ToString()]);
+                                                        break;
+                                                    case DbOperations.MMETables.MMEFineLocations1Fields.LAST_CHANGE_TEXT:
+                                                        lastChangeText = Convert.ToString(dr[field.ToString()]);
+                                                        break;
+                                                    case DbOperations.MMETables.MMEFineLocations1Fields.REMARKS:
+                                                        remarks = Convert.ToString(dr[field.ToString()]);
+                                                        break;
+                                                    case DbOperations.MMETables.MMEFineLocations1Fields.s_GUID:
+                                                        sGuid = Convert.ToString(dr[field.ToString()]);
+                                                        break;
+                                                    case DbOperations.MMETables.MMEFineLocations1Fields.SORTKEY:
+                                                        sortKey = Convert.ToString(dr[field.ToString()]);
+                                                        break;
+                                                    case DbOperations.MMETables.MMEFineLocations1Fields.TEXT_L1:
+                                                        text1 = Convert.ToString(dr[field.ToString()]);
+                                                        break;
+                                                    case DbOperations.MMETables.MMEFineLocations1Fields.TEXT_L2:
+                                                        text2 = Convert.ToString(dr[field.ToString()]);
+                                                        break;
+                                                    case DbOperations.MMETables.MMEFineLocations1Fields.VERSION:
+                                                        version = Convert.ToInt32(dr[field.ToString()]);
+                                                        break;
+                                                }
+                                            }
+                                            catch (Exception) 
+                                            {
+                                                //ignore
+                                            }
+                                        }
+                                        var fineLoc = new MMEFineLocations1(sGuid.ToString(), fineLoc1, text1, text2,
+                                            Convert.ToInt64(version), date, remarks, expired, sortKey, lastChange, lastChangeText,
+                                            history, MMEPossibleChannels.MMEChannelTypes.SQL);
+                                        fineLocations1.Add(fineLoc);
+                                    }
+                                }
+                            }
+                        }
+                        finally
+                        {
+                            cmd.Connection.Dispose();
+                        }
+                    }
+                }
+                catch (Exception) 
+                {
+                    //ignore
+                }
+            }
+            catch (Exception)
+            {
+                //ignore
+            }
+            return fineLocations1.ToArray();
+        }
+    }
+}

DataPRO/Modules/PreviousDBVersions/Version57/DatabaseExport/ISO/MMEFineLocations2.cs

@@ -0,0 +1,206 @@
+using System;
+using System.Collections.Generic;
+using System.Data;
+using System.Linq;
+using System.Data.OleDb;
+
+namespace DatabaseExport
+{
+    public class MMEFineLocations2 : AbstractOLEDbWrapper
+    {
+        public string S_GUID { get; }
+
+        public string FINE_LOC_2 { get; }
+
+        public string Text_L1 { get; }
+
+        public string Text_L2 { get; }
+
+        public long Version { get; }
+
+        public DateTime Date { get; }
+
+        public string Remarks { get; }
+
+        public bool Expired { get; }
+
+        public string SortKey { get; }
+
+        public DateTime Last_Change { get; }
+
+        public string Last_Change_Text { get; }
+
+        public string History { get; }
+
+        public MMEPossibleChannels.MMEChannelTypes RecordType { get; } = MMEPossibleChannels.MMEChannelTypes.ISO13499_106;
+
+        public MMEFineLocations2(string sGuid, string fineLoc2, string textL1, string textL2, long version, DateTime date,
+            string remarks, bool expired, string sortKey, DateTime lastChange, string lastChangeText, string history,
+            MMEPossibleChannels.MMEChannelTypes type)
+        {
+            RecordType = type;
+            S_GUID = sGuid;
+            FINE_LOC_2 = fineLoc2;
+            Text_L1 = textL1;
+            Text_L2 = textL2;
+            Version = version;
+            Date = date;
+            Remarks = remarks;
+            Expired = expired;
+            SortKey = sortKey;
+            Last_Change = lastChange;
+            Last_Change_Text = lastChangeText;
+            History = history;
+        }
+        public static MMEFineLocations2[] GetFineLocations2()
+        {
+            var fineLocations2 = new List<MMEFineLocations2>();
+            try
+            {
+                using (var cmd = DbOperations.GetISOCommand())
+                {
+                    cmd.CommandText = "SELECT * FROM MMEFineLocations2";
+                    cmd.CommandType = CommandType.Text;
+                    try
+                    {
+                        using (var ISOReader = cmd.ExecuteReader())
+                        {
+                            while (ISOReader.Read())
+                            {
+                                try
+                                {
+                                    string sGuid = ISOReader["s_GUID"].ToString();
+                                    string sFineLoc2 = ISOReader["FINE_LOC_2"].ToString();
+                                    string textL1 = ISOReader["TEXT_L1"].ToString();
+                                    string textL2 = ISOReader["TEXT_L2"].ToString();
+                                    long version = Convert.ToInt64(ISOReader["VERSION"]);
+                                    DateTime date = (DateTime)ISOReader["DATE"];
+                                    string remarks = ISOReader["REMARKS"].ToString();
+                                    bool expired = (bool)ISOReader["EXPIRED"];
+                                    string sortkey = ISOReader["SORTKEY"].ToString();
+                                    DateTime lastChange = GetDate(ISOReader, "LAST_CHANGE");
+                                    string lastChangeText = ISOReader["LAST_CHANGE_TEXT"].ToString();
+                                    string history = ISOReader["HISTORY"].ToString();
+                                    fineLocations2.Add(new MMEFineLocations2(sGuid, sFineLoc2, textL1, textL2, version, date,
+                                        remarks, expired, sortkey, lastChange, lastChangeText, history, MMEPossibleChannels.MMEChannelTypes.ISO13499_106));
+                                }
+                                catch (Exception)
+                                {
+                                    //ignore
+                                }
+                            }
+                        }
+                    }
+                    finally
+                    {
+                        cmd.Connection.Dispose();
+                    }
+                }
+                try
+                {
+                    using (var cmd = DbOperations.GetCommand())
+                    {
+                        try
+                        {
+                            cmd.CommandText = string.Format("SELECT * from {0}", DbOperations.MMETables.MMEFineLocations2Table);
+                            using (var ds = DbOperations.Connection.QueryDataSet(cmd))
+                            {
+                                if (ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0)
+                                {
+                                    var fields = Enum.GetValues(typeof(DbOperations.MMETables.MMEFineLocations2Fields))
+                                        .Cast<DbOperations.MMETables.MMEFineLocations2Fields>().ToArray();
+                                    foreach (System.Data.DataRow dr in ds.Tables[0].Rows)
+                                    {
+                                        var version = 0;
+                                        var text2 = "";
+                                        var text1 = "";
+                                        var sortkey = "";
+                                        var sGuid = "";
+                                        var remarks = "";
+                                        var lastChangeText = "";
+                                        var lastChange = DateTime.Now;
+                                        var history = "";
+                                        var fineLoc2 = "??";
+                                        var expired = false;
+                                        var date = DateTime.Now;
+
+                                        foreach (var field in fields)
+                                        {
+                                            try
+                                            {
+                                                if (DBNull.Value.Equals(dr[field.ToString()]))
+                                                {
+                                                    continue;
+                                                }
+
+                                                switch (field)
+                                                {
+                                                    case DbOperations.MMETables.MMEFineLocations2Fields.DATE:
+                                                        date = Convert.ToDateTime(dr[field.ToString()]);
+                                                        break;
+                                                    case DbOperations.MMETables.MMEFineLocations2Fields.EXPIRED:
+                                                        expired = Convert.ToBoolean(dr[field.ToString()]);
+                                                        break;
+                                                    case DbOperations.MMETables.MMEFineLocations2Fields.FINE_LOC_2:
+                                                        fineLoc2 = Convert.ToString(dr[field.ToString()]);
+                                                        break;
+                                                    case DbOperations.MMETables.MMEFineLocations2Fields.HISTORY:
+                                                        history = Convert.ToString(dr[field.ToString()]);
+                                                        break;
+                                                    case DbOperations.MMETables.MMEFineLocations2Fields.LAST_CHANGE:
+                                                        lastChange = Convert.ToDateTime(dr[field.ToString()]);
+                                                        break;
+                                                    case DbOperations.MMETables.MMEFineLocations2Fields.LAST_CHANGE_TEXT:
+                                                        lastChangeText = Convert.ToString(dr[field.ToString()]);
+                                                        break;
+                                                    case DbOperations.MMETables.MMEFineLocations2Fields.REMARKS:
+                                                        remarks = Convert.ToString(dr[field.ToString()]);
+                                                        break;
+                                                    case DbOperations.MMETables.MMEFineLocations2Fields.s_GUID:
+                                                        sGuid = Convert.ToString(dr[field.ToString()]);
+                                                        break;
+                                                    case DbOperations.MMETables.MMEFineLocations2Fields.SORTKEY:
+                                                        sortkey = Convert.ToString(dr[field.ToString()]);
+                                                        break;
+                                                    case DbOperations.MMETables.MMEFineLocations2Fields.TEXT_L1:
+                                                        text1 = Convert.ToString(dr[field.ToString()]);
+                                                        break;
+                                                    case DbOperations.MMETables.MMEFineLocations2Fields.TEXT_L2:
+                                                        text2 = Convert.ToString(dr[field.ToString()]);
+                                                        break;
+                                                    case DbOperations.MMETables.MMEFineLocations2Fields.VERSION:
+                                                        version = Convert.ToInt32(dr[field.ToString()]);
+                                                        break;
+                                                }
+                                            }
+                                            catch (Exception) 
+                                            {
+                                                //ignore
+                                            }
+
+                                        }
+                                        fineLocations2.Add(new MMEFineLocations2(sGuid.ToString(), fineLoc2, text1, text2, Convert.ToInt64(version),
+                                            date, remarks, expired, sortkey, lastChange, lastChangeText, history, MMEPossibleChannels.MMEChannelTypes.SQL));
+                                    }
+                                }
+                            }
+                        }
+                        finally
+                        {
+                            cmd.Connection.Dispose();
+                        }
+                    }
+                }
+                catch (Exception) 
+                {
+                    //ignore
+                }
+            }
+            catch (Exception)
+            {
+                //ignore
+            }
+            return fineLocations2.ToArray();
+        }
+    }
+}

DataPRO/Modules/PreviousDBVersions/Version57/DatabaseExport/ISO/MMEFineLocations3.cs

@@ -0,0 +1,216 @@
+using System;
+using System.Collections.Generic;
+using System.Data;
+using System.Linq;
+using System.Data.OleDb;
+
+namespace DatabaseExport
+{
+    public class MMEFineLocations3 : AbstractOLEDbWrapper
+    {
+        public string S_GUID { get; }
+
+        public string FINE_LOC_3 { get; }
+
+        public string Text_L1 { get; }
+
+        public string Text_L2 { get; }
+
+        public long Version { get; }
+
+        public DateTime Date { get; }
+
+        public string Remarks { get; }
+
+        public bool Expired { get; }
+
+        public string SortKey { get; }
+
+        public string Picture_ShortName { get; }
+
+        public DateTime Last_Change { get; }
+
+        public string Last_Change_Text { get; }
+
+        public string History { get; }
+
+        public MMEPossibleChannels.MMEChannelTypes RecordType { get; }
+
+        public MMEFineLocations3(string sGuid, string fineLoc3, string textL1, string textL2, long version, DateTime date,
+            string remarks, bool expired, string sortKey, DateTime lastChange, string lastChangeText, string history, string picturesShortName,
+            MMEPossibleChannels.MMEChannelTypes type)
+        {
+            RecordType = type;
+            S_GUID = sGuid;
+            FINE_LOC_3 = fineLoc3;
+            Text_L1 = textL1;
+            Text_L2 = textL2;
+            Version = version;
+            Date = date;
+            Remarks = remarks;
+            Expired = expired;
+            SortKey = sortKey;
+            Last_Change = lastChange;
+            Last_Change_Text = lastChangeText;
+            History = history;
+            Picture_ShortName = picturesShortName;
+        }
+        public static MMEFineLocations3[] GetFineLocations3()
+        {
+            var fineLocations3 = new List<MMEFineLocations3>();
+            try
+            {
+                using (var cmd = DbOperations.GetISOCommand())
+                {
+                    cmd.CommandType = CommandType.Text;
+                    cmd.CommandText = "SELECT * FROM MMEFineLocations3";
+                    try
+                    {
+                        using (var ISOReader = cmd.ExecuteReader())
+                        {
+                            while (ISOReader.Read())
+                            {
+                                try
+                                {
+                                    string sGuid = ISOReader["s_GUID"].ToString();
+                                    string sFineLoc3 = ISOReader["FINE_LOC_3"].ToString();
+                                    string textL1 = ISOReader["TEXT_L1"].ToString();
+                                    string textL2 = ISOReader["TEXT_L2"].ToString();
+                                    long version = Convert.ToInt64(ISOReader["VERSION"]);
+                                    DateTime date = (DateTime)ISOReader["DATE"];
+                                    string remarks = ISOReader["REMARKS"].ToString();
+                                    bool expired = (bool)ISOReader["EXPIRED"];
+                                    string sortkey = ISOReader["SORTKEY"].ToString();
+                                    DateTime lastChange = GetDate(ISOReader, "LAST_CHANGE");
+                                    string lastChangeText = ISOReader["LAST_CHANGE_TEXT"].ToString();
+                                    string history = ISOReader["HISTORY"].ToString();
+                                    string pictureShortName = ISOReader["PICTURE_SHORTNAME"].ToString();
+                                    fineLocations3.Add(new MMEFineLocations3(sGuid, sFineLoc3, textL1, textL2, version, date,
+                                        remarks, expired, sortkey, lastChange, lastChangeText, history, pictureShortName, MMEPossibleChannels.MMEChannelTypes.ISO13499_106));
+                                }
+                                catch (Exception)
+                                {
+                                    //ignore
+                                }
+                            }
+                        }
+                    }
+                    finally
+                    {
+                        cmd.Connection.Dispose();
+                    }
+                }
+                try
+                {
+                    using (var cmd = DbOperations.GetCommand())
+                    {
+                        try
+                        {
+                            cmd.CommandText = string.Format("SELECT * FROM {0}", DbOperations.MMETables.MMEFineLocations3Table);
+                            using (var ds = DbOperations.Connection.QueryDataSet(cmd))
+                            {
+                                if (ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0)
+                                {
+                                    var fields = Enum.GetValues(typeof(DbOperations.MMETables.MMEFineLocations3Fields))
+                                        .Cast<DbOperations.MMETables.MMEFineLocations3Fields>().ToArray();
+
+                                    foreach (System.Data.DataRow dr in ds.Tables[0].Rows)
+                                    {
+
+                                        var date = DateTime.Now;
+                                        var expired = false;
+                                        var fineLoc3 = "??";
+                                        var history = "";
+                                        var lastChange = DateTime.Now;
+                                        var lastChangeText = "";
+                                        var pictureShortName = "";
+                                        var remarks = "";
+                                        var sGuid = "";
+                                        var sortKey = "";
+                                        var text1 = "";
+                                        var text2 = "";
+                                        var version = 0;
+
+                                        foreach (var field in fields)
+                                        {
+                                            try
+                                            {
+                                                if (DBNull.Value.Equals(dr[field.ToString()]))
+                                                {
+                                                    continue;
+                                                }
+
+                                                var o = dr[field.ToString()];
+                                                switch (field)
+                                                {
+                                                    case DbOperations.MMETables.MMEFineLocations3Fields.DATE:
+                                                        date = Convert.ToDateTime(o);
+                                                        break;
+                                                    case DbOperations.MMETables.MMEFineLocations3Fields.EXPIRED:
+                                                        expired = Convert.ToBoolean(o);
+                                                        break;
+                                                    case DbOperations.MMETables.MMEFineLocations3Fields.FINE_LOC_3:
+                                                        fineLoc3 = Convert.ToString(o);
+                                                        break;
+                                                    case DbOperations.MMETables.MMEFineLocations3Fields.HISTORY:
+                                                        history = Convert.ToString(o);
+                                                        break;
+                                                    case DbOperations.MMETables.MMEFineLocations3Fields.LAST_CHANGE:
+                                                        lastChange = Convert.ToDateTime(o);
+                                                        break;
+                                                    case DbOperations.MMETables.MMEFineLocations3Fields.LAST_CHANGE_TEXT:
+                                                        lastChangeText = Convert.ToString(o);
+                                                        break;
+                                                    case DbOperations.MMETables.MMEFineLocations3Fields.PICTURE_SHORTNAME:
+                                                        pictureShortName = Convert.ToString(o);
+                                                        break;
+                                                    case DbOperations.MMETables.MMEFineLocations3Fields.REMARKS:
+                                                        remarks = Convert.ToString(o);
+                                                        break;
+                                                    case DbOperations.MMETables.MMEFineLocations3Fields.s_GUID:
+                                                        sGuid = Convert.ToString(o);
+                                                        break;
+                                                    case DbOperations.MMETables.MMEFineLocations3Fields.SORTKEY:
+                                                        sortKey = Convert.ToString(o);
+                                                        break;
+                                                    case DbOperations.MMETables.MMEFineLocations3Fields.TEXT_L1:
+                                                        text1 = Convert.ToString(o);
+                                                        break;
+                                                    case DbOperations.MMETables.MMEFineLocations3Fields.TEXT_L2:
+                                                        text2 = Convert.ToString(o);
+                                                        break;
+                                                    case DbOperations.MMETables.MMEFineLocations3Fields.VERSION:
+                                                        version = Convert.ToInt32(o);
+                                                        break;
+                                                }
+                                            }
+                                            catch (Exception) 
+                                            {
+                                                //ignore
+                                            }
+                                        }
+                                        fineLocations3.Add(new MMEFineLocations3(sGuid.ToString(), fineLoc3, text1, text2, Convert.ToInt64(version), date, remarks, expired,
+                                            sortKey, lastChange, lastChangeText, history, pictureShortName, MMEPossibleChannels.MMEChannelTypes.SQL));
+                                    }
+                                }
+                            }
+                        }
+                        finally
+                        {
+                            cmd.Connection.Dispose();
+                        }
+                    }
+                }
+                catch (Exception) 
+                {
+                    //ignore
+                }
+            }
+            catch (Exception)
+            {
+                //ignore
+            }
+            return fineLocations3.ToArray();
+        }
+    }
+}

DataPRO/Modules/PreviousDBVersions/Version57/DatabaseExport/ISO/MMEPhysicalDimensions.cs

@@ -0,0 +1,273 @@
+using System;
+using System.Collections.Generic;
+using System.Data;
+using System.Linq;
+using System.Data.OleDb;
+
+namespace DatabaseExport
+{
+    public class MMEPhysicalDimensions : AbstractOLEDbWrapper
+    {
+        public string S_GUID { get; }
+
+        public string Physical_Dimension { get; }
+
+        public string Text_L1 { get; }
+
+        public string Text_L2 { get; }
+
+        public string Default_Unit { get; }
+
+        public long Length_EXP { get; }
+
+        public long Time_EXP { get; }
+
+        public long Mass_EXP { get; }
+
+        public long Electric_Current_EXP { get; }
+
+        public long Temperature_EXP { get; }
+
+        public long Luminous_Intensity_Exp { get; }
+
+        public long Amount_Of_Substance_EXP { get; }
+
+        public long Version { get; }
+
+        public DateTime Date { get; }
+
+        public string Remarks { get; }
+
+        public bool Expired { get; }
+
+        public string SortKey { get; }
+
+        public DateTime Last_Change { get; }
+
+        public string Last_Change_Text { get; }
+
+        public string History { get; }
+
+        public MMEPossibleChannels.MMEChannelTypes RecordType { get; } = MMEPossibleChannels.MMEChannelTypes.ISO13499_106;
+
+        public MMEPhysicalDimensions(string sGUID, string physicalDimension, string textL1, string textL2, string defaultUnit,
+            long lengthExp, long timeExp, long massExp, long currentExp, long temperatureExp, long luminiousExp, long amountExp,
+            long version, DateTime date, string remarks, bool expired, string sortKey, DateTime lastChange, string lastChangeText,
+            string history, MMEPossibleChannels.MMEChannelTypes type)
+        {
+            RecordType = type;
+            S_GUID = sGUID;
+            Physical_Dimension = physicalDimension;
+            Text_L1 = textL1;
+            Text_L2 = textL2;
+            Default_Unit = defaultUnit;
+            Length_EXP = lengthExp;
+            Time_EXP = timeExp;
+            Mass_EXP = massExp;
+            Electric_Current_EXP = currentExp;
+            Temperature_EXP = temperatureExp;
+            Luminous_Intensity_Exp = luminiousExp;
+            Amount_Of_Substance_EXP = amountExp;
+            Version = version;
+            Date = date;
+            Remarks = remarks;
+            Expired = expired;
+            SortKey = sortKey;
+            Last_Change = lastChange;
+            Last_Change_Text = lastChangeText;
+            History = history;
+        }
+        public static MMEPhysicalDimensions[] GetPhysicalDimensions()
+        {
+            var physicalDimensions = new List<MMEPhysicalDimensions>();
+            try
+            {
+                using (var cmd = DbOperations.GetISOCommand())
+                {
+                    cmd.CommandType = CommandType.Text;
+                    cmd.CommandText = "SELECT * FROM MMEPhysicalDimensions";
+                    try
+                    {
+                        using (var ISOReader = cmd.ExecuteReader())
+                        {
+                            while (ISOReader.Read())
+                            {
+                                try
+                                {
+                                    string sGuid = ISOReader["s_GUID"].ToString();
+                                    string physicalDimension = ISOReader["PHYSICAL_DIMENSION"].ToString();
+                                    string textL1 = ISOReader["TEXT_L1"].ToString();
+                                    string textL2 = ISOReader["TEXT_L2"].ToString();
+                                    string defaultUnit = ISOReader["DEFAULT_UNIT"].ToString();
+                                    long lengthExp = GetLong(ISOReader, "LENGTH_EXP");
+                                    long timeExp = GetLong(ISOReader, "TIME_EXP");
+                                    long massExp = GetLong(ISOReader, "MASS_EXP");
+                                    long electricCurrentExp = GetLong(ISOReader, "ELECTRIC_CURRENT_EXP");
+                                    long temperatureExp = GetLong(ISOReader, "TEMPERATURE_EXP");
+                                    long luminiousExp = GetLong(ISOReader, "LUMINOUS_INTENSITY_EXP");
+                                    long amountExp = GetLong(ISOReader, "AMOUNT_OF_SUBSTANCE_EXP");
+                                    long version = GetLong(ISOReader, "VERSION");
+                                    DateTime date = (DateTime)ISOReader["DATE"];
+                                    string remarks = ISOReader["REMARKS"].ToString();
+                                    bool expired = (bool)ISOReader["EXPIRED"];
+                                    string sortkey = ISOReader["SORTKEY"].ToString();
+                                    DateTime lastChange = GetDate(ISOReader, "LAST_CHANGE");
+                                    string lastChangeText = ISOReader["LAST_CHANGE_TEXT"].ToString();
+                                    string history = ISOReader["HISTORY"].ToString();
+
+                                    physicalDimensions.Add(new MMEPhysicalDimensions(sGuid, physicalDimension, textL1, textL2, defaultUnit, lengthExp,
+                                        timeExp, massExp, electricCurrentExp, temperatureExp, luminiousExp, amountExp,
+                                        version, date, remarks, expired, sortkey, lastChange, lastChangeText, history, MMEPossibleChannels.MMEChannelTypes.ISO13499_106));
+                                }
+                                catch (Exception)
+                                {
+                                    //ignore
+                                }
+                            }
+                        }
+                    }
+                    finally
+                    {
+                        cmd.Connection.Dispose();
+                    }
+                }
+                try
+                {
+                    using (var cmd = DbOperations.GetCommand())
+                    {
+                        try
+                        {
+                            cmd.CommandText = string.Format("SELECT * FROM {0}", DbOperations.MMETables.MMEPhysicalDimensions);
+                            using (var ds = DbOperations.Connection.QueryDataSet(cmd))
+                            {
+                                if (ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0)
+                                {
+                                    var fields = Enum.GetValues(typeof(DbOperations.MMETables.MMEPhysicalDimensionFields))
+                                        .Cast<DbOperations.MMETables.MMEPhysicalDimensionFields>().ToArray();
+
+                                    foreach (System.Data.DataRow dr in ds.Tables[0].Rows)
+                                    {
+                                        var version = 0;
+                                        var timeExp = 0;
+                                        var text2 = "";
+                                        var text1 = "";
+                                        var tempExp = 0;
+                                        var sortKey = "";
+                                        var sGuid = "";
+                                        var remarks = "";
+                                        var physicalDimension = "??";
+                                        var massExp = 0;
+                                        var lumIntExp = 0;
+                                        var lengthExp = 0;
+                                        var lastChangeText = "";
+                                        var lastChange = DateTime.Now;
+                                        var history = "";
+                                        var expired = false;
+                                        var electricalExp = 0;
+                                        var defaultUnit = "";
+                                        var date = DateTime.Now;
+                                        var amountOfSubstanceExp = 0;
+                                        foreach (var field in fields)
+                                        {
+                                            try
+                                            {
+                                                if (DBNull.Value.Equals(dr[field.ToString()])) { continue; }
+                                                var o = dr[field.ToString()];
+
+                                                switch (field)
+                                                {
+                                                    case DbOperations.MMETables.MMEPhysicalDimensionFields.AMOUNT_OFSUBSTANCE_EXP:
+                                                        amountOfSubstanceExp = Convert.ToInt32(o);
+                                                        break;
+                                                    case DbOperations.MMETables.MMEPhysicalDimensionFields.DATE:
+                                                        date = Convert.ToDateTime(o);
+                                                        break;
+                                                    case DbOperations.MMETables.MMEPhysicalDimensionFields.DEFAULT_UNIT:
+                                                        defaultUnit = Convert.ToString(o);
+                                                        break;
+                                                    case DbOperations.MMETables.MMEPhysicalDimensionFields.ELECTRIC_CURRENT_EXP:
+                                                        electricalExp = Convert.ToInt32(o);
+                                                        break;
+                                                    case DbOperations.MMETables.MMEPhysicalDimensionFields.EXPIRED:
+                                                        expired = Convert.ToBoolean(o);
+                                                        break;
+                                                    case DbOperations.MMETables.MMEPhysicalDimensionFields.HISTORY:
+                                                        history = Convert.ToString(o);
+                                                        break;
+                                                    case DbOperations.MMETables.MMEPhysicalDimensionFields.LAST_CHANGE:
+                                                        lastChange = Convert.ToDateTime(o);
+                                                        break;
+                                                    case DbOperations.MMETables.MMEPhysicalDimensionFields.LAST_CHANGE_TEXT:
+                                                        lastChangeText = Convert.ToString(o);
+                                                        break;
+                                                    case DbOperations.MMETables.MMEPhysicalDimensionFields.LENGTH_EXP:
+                                                        lengthExp = Convert.ToInt32(o);
+                                                        break;
+                                                    case DbOperations.MMETables.MMEPhysicalDimensionFields.LUMINOUS_INTENSITY_EXP:
+                                                        lumIntExp = Convert.ToInt32(o);
+                                                        break;
+                                                    case DbOperations.MMETables.MMEPhysicalDimensionFields.MASS_EXP:
+                                                        massExp = Convert.ToInt32(o);
+                                                        break;
+                                                    case DbOperations.MMETables.MMEPhysicalDimensionFields.PHYSICAL_DIMENSION:
+                                                        physicalDimension = Convert.ToString(o);
+                                                        break;
+                                                    case DbOperations.MMETables.MMEPhysicalDimensionFields.REMARKS:
+                                                        remarks = Convert.ToString(o);
+                                                        break;
+                                                    case DbOperations.MMETables.MMEPhysicalDimensionFields.s_GUID:
+                                                        sGuid = Convert.ToString(o);
+                                                        break;
+                                                    case DbOperations.MMETables.MMEPhysicalDimensionFields.SORTKEY:
+                                                        sortKey = Convert.ToString(o);
+                                                        break;
+                                                    case DbOperations.MMETables.MMEPhysicalDimensionFields.TEMPERATURE_EXP:
+                                                        tempExp = Convert.ToInt32(o);
+                                                        break;
+                                                    case DbOperations.MMETables.MMEPhysicalDimensionFields.TEXT_L1:
+                                                        text1 = Convert.ToString(o);
+                                                        break;
+                                                    case DbOperations.MMETables.MMEPhysicalDimensionFields.TEXT_L2:
+                                                        text2 = Convert.ToString(o);
+                                                        break;
+                                                    case DbOperations.MMETables.MMEPhysicalDimensionFields.TIME_EXP:
+                                                        timeExp = Convert.ToInt32(o);
+                                                        break;
+                                                    case DbOperations.MMETables.MMEPhysicalDimensionFields.VERSION:
+                                                        version = Convert.ToInt32(o);
+                                                        break;
+                                                }
+                                            }
+                                            catch (Exception) 
+                                            {
+                                                //ignore
+                                            }
+                                        }
+                                        physicalDimensions.Add(new MMEPhysicalDimensions(sGuid.ToString(), physicalDimension, text1, text2, defaultUnit, Convert.ToInt64(lengthExp),
+                                            Convert.ToInt64(timeExp), Convert.ToInt64(massExp), Convert.ToInt64(electricalExp), Convert.ToInt64(tempExp), Convert.ToInt64(lumIntExp),
+                                            Convert.ToInt64(amountOfSubstanceExp), Convert.ToInt64(version), date, remarks, expired, sortKey, lastChange, lastChangeText,
+                                            history, MMEPossibleChannels.MMEChannelTypes.SQL));
+
+                                    }
+                                }
+                            }
+                        }
+                        finally
+                        {
+                            cmd.Connection.Dispose();
+                        }
+                    }
+                }
+                catch (Exception) 
+                {
+                    //ignore
+                }
+            }
+            catch (Exception)
+            {
+                //ignore
+            }
+            return physicalDimensions.ToArray();
+        }
+    }
+}

DataPRO/Modules/PreviousDBVersions/Version57/DatabaseExport/ISO/MMEPositions.cs

@@ -0,0 +1,203 @@
+using System;
+using System.Collections.Generic;
+using System.Data;
+using System.Linq;
+using System.Data.OleDb;
+
+namespace DatabaseExport
+{
+    public class MMEPositions : AbstractOLEDbWrapper
+    {
+        public string S_GUID { get; }
+
+        public string Position { get; }
+
+        public string Text_L1 { get; }
+
+        public string Text_L2 { get; }
+
+        public long Version { get; }
+
+        public DateTime Date { get; }
+
+        public string Remarks { get; }
+
+        public bool Expired { get; }
+
+        public string SortKey { get; }
+
+        public DateTime Last_Change { get; }
+
+        public string Last_Change_Text { get; }
+
+        public string History { get; }
+
+        public MMEPossibleChannels.MMEChannelTypes RecordType { get; } = MMEPossibleChannels.MMEChannelTypes.ISO13499_106;
+
+        public MMEPositions(string sGuid, string position, string textL1, string textL2, long version,
+            DateTime date, string remarks, bool expired, string sortKey, DateTime lastChange, string lastChangeText,
+            string history, MMEPossibleChannels.MMEChannelTypes type)
+        {
+            RecordType = type;
+            S_GUID = sGuid;
+            Position = position;
+            Text_L1 = textL1;
+            Text_L2 = textL2;
+            Version = version;
+            Date = date;
+            Remarks = remarks;
+            Expired = expired;
+            SortKey = sortKey;
+            Last_Change = lastChange;
+            Last_Change_Text = lastChangeText;
+            History = history;
+        }
+        public static MMEPositions[] GetPositions()
+        {
+            var positions = new List<MMEPositions>();
+            try
+            {
+                using (var cmd = DbOperations.GetISOCommand())
+                {
+                    cmd.CommandText = "SELECT * FROM MMEPositions";
+                    cmd.CommandType = CommandType.Text;
+                    try
+                    {
+                        using (var ISOReader = cmd.ExecuteReader())
+                        {
+                            while (ISOReader.Read())
+                            {
+                                try
+                                {
+                                    string sGuid = ISOReader["s_GUID"].ToString();
+                                    string position = ISOReader["POSITION"].ToString();
+                                    string textL1 = ISOReader["TEXT_L1"].ToString();
+                                    string textL2 = ISOReader["TEXT_L2"].ToString();
+                                    long version = GetLong(ISOReader, "VERSION");
+                                    DateTime date = (DateTime)ISOReader["DATE"];
+                                    string remarks = ISOReader["REMARKS"].ToString();
+                                    bool expired = (bool)ISOReader["EXPIRED"];
+                                    string sortkey = ISOReader["SORTKEY"].ToString();
+                                    DateTime lastChange = GetDate(ISOReader, "LAST_CHANGE");
+                                    string lastChangeText = ISOReader["LAST_CHANGE_TEXT"].ToString();
+                                    string history = ISOReader["HISTORY"].ToString();
+                                    positions.Add(new MMEPositions(sGuid, position, textL1, textL2, version, date, remarks, expired, sortkey, lastChange, lastChangeText, history, MMEPossibleChannels.MMEChannelTypes.ISO13499_106));
+                                }
+                                catch (Exception)
+                                {
+                                    //ignore
+                                }
+                            }
+                        }
+                    }
+                    finally
+                    {
+                        cmd.Connection.Dispose();
+                    }
+                }
+                try
+                {
+                    using (var cmd = DbOperations.GetCommand())
+                    {
+                        try
+                        {
+                            cmd.CommandText = string.Format("SELECT * FROM {0}", DbOperations.MMETables.MMEPositionsTable);
+                            using (var ds = DbOperations.Connection.QueryDataSet(cmd))
+                            {
+                                if (ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0)
+                                {
+                                    var fields = Enum.GetValues(typeof(DbOperations.MMETables.MMEPositionsFields))
+                                        .Cast<DbOperations.MMETables.MMEPositionsFields>().ToArray();
+                                    foreach (System.Data.DataRow dr in ds.Tables[0].Rows)
+                                    {
+                                        var version = 0;
+                                        var text2 = "";
+                                        var text1 = "";
+                                        var sortKey = "";
+                                        var sGuid = "";
+                                        var remarks = "";
+                                        var position = "?";
+                                        var lastChangeText = "";
+                                        var lastChange = DateTime.Now;
+                                        var history = "";
+                                        var expired = false;
+                                        var date = DateTime.Now;
+
+                                        foreach (var field in fields)
+                                        {
+                                            try
+                                            {
+                                                if (DBNull.Value.Equals(dr[field.ToString()])) { continue; }
+
+                                                var o = dr[field.ToString()];
+
+                                                switch (field)
+                                                {
+                                                    case DbOperations.MMETables.MMEPositionsFields.DATE:
+                                                        date = Convert.ToDateTime(o);
+                                                        break;
+                                                    case DbOperations.MMETables.MMEPositionsFields.EXPIRED:
+                                                        expired = Convert.ToBoolean(o);
+                                                        break;
+                                                    case DbOperations.MMETables.MMEPositionsFields.HISTORY:
+                                                        history = Convert.ToString(o);
+                                                        break;
+                                                    case DbOperations.MMETables.MMEPositionsFields.LAST_CHANGE:
+                                                        lastChange = Convert.ToDateTime(o);
+                                                        break;
+                                                    case DbOperations.MMETables.MMEPositionsFields.LAST_CHANGE_TEXT:
+                                                        lastChangeText = Convert.ToString(o);
+                                                        break;
+                                                    case DbOperations.MMETables.MMEPositionsFields.POSITION:
+                                                        position = Convert.ToString(o);
+                                                        break;
+                                                    case DbOperations.MMETables.MMEPositionsFields.REMARKS:
+                                                        remarks = Convert.ToString(o);
+                                                        break;
+                                                    case DbOperations.MMETables.MMEPositionsFields.s_GUID:
+                                                        sGuid = Convert.ToString(o);
+                                                        break;
+                                                    case DbOperations.MMETables.MMEPositionsFields.SORTKEY:
+                                                        sortKey = Convert.ToString(o);
+                                                        break;
+                                                    case DbOperations.MMETables.MMEPositionsFields.TEXT_L1:
+                                                        text1 = Convert.ToString(o);
+                                                        break;
+                                                    case DbOperations.MMETables.MMEPositionsFields.TEXT_L2:
+                                                        text2 = Convert.ToString(o);
+                                                        break;
+                                                    case DbOperations.MMETables.MMEPositionsFields.VERSION:
+                                                        version = Convert.ToInt32(o);
+                                                        break;
+                                                }
+                                            }
+                                            catch (Exception) 
+                                            {
+                                                //ignore
+                                            }
+                                        }
+                                        positions.Add(new MMEPositions(sGuid.ToString(), position, text1, text2, Convert.ToInt64(version), date, remarks, expired,
+                                            sortKey, lastChange, lastChangeText, history, MMEPossibleChannels.MMEChannelTypes.SQL));
+                                    }
+                                }
+                            }
+                        }
+                        finally
+                        {
+                            cmd.Connection.Dispose();
+                        }
+                    }
+                }
+                catch (Exception) 
+                {
+                    //ignore
+                }
+            }
+            catch (Exception)
+            {
+                //ignore
+            }
+            return positions.ToArray();
+        }
+    }
+}

DataPRO/Modules/PreviousDBVersions/Version57/DatabaseExport/ISO/MMEPossibleChannels.cs

@@ -0,0 +1,305 @@
+using System;
+using System.Collections.Generic;
+using System.Data;
+using System.Data.OleDb;
+
+namespace DatabaseExport
+{
+    /// <summary>
+    /// this is a "possible" channel, once we know what iso object we are dealing with there can be a number of channels
+    /// defined for the object.  We might not care about all of them ...
+    /// this is also a template channel, in that some fields will not be known yet (direction, dimension maybe, position, etc)
+    /// TestObjectChannel will consume this channel and then allow setting the locations as needed
+    /// </summary>
+    public class MMEPossibleChannels : AbstractOLEDbWrapper
+    {
+        public long Id { get; private set; }
+
+        public void ClearId() { Id = -1; }
+        public void SetId(long id) { Id = id; }
+
+        public string Type { get; private set; }
+
+        public void SetType(string type) { Type = type; }
+
+        public string Test_Object { get; private set; }
+
+        public void Set_Test_Object(string val)
+        {
+            Test_Object = val;
+        }
+
+        public string Position { get; private set; }
+
+        public void Set_Position(string val)
+        {
+            Position = val;
+        }
+
+        public string Trans_Main_Loc { get; private set; }
+
+        public void Set_Main_Loc(string val)
+        {
+            Trans_Main_Loc = val;
+        }
+
+        public string Fine_Loc_1 { get; private set; }
+
+        /// <summary>
+        /// Sets the fine location 1
+        /// the property doesn't seem to have a set
+        /// so not sure if it was omitted or on purpose
+        /// See all othe "Set_*" functions
+        /// </summary>
+        /// <param name="val"></param>
+        public void Set_Fine_Loc_1(string val)
+        {
+            Fine_Loc_1 = val;
+        }
+
+
+        public string Fine_Loc_2 { get; private set; }
+
+        public void Set_Fine_Loc_2(string val)
+        {
+            Fine_Loc_2 = val;
+        }
+
+        public string Fine_Loc_3 { get; private set; }
+
+        public void Set_Fine_Loc_3(string val)
+        {
+            Fine_Loc_3 = val;
+        }
+
+        public string Physical_Dimension { get; private set; }
+
+        public void Set_Physical_Dimension(string val)
+        {
+            Physical_Dimension = val;
+        }
+
+        public string Direction { get; private set; }
+
+        public void Set_Direction(string val)
+        {
+            Direction = val;
+        }
+
+        public string Default_Filter_Class { get; private set; }
+
+        public void Set_Default_Filter_Class(string val)
+        {
+            Default_Filter_Class = val;
+        }
+
+        public string Text_L1 { get; private set; }
+
+        public void SetText1(string text1) { Text_L1 = text1; }
+
+        public string Text_L2 { get; private set; }
+
+        public void SetText2(string text2) { Text_L2 = text2; }
+
+        public long Version { get; }
+
+        public DateTime Date { get; }
+
+        public string Remarks { get; private set; }
+
+        public void SetRemarks(string remarks) { Remarks = remarks; }
+
+        public bool Expired { get; }
+
+        public string SortKey { get; }
+
+        public string Picture_ShortName { get; }
+
+        public DateTime Last_Change { get; }
+
+        public string Last_Change_Text { get; }
+
+        public string History { get; }
+
+        public int MMEChannelType { get; }
+
+        public MMEPossibleChannels(MMEPossibleChannels copy)
+        {
+            Id = copy.Id;
+            Type = copy.Type;
+            Test_Object = copy.Test_Object;
+            Position = copy.Position;
+            Trans_Main_Loc = copy.Trans_Main_Loc;
+            Fine_Loc_1 = copy.Fine_Loc_1;
+            Fine_Loc_2 = copy.Fine_Loc_2;
+            Fine_Loc_3 = copy.Fine_Loc_3;
+            Physical_Dimension = copy.Physical_Dimension;
+            Direction = copy.Direction;
+            Default_Filter_Class = copy.Default_Filter_Class;
+            Text_L1 = copy.Text_L1;
+            Text_L2 = copy.Text_L2;
+            Version = copy.Version;
+            Date = copy.Date;
+            Remarks = copy.Remarks;
+            Expired = copy.Expired;
+            SortKey = copy.SortKey;
+            Picture_ShortName = copy.Picture_ShortName;
+            Last_Change = copy.Last_Change;
+            Last_Change_Text = copy.Last_Change_Text;
+            History = copy.History;
+            MMEChannelType = copy.MMEChannelType;
+        }
+        public MMEPossibleChannels(long id, string type, string textObject, string position, string transMainLoc,
+            string fineLoc1, string fineLoc2, string fineLoc3, string physicalDimension, string direction, string defaultFilterClass,
+            string textL1, string textL2, long version, DateTime date, string remarks, bool expired, string sortkey,
+            string pictureShortName, DateTime lastChange, string lastChangeText, string history, int mmeChannelType)
+        {
+            Id = id;
+            Type = type;
+            Test_Object = textObject;
+            Position = position;
+            Trans_Main_Loc = transMainLoc;
+            Fine_Loc_1 = fineLoc1;
+            Fine_Loc_2 = fineLoc2;
+            Fine_Loc_3 = fineLoc3;
+            Physical_Dimension = physicalDimension;
+            Direction = direction;
+            Default_Filter_Class = defaultFilterClass;
+            Text_L1 = textL1;
+            Text_L2 = textL2;
+            Version = version;
+            Date = date;
+            Remarks = remarks;
+            Expired = expired;
+            SortKey = sortkey;
+            Picture_ShortName = pictureShortName;
+            Last_Change = lastChange;
+            Last_Change_Text = lastChangeText;
+            History = history;
+            MMEChannelType = mmeChannelType;
+        }
+        public enum MMEChannelTypes
+        {
+            ISO13499_106,
+            SQL
+        }
+        public static MMEPossibleChannels[] GetPossibleChannels()
+        {
+            var possibleChannels = new List<MMEPossibleChannels>();
+            try
+            {
+                using (var cmd = DbOperations.GetISOCommand())
+                {
+                    cmd.CommandText = "SELECT * FROM MMEPossibleChannels";
+                    cmd.CommandType = CommandType.Text;
+                    try
+                    {
+                        using (var ISOReader = cmd.ExecuteReader())
+                        {
+                            while (ISOReader.Read())
+                            {
+                                try
+                                {
+                                    long id = GetLong(ISOReader, "ID");
+                                    string type = ISOReader["TYPE"].ToString();
+                                    string testObject = ISOReader["TEST_OBJECT"].ToString();
+                                    string position = ISOReader["POSITION"].ToString();
+                                    string transMainLoc = ISOReader["TRANS_MAIN_LOC"].ToString();
+                                    string fineLoc1 = ISOReader["FINE_LOC_1"].ToString();
+                                    string fineLoc2 = ISOReader["FINE_LOC_2"].ToString();
+                                    string fineLoc3 = ISOReader["FINE_LOC_3"].ToString();
+                                    string physicalDimension = ISOReader["PHYSICAL_DIMENSION"].ToString();
+                                    string direction = ISOReader["DIRECTION"].ToString();
+                                    string defaultFilterClass = ISOReader["DEFAULT_FILTER_CLASS"].ToString();
+                                    string textL1 = ISOReader["TEXT_L1"].ToString();
+                                    string textL2 = ISOReader["TEXT_L2"].ToString();
+                                    long version = GetLong(ISOReader, "VERSION");
+                                    DateTime date = GetDate(ISOReader, "DATE");
+                                    string remarks = ISOReader["REMARKS"].ToString();
+                                    bool expired = (bool)ISOReader["EXPIRED"];
+                                    string sortkey = ISOReader["SORTKEY"].ToString();
+                                    string pictureShortName = ISOReader["PICTURE_SHORTNAME"].ToString();
+                                    DateTime lastChange = GetDate(ISOReader, "LAST_CHANGE");
+                                    string lastChangeText = ISOReader["LAST_CHANGE_TEXT"].ToString();
+                                    string history = ISOReader["HISTORY"].ToString();
+
+                                    possibleChannels.Add(new MMEPossibleChannels(id, type, testObject, position,
+                                        transMainLoc, fineLoc1, fineLoc2,
+                                        fineLoc3, physicalDimension, direction, defaultFilterClass, textL1, textL2,
+                                        version, date, remarks, expired, sortkey, pictureShortName, lastChange,
+                                        lastChangeText, history, (int)MMEChannelTypes.ISO13499_106));
+                                }
+                                catch (Exception)
+                                {
+                                    //ignore
+                                }
+                            }
+                        }
+                    }
+                    finally
+                    {
+                        cmd.Connection.Dispose();
+                    }
+                }
+                try
+                {
+                    using (var cmd = DbOperations.GetCommand())
+                    {
+                        try
+                        {
+                            cmd.CommandText = "SELECT * from [tblMMEPossibleChannels]";
+                            using (var ds = DbOperations.Connection.QueryDataSet(cmd))
+                            {
+                                if (ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0)
+                                {
+                                    foreach (System.Data.DataRow dr in ds.Tables[0].Rows)
+                                    {
+                                        var id = Convert.ToInt64(dr["ID"]);
+                                        var type = Convert.ToString(dr["TYPE"]);
+                                        var testobject = Convert.ToString(dr["TEST_OBJECT"]);
+                                        var position = Convert.ToString(dr["POSITION"]);
+                                        var mainloc = Convert.ToString(dr["TRANS_MAIN_LOC"]);
+                                        var fineloc1 = Convert.ToString(dr["FINE_LOC_1"]);
+                                        var fineloc2 = Convert.ToString(dr["FINE_LOC_2"]);
+                                        var fineloc3 = Convert.ToString(dr["FINE_LOC_3"]);
+                                        var dimension = Convert.ToString(dr["PHYSICAL_DIMENSION"]);
+                                        var direction = Convert.ToString(dr["DIRECTION"]);
+                                        var filter = Convert.ToString(dr["DEFAULT_FILTER_CLASS"]);
+                                        var textL1 = Convert.ToString(dr["TEXT_L1"]);
+                                        var textL2 = Convert.ToString(dr["TEXT_L2"]);
+                                        var version = Convert.ToInt32(dr["VERSION"]);
+                                        var date = Convert.ToDateTime(dr["DATE"]);
+                                        var remarks = Convert.ToString(dr["REMARKS"]);
+                                        var expired = Convert.ToBoolean(dr["EXPIRED"]);
+                                        var sortkey = Convert.ToString(dr["SORTKEY"]);
+                                        var pictureShortName = Convert.ToString(dr["PICTURE_SHORTNAME"]);
+                                        var lastChange = Convert.ToDateTime(dr["LAST_CHANGE"]);
+                                        var lastChangeText = Convert.ToString(dr["LAST_CHANGE_TEXT"]);
+                                        var history = Convert.ToString(dr["HISTORY"]);
+                                        possibleChannels.Add(new MMEPossibleChannels(id, type, testobject, position, mainloc, fineloc1, fineloc2,
+                                            fineloc3, dimension, direction, filter, textL1, textL2,
+                                            Convert.ToInt64(version), date, remarks, expired, sortkey, pictureShortName, lastChange, lastChangeText, history, (int)MMEChannelTypes.SQL));
+                                    }
+                                }
+                            }
+                        }
+                        finally
+                        {
+                            cmd.Connection.Dispose();
+                        }
+                    }
+                }
+                catch (Exception) 
+                {
+                    //ignore
+                }
+
+            }
+            catch (Exception)
+            {
+                //ignore
+            }
+            return possibleChannels.ToArray();
+        }
+    }
+}

DataPRO/Modules/PreviousDBVersions/Version57/DatabaseExport/ISO/MMETestObjects.cs

@@ -0,0 +1,341 @@
+using System;
+using System.Collections.Generic;
+using System.Data;
+using System.Linq;
+using System.Data.OleDb;
+
+namespace DatabaseExport
+{
+    /// <summary>
+    /// a test object is a top level object in the ISO database
+    /// given a test object, it is possible to find all possible channels as defined in ISO
+    /// note there is a ? test object ...
+    /// I'll use these to build templates
+    /// </summary>
+    public class MMETestObjects : AbstractOLEDbWrapper
+    {
+        public string S_GUID { get; }
+
+        public string Test_Object { get; }
+
+        public string Text_L1 { get; }
+
+        public string Text_L2 { get; }
+
+        public long Version { get; }
+
+        public DateTime Date { get; }
+
+        public string Remarks { get; }
+
+        public bool Expired { get; }
+
+        public string SortKey { get; }
+
+        public DateTime Last_Change { get; }
+
+        public string Last_Change_Text { get; }
+
+        public string History { get; }
+
+        public MMEPossibleChannels.MMEChannelTypes RecordType { get; } = MMEPossibleChannels.MMEChannelTypes.ISO13499_106;
+
+        public MMETestObjects(string sGuid, string testObject, string textL1, string textL2, long version,
+            DateTime date, string remarks, bool expired, string sortkey, DateTime lastChange, string lastChangeText,
+            string history, MMEPossibleChannels.MMEChannelTypes type)
+        {
+            RecordType = type;
+            S_GUID = sGuid;
+            Test_Object = testObject;
+            Text_L1 = textL1;
+            Text_L2 = textL2;
+            Version = version;
+            Date = date;
+            Remarks = remarks;
+            Expired = expired;
+            SortKey = sortkey;
+            Last_Change = lastChange;
+            Last_Change_Text = lastChangeText;
+            History = history;
+        }
+        public static MMETestObjects GetTestObject(OleDbConnection connection, string sGUID)
+        {
+            var testObjects = new List<MMETestObjects>();
+            try
+            {
+                using (var command = new OleDbCommand())
+                {
+                    command.Connection = connection;
+                    var param = new OleDbParameter("@SGuid", sGUID);
+                    command.Parameters.Add(param);
+                    command.CommandText = "SELECT * from [MME_TEST_OBJECTS] WHERE [s_GUID]=@SGuid";
+
+                    using (var reader = command.ExecuteReader())
+                    {
+                        while (reader.Read())
+                        {
+                            var sGuid = reader["s_GUID"].ToString();
+                            var testObject = reader["TEST_OBJECT"].ToString();
+                            var textL1 = reader["TEXT_L1"].ToString();
+                            var textL2 = reader["TEXT_L2"].ToString();
+                            var version = AbstractOLEDbWrapper.GetLong(reader, "VERSION");
+                            var date = (DateTime)reader["DATE"];
+                            var remarks = reader["REMARKS"].ToString();
+                            var expired = (bool)reader["EXPIRED"];
+                            var sortkey = reader["SORTKEY"].ToString();
+                            var lastChange = AbstractOLEDbWrapper.GetDate(reader, "LAST_CHANGE");
+                            var lastChangeText = reader["LAST_CHANGE_TEXT"].ToString();
+                            var history = reader["HISTORY"].ToString();
+                            testObjects.Add(new MMETestObjects(sGuid, testObject, textL1, textL2, version, date, remarks, expired,
+                                sortkey, lastChange, lastChangeText, history, MMEPossibleChannels.MMEChannelTypes.ISO13499_106));
+                        }
+                    }
+                }
+                long l;
+                if (long.TryParse(sGUID, out l))
+                {
+                    using (var cmd = DbOperations.GetCommand())
+                    {
+                        cmd.CommandText = string.Format("SELECT * from {0} where {1}=@{1}", DbOperations.MMETables.MMETestObjectsTable,
+                            DbOperations.MMETables.MMETestObjectsFields.s_GUID.ToString());
+                        DbOperations.CreateParam(cmd, string.Format("@{0}", DbOperations.MMETables.MMETestObjectsFields.s_GUID.ToString()),
+                            System.Data.SqlDbType.BigInt, l);
+                        using (var ds = DbOperations.Connection.QueryDataSet(cmd))
+                        {
+                            if (ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0)
+                            {
+                                var fields = Enum.GetValues(typeof(DbOperations.MMETables.MMETestObjectsFields))
+                                    .Cast<DbOperations.MMETables.MMETestObjectsFields>().ToArray();
+                                foreach (System.Data.DataRow dr in ds.Tables[0].Rows)
+                                {
+                                    var version = 0;
+                                    var text2 = "";
+                                    var text1 = "";
+                                    var testObject = "?";
+                                    var sortkey = "";
+                                    var remarks = "";
+                                    var lastChangeText = "";
+                                    var lastChange = DateTime.Now;
+                                    var history = "";
+                                    var expired = false;
+                                    var date = DateTime.Now;
+                                    foreach (var field in fields)
+                                    {
+                                        try
+                                        {
+                                            if (DBNull.Value.Equals(dr[field.ToString()])) { continue; }
+
+                                            var o = dr[field.ToString()];
+                                            switch (field)
+                                            {
+                                                case DbOperations.MMETables.MMETestObjectsFields.DATE:
+                                                    date = Convert.ToDateTime(o);
+                                                    break;
+                                                case DbOperations.MMETables.MMETestObjectsFields.EXPIRED:
+                                                    expired = Convert.ToBoolean(o);
+                                                    break;
+                                                case DbOperations.MMETables.MMETestObjectsFields.HISTORY:
+                                                    history = Convert.ToString(o);
+                                                    break;
+                                                case DbOperations.MMETables.MMETestObjectsFields.LAST_CHANGE:
+                                                    lastChange = Convert.ToDateTime(o);
+                                                    break;
+                                                case DbOperations.MMETables.MMETestObjectsFields.LAST_CHANGE_TEXT:
+                                                    lastChangeText = Convert.ToString(o);
+                                                    break;
+                                                case DbOperations.MMETables.MMETestObjectsFields.REMARKS:
+                                                    remarks = Convert.ToString(o);
+                                                    break;
+                                                case DbOperations.MMETables.MMETestObjectsFields.s_GUID:
+                                                    //this was part of the where ... we don't need it
+                                                    break;
+                                                case DbOperations.MMETables.MMETestObjectsFields.SORTKEY:
+                                                    sortkey = Convert.ToString(sortkey);
+                                                    break;
+                                                case DbOperations.MMETables.MMETestObjectsFields.TEST_OBJECT:
+                                                    testObject = Convert.ToString(o);
+                                                    break;
+                                                case DbOperations.MMETables.MMETestObjectsFields.TEXT_L1:
+                                                    text1 = Convert.ToString(o);
+                                                    break;
+                                                case DbOperations.MMETables.MMETestObjectsFields.TEXT_L2:
+                                                    text2 = Convert.ToString(o);
+                                                    break;
+                                                case DbOperations.MMETables.MMETestObjectsFields.VERSION:
+                                                    version = Convert.ToInt32(o);
+                                                    break;
+                                            }
+                                        }
+                                        catch (Exception) 
+                                        {
+                                            //ignore
+                                        }
+                                    }
+                                    testObjects.Add(new MMETestObjects(sGUID, testObject, text1, text2, Convert.ToInt64(version), date, remarks, expired, sortkey,
+                                        lastChange, lastChangeText, history, MMEPossibleChannels.MMEChannelTypes.SQL));
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            catch (Exception)
+            {
+                //ignore
+            }
+            if (testObjects.Count > 0) { return testObjects[0]; }
+            else { return null; }
+        }
+        public static MMETestObjects[] GetTestObjects()
+        {
+            var testObjects = new List<MMETestObjects>();
+            try
+            {
+                using (var cmd = DbOperations.GetISOCommand())
+                {
+                    cmd.CommandText = "SELECT * FROM MMETestObjects";
+                    cmd.CommandType = CommandType.Text;
+                    try
+                    {
+                        using (var ISOReader = cmd.ExecuteReader())
+                        {
+                            while (ISOReader.Read())
+                            {
+                                try
+                                {
+                                    string sGuid = ISOReader["s_GUID"].ToString();
+                                    string testObject = ISOReader["TEST_OBJECT"].ToString();
+                                    string textL1 = ISOReader["TEXT_L1"].ToString();
+                                    string textL2 = ISOReader["TEXT_L2"].ToString();
+                                    long version = GetLong(ISOReader, "VERSION");
+                                    DateTime date = (DateTime)ISOReader["DATE"];
+                                    string remarks = ISOReader["REMARKS"].ToString();
+                                    bool expired = (bool)ISOReader["EXPIRED"];
+                                    string sortkey = ISOReader["SORTKEY"].ToString();
+                                    DateTime lastChange = GetDate(ISOReader, "LAST_CHANGE");
+                                    string lastChangeText = ISOReader["LAST_CHANGE_TEXT"].ToString();
+                                    string history = ISOReader["HISTORY"].ToString();
+                                    testObjects.Add(new MMETestObjects(sGuid, testObject, textL1, textL2, version, date, remarks, expired,
+                                        sortkey, lastChange, lastChangeText, history, MMEPossibleChannels.MMEChannelTypes.ISO13499_106));
+                                }
+                                catch (Exception)
+                                {
+                                    //ignore
+                                }
+                            }
+                        }
+                    }
+                    finally
+                    {
+                        cmd.Connection.Dispose();
+                    }
+                }
+                try
+                {
+                    using (var cmd = DbOperations.GetCommand())
+                    {
+                        try
+                        {
+                            cmd.CommandText = string.Format("SELECT * FROM {0}", DbOperations.MMETables.MMETestObjectsTable);
+                            using (var ds = DbOperations.Connection.QueryDataSet(cmd))
+                            {
+                                if (ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0)
+                                {
+                                    var fields = Enum.GetValues(typeof(DbOperations.MMETables.MMETestObjectsFields))
+                                        .Cast<DbOperations.MMETables.MMETestObjectsFields>().ToArray();
+                                    foreach (System.Data.DataRow dr in ds.Tables[0].Rows)
+                                    {
+                                        var version = 0;
+                                        var text2 = "";
+                                        var text1 = "";
+                                        var textObject = "?";
+                                        var sortKey = "";
+                                        var sGuid = "";
+                                        var remarks = "";
+                                        var lastChangeText = "";
+                                        var lastChange = DateTime.Now;
+                                        var history = "";
+                                        var expired = false;
+                                        var date = DateTime.Now;
+
+                                        foreach (var field in fields)
+                                        {
+                                            try
+                                            {
+                                                if (DBNull.Value.Equals(dr[field.ToString()]))
+                                                {
+                                                    continue;
+                                                }
+                                                var o = dr[field.ToString()];
+
+                                                switch (field)
+                                                {
+                                                    case DbOperations.MMETables.MMETestObjectsFields.DATE:
+                                                        date = Convert.ToDateTime(o);
+                                                        break;
+                                                    case DbOperations.MMETables.MMETestObjectsFields.EXPIRED:
+                                                        expired = Convert.ToBoolean(o);
+                                                        break;
+                                                    case DbOperations.MMETables.MMETestObjectsFields.HISTORY:
+                                                        history = Convert.ToString(o);
+                                                        break;
+                                                    case DbOperations.MMETables.MMETestObjectsFields.LAST_CHANGE:
+                                                        lastChange = Convert.ToDateTime(o);
+                                                        break;
+                                                    case DbOperations.MMETables.MMETestObjectsFields.LAST_CHANGE_TEXT:
+                                                        lastChangeText = Convert.ToString(o);
+                                                        break;
+                                                    case DbOperations.MMETables.MMETestObjectsFields.REMARKS:
+                                                        remarks = Convert.ToString(o);
+                                                        break;
+                                                    case DbOperations.MMETables.MMETestObjectsFields.s_GUID:
+                                                        sGuid = Convert.ToString(o);
+                                                        break;
+                                                    case DbOperations.MMETables.MMETestObjectsFields.SORTKEY:
+                                                        sortKey = Convert.ToString(o);
+                                                        break;
+                                                    case DbOperations.MMETables.MMETestObjectsFields.TEST_OBJECT:
+                                                        textObject = Convert.ToString(o);
+                                                        break;
+                                                    case DbOperations.MMETables.MMETestObjectsFields.TEXT_L1:
+                                                        text1 = Convert.ToString(o);
+                                                        break;
+                                                    case DbOperations.MMETables.MMETestObjectsFields.TEXT_L2:
+                                                        text2 = Convert.ToString(o);
+                                                        break;
+                                                    case DbOperations.MMETables.MMETestObjectsFields.VERSION:
+                                                        version = Convert.ToInt32(o);
+                                                        break;
+                                                }
+                                            }
+                                            catch (Exception) 
+                                            {
+                                                //ignore
+                                            }
+                                        }
+                                        testObjects.Add(new MMETestObjects(sGuid.ToString(), textObject, text1, text2, Convert.ToInt64(version), date, remarks, expired, sortKey,
+                                            lastChange, lastChangeText, history, MMEPossibleChannels.MMEChannelTypes.SQL));
+                                    }
+                                }
+                            }
+                        }
+                        finally
+                        {
+                            cmd.Connection.Dispose();
+                        }
+                    }
+                }
+                catch (Exception) 
+                {
+                    //ignore
+                }
+
+            }
+            catch (Exception)
+            {
+                //ignore
+            }
+            return testObjects.ToArray();
+        }
+    }
+}

DataPRO/Modules/PreviousDBVersions/Version57/DatabaseExport/ISO/MMETransducerMainLocation.cs

@@ -0,0 +1,219 @@
+using System;
+using System.Collections.Generic;
+using System.Data;
+using System.Linq;
+using System.Data.OleDb;
+
+namespace DatabaseExport
+{
+    public class MMETransducerMainLocation : AbstractOLEDbWrapper
+    {
+        public string S_GUID { get; }
+
+        public string Type { get; }
+
+        public string Trans_Main_Loc { get; }
+
+        public string Text_L1 { get; }
+
+        public string Text_L2 { get; }
+
+        public long Version { get; }
+
+        public DateTime Date { get; }
+
+        public string Remarks { get; }
+
+        public bool Expired { get; }
+
+        public string SortKey { get; }
+
+        public string Picture_ShortName { get; }
+
+        public DateTime Last_Change { get; }
+
+        public string Last_Change_Text { get; }
+
+        public string History { get; }
+
+        public MMEPossibleChannels.MMEChannelTypes RecordType { get; }
+
+        public MMETransducerMainLocation(string sGuid, string type, string transMainLoc, string textL1, string textL2,
+            long version, DateTime date, string remarks, bool expired, string sortkey, string pictureShortName,
+            DateTime lastChange, string lastChangeText, string history, MMEPossibleChannels.MMEChannelTypes recordType)
+        {
+            RecordType = recordType;
+            S_GUID = sGuid;
+            Type = type;
+            Trans_Main_Loc = transMainLoc;
+            Text_L1 = textL1;
+            Text_L2 = textL2;
+            Version = version;
+            Date = date;
+            Remarks = remarks;
+            Expired = expired;
+            SortKey = sortkey;
+            Picture_ShortName = pictureShortName;
+            Last_Change = lastChange;
+            Last_Change_Text = lastChangeText;
+            History = history;
+        }
+        public static MMETransducerMainLocation[] GetTransducerMainLocations()
+        {
+            var transducerMainLocations = new List<MMETransducerMainLocation>();
+            try
+            {
+                using (var cmd = DbOperations.GetISOCommand())
+                {
+                    cmd.CommandText = "SELECT * FROM MMEMainLocations";
+                    cmd.CommandType = CommandType.Text;
+                    try
+                    {
+                        using (var ISOReader = cmd.ExecuteReader())
+                        {
+                            while (ISOReader.Read())
+                            {
+                                try
+                                {
+                                    string sGuid = ISOReader["s_GUID"].ToString();
+                                    string type = ISOReader["TYPE"].ToString();
+                                    string transMainLoc = ISOReader["TRANS_MAIN_LOC"].ToString();
+                                    string textL1 = ISOReader["TEXT_L1"].ToString();
+                                    string textL2 = ISOReader["TEXT_L2"].ToString();
+                                    long version = GetLong(ISOReader, "VERSION");
+                                    DateTime date = GetDate(ISOReader, "DATE");
+                                    string remarks = ISOReader["REAMRKS"].ToString();
+                                    bool expired = (bool)ISOReader["EXPIRED"];
+                                    string sortkey = ISOReader["SORTKEY"].ToString();
+                                    string pictureShortName = ISOReader["PICTURE_SHORTNAME"].ToString();
+                                    DateTime lastChange = GetDate(ISOReader, "LAST_CHANGE");
+                                    string lastChangeText = ISOReader["LAST_CHANGE_TEXT"].ToString();
+                                    string history = ISOReader["HISTORY"].ToString();
+                                    transducerMainLocations.Add(new MMETransducerMainLocation(sGuid, type, transMainLoc, textL1, textL2, version,
+                                        date, remarks, expired, sortkey, pictureShortName, lastChange, lastChangeText, history, MMEPossibleChannels.MMEChannelTypes.ISO13499_106));
+                                }
+                                catch (Exception)
+                                {
+                                    //ignore
+                                }
+                            }
+                        }
+                    }
+                    finally
+                    {
+                        cmd.Connection.Dispose();
+                    }
+                }
+                try
+                {
+                    using (var cmd = DbOperations.GetCommand())
+                    {
+                        try
+                        {
+                            cmd.CommandText = string.Format("SELECT * FROM {0}", DbOperations.MMETables.MMEMainLocationTable);
+                            using (var ds = DbOperations.Connection.QueryDataSet(cmd))
+                            {
+                                if (ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0)
+                                {
+                                    var fields = Enum.GetValues(typeof(DbOperations.MMETables.MMEMainLocationsFields))
+                                        .Cast<DbOperations.MMETables.MMEMainLocationsFields>().ToArray();
+                                    foreach (System.Data.DataRow dr in ds.Tables[0].Rows)
+                                    {
+                                        var date = DateTime.Now;
+                                        var expired = false;
+                                        var history = "";
+                                        var lastChange = DateTime.Now;
+                                        var lastChangeText = "";
+                                        var pictureShortName = "";
+                                        var remarks = "";
+                                        var guid = "";
+                                        var sortkey = "";
+                                        var text1 = "";
+                                        var text2 = "";
+                                        var mainLoc = "????";
+                                        var type = "";
+                                        var version = 0;
+                                        foreach (var field in fields)
+                                        {
+                                            try
+                                            {
+                                                var o = dr[field.ToString()];
+                                                if (DBNull.Value.Equals(o)) { continue; }
+
+                                                switch (field)
+                                                {
+                                                    case DbOperations.MMETables.MMEMainLocationsFields.DATE:
+                                                        date = Convert.ToDateTime(o);
+                                                        break;
+                                                    case DbOperations.MMETables.MMEMainLocationsFields.EXPIRED:
+                                                        expired = Convert.ToBoolean(o);
+                                                        break;
+                                                    case DbOperations.MMETables.MMEMainLocationsFields.HISTORY:
+                                                        history = Convert.ToString(o);
+                                                        break;
+                                                    case DbOperations.MMETables.MMEMainLocationsFields.LAST_CHANGE:
+                                                        lastChange = Convert.ToDateTime(o);
+                                                        break;
+                                                    case DbOperations.MMETables.MMEMainLocationsFields.LAST_CHANGE_TEXT:
+                                                        lastChangeText = Convert.ToString(o);
+                                                        break;
+                                                    case DbOperations.MMETables.MMEMainLocationsFields.PICTURE_SHORTNAME:
+                                                        pictureShortName = Convert.ToString(o);
+                                                        break;
+                                                    case DbOperations.MMETables.MMEMainLocationsFields.REMARKS:
+                                                        remarks = Convert.ToString(o);
+                                                        break;
+                                                    case DbOperations.MMETables.MMEMainLocationsFields.s_GUID:
+                                                        guid = Convert.ToString(o);
+                                                        break;
+                                                    case DbOperations.MMETables.MMEMainLocationsFields.SORTKEY:
+                                                        sortkey = Convert.ToString(o);
+                                                        break;
+                                                    case DbOperations.MMETables.MMEMainLocationsFields.TEXT_L1:
+                                                        text1 = Convert.ToString(o);
+                                                        break;
+                                                    case DbOperations.MMETables.MMEMainLocationsFields.TEXT_L2:
+                                                        text2 = Convert.ToString(o);
+                                                        break;
+                                                    case DbOperations.MMETables.MMEMainLocationsFields.TRANS_MAIN_LOC:
+                                                        mainLoc = Convert.ToString(o);
+                                                        break;
+                                                    case DbOperations.MMETables.MMEMainLocationsFields.TYPE:
+                                                        type = Convert.ToString(o);
+                                                        break;
+                                                    case DbOperations.MMETables.MMEMainLocationsFields.VERSION:
+                                                        version = Convert.ToInt32(o);
+                                                        break;
+                                                }
+                                            }
+                                            catch (Exception) 
+                                            {
+                                                //ignore
+                                            }
+                                        }
+                                        transducerMainLocations.Add(new MMETransducerMainLocation(guid.ToString(), type, mainLoc, text1, text2, Convert.ToInt64(version),
+                                            date, remarks, expired, sortkey, pictureShortName, lastChange, lastChangeText, history, MMEPossibleChannels.MMEChannelTypes.SQL));
+                                    }
+                                }
+                            }
+                        }
+                        finally
+                        {
+                            cmd.Connection.Dispose();
+                        }
+                    }
+                }
+                catch (Exception) 
+                {
+                    //ignore
+                }
+
+            }
+            catch (Exception)
+            {
+                //ignore
+            }
+            return transducerMainLocations.ToArray();
+        }
+    }
+}

DataPRO/Modules/PreviousDBVersions/Version57/DatabaseExport/ISO/TemplateRegion.cs

@@ -0,0 +1,123 @@
+using System;
+using System.Collections.Generic;
+using System.Data;
+
+namespace DatabaseExport
+{
+    public class TemplateRegion
+    {
+        public string TemplateName { get; }
+
+        public string TemplateZone { get; }
+
+        public int RegionNumber { get; set; }
+
+        public string RegionName { get; set; }
+
+        public string RegionDescription { get; set; }
+
+        public string TestObject { get; set; }
+
+        public string Position { get; set; }
+
+        public string MainLocation { get; set; }
+
+        public string FineLocation1 { get; set; }
+
+        public string FineLocation2 { get; set; }
+
+        public string FineLocation3 { get; set; }
+
+        public string PhysicalDimension { get; set; }
+
+        public string Direction { get; set; }
+
+        public string FilterClass { get; set; }
+
+        public bool LocalOnly { get; } = false;
+
+        private int _upperLeftX = 0;
+        private int _upperLeftY = 0;
+        private int _lowerRightX = 0;
+        private int _lowerRightY = 0;
+
+        public System.Drawing.Point UpperLeft
+        {
+            get => new System.Drawing.Point(_upperLeftX, _upperLeftY);
+            set { _upperLeftX = value.X; _upperLeftY = value.Y; }
+        }
+
+        public System.Drawing.Point LowerRight
+        {
+            get => new System.Drawing.Point(_lowerRightX, _lowerRightY);
+            set { _lowerRightX = value.X; _lowerRightY = value.Y; }
+        }
+
+        public TemplateRegion(string templateName, string zoneName, bool bLocalOnly)
+        {
+            TemplateName = templateName;
+            TemplateZone = zoneName;
+            LocalOnly = bLocalOnly;
+        }
+
+        public TemplateRegion(DataRow dr)
+        {
+            TemplateName = (string)dr["TemplateName"];
+            RegionNumber = Convert.ToInt32(dr["RegionNumber"]);
+            RegionName = (string)dr["RegionName"];
+            RegionDescription = (string)dr["RegionDescription"];
+            TestObject = (string)dr["TestObject"];
+            Position = (string)dr["Position"];
+            MainLocation = (string)dr["MainLocation"];
+            FineLocation1 = (string)dr["FineLocation1"];
+            FineLocation2 = (string)dr["FineLocation2"];
+            FineLocation3 = (string)dr["FineLocation3"];
+            PhysicalDimension = (string)dr["PhysicalDimension"];
+            Direction = (string)dr["Direction"];
+            FilterClass = (string)dr["FilterClass"];
+            LocalOnly = Convert.ToBoolean(dr["LocalOnly"]);
+            _upperLeftX = Convert.ToInt32(dr["UpperLeftX"]);
+            _upperLeftY = Convert.ToInt32(dr["UpperLeftY"]);
+            _lowerRightX = Convert.ToInt32(dr["LowerRightX"]);
+            _lowerRightY = Convert.ToInt32(dr["LowerRightY"]);
+            TemplateZone = (string)dr["ZoneName"];
+        }
+
+        internal static TemplateRegion[] GetAllRegions(string templateName, string zoneName)
+        {
+            var regions = new List<TemplateRegion>();
+            try
+            {
+                using (var sql = DbOperations.GetCommand())
+                {
+                    DbOperations.CreateParam(sql, "@TemplateName", SqlDbType.NVarChar, templateName);
+                    DbOperations.CreateParam(sql, "@ZoneName", SqlDbType.NVarChar, zoneName);
+
+                    sql.CommandText = "SELECT * from tblTemplateRegions where [TemplateName]=@TemplateName and [ZoneName]=@ZoneName";
+                    using (var ds = DbOperations.Connection.QueryDataSet(sql))
+                    {
+                        if (ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0)
+                        {
+                            foreach (DataRow dr in ds.Tables[0].Rows)
+                            {
+                                try
+                                {
+                                    regions.Add(new TemplateRegion(dr));
+                                }
+                                catch (Exception)
+                                {
+                                    //DTS.Utilities.Logging.APILogger.Log("Failed to retrieve a region", templateName, ex2);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            catch (Exception)
+            {
+                //DTS.Utilities.Logging.APILogger.Log("Failed to retrieve regions", templateName, ex);
+            }
+            return regions.ToArray();
+        }
+    }
+}

DataPRO/Modules/PreviousDBVersions/Version57/DatabaseExport/ISO/TemplateZone.cs

@@ -0,0 +1,41 @@
+using System;
+using System.Collections.Generic;
+
+namespace DatabaseExport
+{
+    public class TemplateZone
+    {
+        public string TemplateName { get; }
+
+        public string ZoneName { get; } = "";
+
+        public string Picture { get; set; }
+
+        public string Description { get; } = "";
+
+        public TemplateZone(string template, string name, string picture, string description)
+        {
+            ZoneName = name;
+            TemplateName = template;
+            Picture = picture;
+            Description = description;
+        }
+
+        public TemplateZone(System.Data.DataRow dr)
+        {
+            TemplateName = (string)dr["TemplateName"];
+            if (DBNull.Value == dr["ZoneName"]) { ZoneName = "Default zone"; }
+            else { ZoneName = (string)dr["ZoneName"]; }
+            if (DBNull.Value == dr["ZoneDescription"]) { Description = ""; }
+            else { Description = (string)dr["ZoneDescription"]; }
+            Picture = (string)dr["Picture"];
+            TemplateRegions = TemplateRegion.GetAllRegions(TemplateName, ZoneName);
+        }
+        private List<TemplateRegion> _regions = new List<TemplateRegion>();
+        public TemplateRegion[] TemplateRegions
+        {
+            get => _regions.ToArray();
+            set { _regions.Clear(); _regions.AddRange(value); }
+        }
+    }
+}

DataPRO/Modules/PreviousDBVersions/Version57/DatabaseExport/ISO/TestEngineerDetails.cs

@@ -0,0 +1,187 @@
+using System;
+using System.Collections.Generic;
+using System.Data;
+
+namespace DatabaseExport.ISO
+{
+    [Serializable()]
+    public class TestEngineerDetails //: ISerializableFile
+    {
+        private enum Fields
+        {
+            Name,
+            TestEngineerName,
+            TestEngineerPhone,
+            TestEngineerFax,
+            TestEngineerEmail,
+            LocalOnly,
+            LastModified,
+            LastModifiedBy,
+            Version
+        }
+        public Dictionary<string, string> GetValues()
+        {
+            var elementNameValuePairs = new Dictionary<string, string>();
+
+            elementNameValuePairs[Fields.Name.ToString()] = Name;
+            elementNameValuePairs[Fields.TestEngineerName.ToString()] = TestEngineerName;
+            elementNameValuePairs[Fields.TestEngineerPhone.ToString()] = TestEngineerPhone;
+            elementNameValuePairs[Fields.TestEngineerFax.ToString()] = TestEngineerFax;
+            elementNameValuePairs[Fields.TestEngineerEmail.ToString()] = TestEngineerEmail;
+            elementNameValuePairs[Fields.LocalOnly.ToString()] = LocalOnly.ToString();
+            elementNameValuePairs[Fields.LastModified.ToString()] = LastModified.ToString(System.Globalization.CultureInfo.InvariantCulture);
+            elementNameValuePairs[Fields.LastModifiedBy.ToString()] = LastModifiedBy;
+            elementNameValuePairs[Fields.Version.ToString()] = Version.ToString(System.Globalization.CultureInfo.InvariantCulture);
+
+            return elementNameValuePairs;
+        }
+        private string _testEngineerName = "NOVALUE";
+        public string TestEngineerName
+        {
+            get => _testEngineerName;
+            set
+            {
+                if (value != string.Empty)
+                {
+                    _testEngineerName = value;
+                }
+            }
+        }
+
+        private string _testEngineerPhone = "NOVALUE";
+        public string TestEngineerPhone
+        {
+            get => _testEngineerPhone;
+            set
+            {
+                if (value != string.Empty)
+                {
+                    _testEngineerPhone = value;
+                }
+            }
+        }
+
+        private string _testEngineerFax = "NOVALUE";
+        public string TestEngineerFax
+        {
+            get => _testEngineerFax;
+            set
+            {
+                if (value != string.Empty)
+                {
+                    _testEngineerFax = value;
+                }
+            }
+        }
+
+        private string _testEngineerEmail = "NOVALUE";
+        public string TestEngineerEmail
+        {
+            get => _testEngineerEmail;
+            set
+            {
+                if (value != string.Empty)
+                {
+                    _testEngineerEmail = value;
+                }
+            }
+        }
+
+        private bool _localOnly = false;
+        public bool LocalOnly
+        {
+            get => _localOnly;
+            set => _localOnly = value;
+        }
+
+        private string _name = "";
+        public string Name
+        {
+            get => _name;
+            set => _name = value;
+        }
+
+        private DateTime _lastModified;
+        public DateTime LastModified
+        {
+            get => _lastModified;
+            set => _lastModified = value;
+        }
+
+        private string _lastModifiedBy;
+        public string LastModifiedBy
+        {
+            get => _lastModifiedBy;
+            set => _lastModifiedBy = value;
+        }
+        private int _version = 1;
+        public int Version
+        {
+            get => _version;
+            set => _version = value;
+        }
+
+        public TestEngineerDetails()
+        {
+        }
+
+        public TestEngineerDetails(DataRow dr)
+        {
+            _name = (string)dr["Name"];
+            TestEngineerName = (string)dr["TestEngineerName"];
+            TestEngineerPhone = (string)dr["TestEngineerPhone"];
+            TestEngineerFax = (string)dr["TestEngineerFax"];
+            TestEngineerEmail = (string)dr["TestEngineerEmail"];
+            _localOnly = Convert.ToBoolean(dr["LocalOnly"]);
+            _lastModified = Convert.ToDateTime(dr["LastModified"]);
+            _lastModifiedBy = (string)dr["LastModifiedBy"];
+            _version = Convert.ToInt32(dr["Version"]);
+        }
+        public TestEngineerDetails(TestEngineerDetails copy)
+        {
+            _name = copy.Name;
+            TestEngineerName = copy.TestEngineerName;
+            TestEngineerPhone = copy.TestEngineerPhone;
+            TestEngineerFax = copy.TestEngineerFax;
+            TestEngineerEmail = copy.TestEngineerEmail;
+            _localOnly = copy.LocalOnly;
+            _lastModified = copy.LastModified;
+            _lastModifiedBy = copy.LastModifiedBy;
+            _version = copy.Version;
+        }
+        public static TestEngineerDetails[] GetAllTestEngineerDetails()
+        {
+            var list = new List<TestEngineerDetails>();
+            try
+            {
+                using (var sql = DbOperations.GetCommand())
+                {
+                    sql.CommandText = "SELECT * from [tblTestEngineerDetails]";
+
+                    using (var ds = DbOperations.Connection.QueryDataSet(sql))
+                    {
+                        if (ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0)
+                        {
+                            foreach (DataRow dr in ds.Tables[0].Rows)
+                            {
+                                try
+                                {
+                                    list.Add(new TestEngineerDetails(dr));
+                                }
+                                catch (Exception)
+                                {
+                                    //DTS.Utilities.Logging.APILogger.Log("failed to get test engineer details", ex);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            catch (Exception)
+            {
+                //DTS.Utilities.Logging.APILogger.Log("Failed to retrieve test engineer details", ex);
+            }
+            return list.ToArray();
+        }
+    }
+}

DataPRO/Modules/PreviousDBVersions/Version57/DatabaseExport/ISO/TestObject.cs

@@ -0,0 +1,411 @@
+using System;
+using System.Collections.Generic;
+using System.Data;
+using System.Linq;
+using System.Text;
+
+namespace DatabaseExport.ISO
+{
+    public class TestObject
+    {
+        private List<TestObjectChannel> _allChannels = new List<TestObjectChannel>();
+        public TestObjectChannel[] AllChannels
+        {
+            get => _allChannels.ToArray();
+            set
+            {
+                _allChannels = new List<TestObjectChannel>(value);
+                SortChannels();
+            }
+        }
+
+        public void SortChannels()
+        {
+            _allChannels.Sort();
+        }
+
+        public TestObjectChannel GetChannel(string channelid)
+        {
+            return Array.Find(AllChannels, ch => ch.GetID() == channelid || ch.Name == channelid);
+        }
+
+        public override string ToString()
+        {
+            return Embedded ? DisplaySerialNumber : SerialNumber;
+        }
+
+        public string DisplaySerialNumber => SysBuilt ? SerialNumberConverted : OriginalSerialNumber;
+
+        public string SerialNumberConverted { get; set; }
+
+        public string SerialNumber { get; set; }
+
+        public string SerialNumberOrOriginalSerialNumber => Embedded ? OriginalSerialNumber : SerialNumber;
+
+        public string TestObjectType { get; set; }
+
+        public string ParentObject { get; set; }
+
+        public bool SysBuilt { get; set; }
+
+        //        public string TextL1 { get; set; }
+
+        private List<string> _hardwareIds = new List<string>();
+        public string[] HardwareIds
+        {
+            get => _hardwareIds.ToArray();
+            set { _hardwareIds.Clear(); _hardwareIds.AddRange(value); }
+        }
+
+        public string Template { get; set; }
+
+        public void SetTemplateOnly(string value) { Template = value; }
+        public void SetTemplate(string value, ref ISO13499FileDb db)
+        {
+            Template = value;
+            var template = ISO.TestObjectTemplate.GetTemplate(ref db, Template);
+            SetTemplate(template);
+        }
+        public void SetTemplate(ISO.TestObjectTemplate template)
+        {
+            _allChannels.Clear();
+            if (null == template) return;
+            Template = template.TemplateName;
+            AllChannels = template.Channels.Select(c => new TestObjectChannel(c, this, template)).ToArray();
+        }
+        private bool _localOnly;
+        public bool LocalOnly
+        {
+            get => _localOnly;
+            set => _localOnly = value;
+        }
+        private string _lastModifiedBy;
+        public string LastModifiedBy
+        {
+            get => _lastModifiedBy;
+            set => _lastModifiedBy = value;
+        }
+        private DateTime _lastModified;
+        public DateTime LastModified
+        {
+            get => _lastModified;
+            set => _lastModified = value;
+        }
+        private TestObject(DataRow dr, ref ISO13499FileDb db)
+        {
+            OriginalTemplate = "";
+            OriginalSerialNumber = "";
+            SerialNumberConverted = string.Empty;
+            TestObjectGuts(dr, ref db);
+        }
+
+        public bool Embedded { get; set; }
+
+        /// <summary>
+        /// original serial number of this group (the serial number will be changed once it's embedded in a test setup)
+        /// </summary>
+        public string OriginalSerialNumber { get; set; }
+
+        /// <summary>
+        /// the original template for this group (the template is also changed once it's embedded in a test setup)
+        /// </summary>        
+        public string OriginalTemplate { get; set; }
+
+        private void TestObjectGuts(DataRow dr, ref ISO13499FileDb db)
+        {
+            SerialNumber = (string)dr["SerialNumber"];
+            LocalOnly = Convert.ToBoolean(dr["LocalOnly"]);
+            SetTemplate((string)dr["Template"], ref db);
+            LastModifiedBy = (string)dr["LastModifiedBy"];
+            LastModified = Convert.ToDateTime(dr["LastModified"]);
+            SysBuilt = Convert.ToBoolean(dr["SysBuilt"]);
+            var o = dr["Embedded"];
+            if (!DBNull.Value.Equals(o))
+            {
+                Embedded = Convert.ToBoolean(o);
+            }
+            o = dr["OrigSerialNumber"];
+            if (!DBNull.Value.Equals(o))
+            {
+                OriginalSerialNumber = Convert.ToString(o);
+            }
+            o = dr["OrigTEmplate"];
+            if (!DBNull.Value.Equals(o))
+            {
+                OriginalTemplate = Convert.ToString(o);
+            }
+            try
+            {
+                if (!DBNull.Value.Equals(dr["ParentObject"]))
+                {
+                    ParentObject = (string)dr["ParentObject"];
+                }
+            }
+            catch (Exception) { /*APILogger.Log(ex);*/ }
+            try
+            {
+                using (var sql = DbOperations.GetCommand())
+                {
+                    DbOperations.CreateParam(sql, string.Format("@{0}", DbOperations.TestObjectChannelSettings.Fields.TestObjectSerial),
+                        SqlDbType.NVarChar, SerialNumber);
+                    sql.CommandText = string.Format("SELECT * from [{0}] where [{1}]=@{1}", DbOperations.TestObjectChannelSettings.TableName,
+                        DbOperations.TestObjectChannelSettings.Fields.TestObjectSerial);
+
+                    using (var ds = DbOperations.Connection.QueryDataSet(sql))
+                    {
+                        if (ds.Tables[0].Rows.Count <= 0) return;
+                        foreach (DataRow row in ds.Tables[0].Rows)
+                        {
+                            try
+                            {
+                                var channelId = (string)row[DbOperations.TestObjectChannelSettings.Fields.ChannelId.ToString()];
+                                var sensor = (string)row[DbOperations.TestObjectChannelSettings.Fields.SensorSerial.ToString()];
+                                var settings = (string)row[DbOperations.TestObjectChannelSettings.Fields.Setting.ToString()];
+                                if (string.IsNullOrEmpty(channelId) || string.IsNullOrEmpty(sensor) ||
+                                    string.IsNullOrEmpty(settings)) continue;
+                                var sensorsettings = GetSettingsFromString(settings, sensor, channelId);
+                                foreach (var setting in sensorsettings)
+                                {
+                                    SetSensorSetting(channelId, sensor, setting);
+                                }
+                            }
+                            catch (Exception) {/* APILogger.Log(ex);*/ }
+                        }
+                    }
+                }
+            }
+            catch (Exception) { /*APILogger.Log(ex); */}
+        }
+        public static SensorSetting[] GetSettingsFromString(string s, string sensor, string channelid)
+        {
+            var tokens = s.Split(',');
+
+            return (from token in tokens select token.Split('=') into subtokens let setting = (SensorSettings)Convert.ToInt32(subtokens[0]) select new SensorSetting(setting, subtokens[1], channelid, sensor)).ToArray();
+        }
+        public TestObject()
+        {
+            OriginalTemplate = "";
+            OriginalSerialNumber = "";
+            SerialNumberConverted = string.Empty;
+            _allChannels = new List<TestObjectChannel>();
+            _hardwareIds = new List<string>();
+            LastModified = DateTime.MinValue;
+            LastModifiedBy = "N/A";
+            LocalOnly = false;
+            SerialNumber = "";
+            Template = "";
+            ParentObject = "";
+        }
+        public enum SensorSettings
+        {
+            Range,
+            CFC,
+            Polarity,
+            Position,
+            LimitDuration,
+            Duration,
+            Delay,
+            OutputMode,
+            SQMode,
+            DIMode,
+            DefaultValue,
+            ActiveValue
+        }
+        public class SensorSetting
+        {
+            public string ChannelId { get; set; }
+            public string SerialNumber { get; set; }
+            public SensorSettings Setting { get; set; }
+            public string Value { get; set; }
+            public SensorSetting(SensorSettings setting, string value, string channelId, string serialNumber)
+            {
+                ChannelId = channelId;
+                Value = value;
+                Setting = setting;
+                SerialNumber = serialNumber;
+            }
+            public SensorSetting(SensorSetting copy)
+            {
+                ChannelId = copy.ChannelId;
+                Value = copy.Value;
+                Setting = copy.Setting;
+                SerialNumber = copy.SerialNumber;
+            }
+        }
+        private Dictionary<string, Dictionary<string, Dictionary<SensorSettings, SensorSetting>>> _sensorSettings = new Dictionary<string, Dictionary<string, Dictionary<SensorSettings, SensorSetting>>>();
+
+        public SensorSetting[] GetSensorSettings(string channelId, string serialNumber)
+        {
+            if (!_sensorSettings.ContainsKey(channelId)) return new SensorSetting[0];
+            return _sensorSettings[channelId].ContainsKey(serialNumber) ? _sensorSettings[channelId][serialNumber].Values.ToArray() : new SensorSetting[0];
+        }
+        public void SetSensorSetting(string channelId, string serialNumber, SensorSetting setting)
+        {
+            if (!_sensorSettings.ContainsKey(channelId)) { _sensorSettings[channelId] = new Dictionary<string, Dictionary<SensorSettings, SensorSetting>>(); }
+            if (!_sensorSettings[channelId].ContainsKey(serialNumber)) { _sensorSettings[channelId][serialNumber] = new Dictionary<SensorSettings, SensorSetting>(); }
+            _sensorSettings[channelId][serialNumber][setting.Setting] = setting;
+        }
+        public TestObject(TestObject copy, ref ISO13499FileDb db)
+        {
+            SerialNumberConverted = string.Empty;
+            OriginalSerialNumber = copy.OriginalSerialNumber;
+            OriginalTemplate = copy.OriginalTemplate;
+            Embedded = copy.Embedded;
+
+            _allChannels = new List<TestObjectChannel>();
+
+            var t = TestObjectTemplate.GetTemplate(ref db, Template);
+
+            copy.SortChannels();
+            foreach (var c in copy.AllChannels) { _allChannels.Add(new TestObjectChannel(c, this, t)); }
+
+            for (var i = 0; i < copy.AllChannels.Length && i < _allChannels.Count; i++)
+            {
+                _allChannels[i].ChannelIDX = i;
+            }
+
+            _hardwareIds = new List<string>(copy.HardwareIds);
+            LastModified = copy.LastModified;
+            LastModifiedBy = copy.LastModifiedBy;
+            LocalOnly = copy.LocalOnly;
+            SerialNumber = copy.SerialNumber;
+            Template = copy.Template;
+            ParentObject = copy.ParentObject;
+            SysBuilt = copy.SysBuilt;
+            var e = copy._sensorSettings.GetEnumerator();
+            _sensorSettings = new Dictionary<string, Dictionary<string, Dictionary<SensorSettings, SensorSetting>>>();
+            while (e.MoveNext())
+            {
+                if (!_sensorSettings.ContainsKey(e.Current.Key))
+                {
+                    _sensorSettings[e.Current.Key] = new Dictionary<string, Dictionary<SensorSettings, SensorSetting>>();
+                }
+                var e2 = copy._sensorSettings[e.Current.Key].GetEnumerator();
+                while (e2.MoveNext())
+                {
+                    if (!_sensorSettings[e.Current.Key].ContainsKey(e2.Current.Key))
+                    {
+                        _sensorSettings[e.Current.Key][e2.Current.Key] = new Dictionary<SensorSettings, SensorSetting>();
+                    }
+                    var e3 = copy._sensorSettings[e.Current.Key][e2.Current.Key].GetEnumerator();
+                    while (e3.MoveNext())
+                    {
+                        _sensorSettings[e.Current.Key][e2.Current.Key][e3.Current.Key] = new SensorSetting(e3.Current.Value);
+                    }
+                }
+            }
+        }
+        private const char CHANNEL_SEPARATOR = 'x';
+        private void GetHardwareAndSensors()
+        {
+            using (var sql = DbOperations.GetCommand())
+            {
+                DbOperations.CreateParam(sql, "@TestObject", SqlDbType.NVarChar, SerialNumber);
+
+                sql.CommandText = "SELECT [HardwareId] from [tblTestObjectHardware] WHERE [TestObject]=@TestObject";
+
+                using (var ds = DbOperations.Connection.QueryDataSet(sql))
+                {
+                    if (null != ds && ds.Tables.Count > 0)
+                    {
+                        var ids = new List<string>();
+                        for (var i = 0; i < ds.Tables[0].Rows.Count; i++)
+                        {
+                            var id = (string)ds.Tables[0].Rows[i]["HardwareId"];
+                            var tokens = id.Split('_');
+                            if (tokens.Length == 3)
+                            {
+                                var sb = new StringBuilder();
+                                sb.AppendFormat("{0}_{1}", tokens[0], tokens[1]);
+                                var index = tokens[2].IndexOf(CHANNEL_SEPARATOR);
+                                if (index >= 0) { sb.Append(tokens[2].Substring(index)); }
+                                id = sb.ToString();
+                            }
+                            if (!ids.Contains(id)) { ids.Add(id); }
+                        }
+                        _hardwareIds = ids;
+                    }
+                }
+            }
+            var channelLookup = AllChannels.ToDictionary(ch => ch.GetID());
+            using (var sql = DbOperations.GetCommand())
+            {
+                DbOperations.CreateParam(sql, "@TestObjectId", SqlDbType.NVarChar, SerialNumber);
+
+                sql.CommandText = "SELECT [UIChannelID],[SensorId],[ZoneId],[HardwareId],[ChannelIdx] FROM [tblTestObjectSensors] WHERE [TestObjectId]=@TestObjectId";
+
+                using (var ds = DbOperations.Connection.QueryDataSet(sql))
+                {
+                    if (null != ds && ds.Tables.Count > 0)
+                    {
+                        foreach (DataRow dr in ds.Tables[0].Rows)
+                        {
+                            var id = Convert.ToString(dr[0]);
+                            var sensorId = "";
+                            var hardwareId = "";
+                            var channelIdx = -1;
+                            if (!DBNull.Value.Equals(dr["ChannelIdx"])) { channelIdx = Convert.ToInt32(dr["ChannelIdx"]); }
+                            if (!DBNull.Value.Equals(dr[1])) { sensorId = Convert.ToString(dr[1]); }
+                            if (!DBNull.Value.Equals(dr[3]))
+                            {
+                                hardwareId = Convert.ToString(dr[3]);
+                                var tokens = hardwareId.Split('_');
+                                if (3 == tokens.Length)
+                                {
+                                    var sb = new StringBuilder();
+                                    sb.AppendFormat("{0}_{1}", tokens[0], tokens[1]);
+                                    var index = tokens[2].IndexOf('x');
+                                    if (index >= 0) { sb.Append(tokens[2].Substring(index)); }
+                                    hardwareId = sb.ToString();
+                                }
+                            }
+                            if (!channelLookup.ContainsKey(id)) continue;
+                            channelLookup[id].SensorSerialNumber = sensorId;
+                            channelLookup[id].HardwareId = hardwareId;
+                            channelLookup[id].ChannelIDX = channelIdx;
+                        }
+                    }
+                }
+            }
+            SortChannels();
+        }
+        public string GetSerializedSetting(SensorSetting[] settings)
+        {
+            var sb = new StringBuilder();
+            var bNeedComma = false;
+            foreach (var setting in settings)
+            {
+                if (bNeedComma) { sb.Append(","); }
+                bNeedComma = true;
+
+                sb.AppendFormat("{0}={1}", (int)setting.Setting, setting.Value);
+            }
+            return sb.ToString();
+        }
+        public static TestObject GetTestObject(string serialNumber, ref ISO13499FileDb db)
+        {
+            try
+            {
+                TestObject testObject = null;
+                using (var sql = DbOperations.GetCommand())
+                {
+                    DbOperations.CreateParam(sql, "@1", SqlDbType.NVarChar, serialNumber);
+                    sql.CommandText = "Select * FROM [tblTestObjects] WHERE [SerialNumber] = @1";
+                    using (var ds = DbOperations.Connection.QueryDataSet(sql))
+                    {
+                        if (null != ds && ds.Tables[0].Rows.Count > 0)
+                        {
+                            //var testObject =  new TestObject(ds.Tables[0].Rows[0], ref db);
+                            testObject = new TestObject(ds.Tables[0].Rows[0], ref db);
+                            testObject.GetHardwareAndSensors();
+                            //return testObject;
+                        }
+                    }
+                }
+                return testObject;
+            }
+            catch (Exception) { /*APILogger.Log("failed to retrieve test objects", ex);*/ }
+            return null;
+        }
+    }
+}

DataPRO/Modules/PreviousDBVersions/Version57/DatabaseExport/ISO/TestObjectChannel.cs

@@ -0,0 +1,101 @@
+using System;
+using System.Text;
+
+namespace DatabaseExport
+{
+    public class TestObjectChannel : TestObjectTemplateChannel, /*INotifyPropertyChanged,*/ IComparable<TestObjectChannel>
+    {
+        private const string CURRENT_SUFFIX = "_CU";
+        public const int CHANNEL_IDX_UNKNOWN = -1;
+        public enum SquibChannelTypes
+        {
+            None, //Non-squib channels
+            Voltage,
+            Current
+        }
+        //        #endregion
+        public string GetGraphID()
+        {
+            return SquibChannelType == SquibChannelTypes.Current ? GetId() + CURRENT_SUFFIX : GetId();
+        }
+        public string GetId()
+        {
+            return GetIdWithSpecificChannelId(Channel.Id);
+        }
+        public string GetIdWithSpecificChannelId(long id)
+        {
+            return $"{TestObject.SerialNumber}_{Channel.MMEChannelType}_{id}";
+        }
+        public SquibChannelTypes SquibChannelType
+        {
+            get; set;
+        }
+        public int CompareTo(TestObjectChannel right)
+        {
+            if (null == right) { return 1; }
+            if (this == right) { return 0; }
+            var comp = DisplayOrder.CompareTo(right.DisplayOrder);
+            if (0 != comp) { return comp; }
+
+            comp = Name.CompareTo(right.Name);
+            if (0 != comp) { return comp; }
+
+            if (null != TestObject && null != right.TestObject)
+            {
+                comp = TestObject.SerialNumberOrOriginalSerialNumber.CompareTo(right.TestObject.SerialNumberOrOriginalSerialNumber);
+                if (0 != comp) { return comp; }
+            }
+            return 0;
+        }
+        public string SensorSerialNumber
+        {
+            get => GetProperty("SensorSerialNumber", "") as string;
+            set => SetProperty("SensorSerialNumber", value);
+        }
+        private const char ChannelSeparator = 'x';
+        public string HardwareId
+        {
+            get => GetProperty("HardwareId", "") as string;
+            set
+            {
+                if (null != value)
+                {
+                    var tokens = value.Split('_');
+                    if (3 == tokens.Length)
+                    {
+                        var sb = new StringBuilder();
+                        sb.AppendFormat("{0}_{1}", tokens[0], tokens[1]);
+                        var index = tokens[2].IndexOf(ChannelSeparator);
+                        if (index >= 0) { sb.Append(tokens[2].Substring(index)); }
+                        value = sb.ToString();
+                    }
+                }
+                SetProperty("HardwareId", value);
+            }
+        }
+
+        private ISO.TestObject _testObject = null;
+        public ISO.TestObject TestObject => _testObject;
+
+        public TestObjectChannel(TestObjectTemplateChannel copy, ISO.TestObject testObject, ISO.TestObjectTemplate template)
+            : base(copy, template)
+        {
+            _testObject = testObject;
+        }
+
+        public string GetID()
+        {
+            return GetIDWithSpecificChannelId(Channel.Id);
+        }
+        public string GetIDWithSpecificChannelId(long id)
+        {
+            return string.Format("{0}_{1}_{2}", _testObject.SerialNumber, Channel.MMEChannelType, id);
+        }
+        private int _channelIDX = CHANNEL_IDX_UNKNOWN;
+        public int ChannelIDX
+        {
+            get => _channelIDX;
+            set => _channelIDX = value;
+        }
+    }
+}

DataPRO/Modules/PreviousDBVersions/Version57/DatabaseExport/ISO/TestObjectMetaData.cs

@@ -0,0 +1,196 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace DatabaseExport
+{
+    public class TestObjectMetaData
+    {
+        public double Version { get; set; } = 1.06;
+
+        public const string NOVALUE = "NOVALUE";
+
+        public void SetProperty(MetaData meta)
+        {
+            _properties[meta.Name] = meta;
+        }
+        public enum CommentFields
+        {
+            Comment1,
+            Comment2,
+            Comment3,
+        }
+        public enum Fields
+        {
+            NameOfTestObject,
+            VelocityOfTestObject,
+            MassOfTestObject,
+            DriverPositionObject,
+            ImpactSideTestObject,
+            TypeOfTestObject,
+            ClassOfTestObject,
+            CodeOfTestObject,
+            RefNumberOfTestObject,
+            TestObjectComments
+        }
+        public enum OptionFields
+        {
+            Offset,
+            BarrierWidth,
+            BarrierHeight,
+            YawAngle,
+            ReferenceSystem,
+            OriginX,
+            OriginY,
+            OriginZ,
+            NumberOfLoadCells
+        }
+        private Dictionary<string, MetaData> _properties = new Dictionary<string, MetaData>();
+        public TestObjectMetaData(char testobject)
+        {
+            TestObject = testobject;
+            var comments = Enum.GetValues(typeof(CommentFields)).Cast<CommentFields>().ToArray();
+            var fields = Enum.GetValues(typeof(Fields)).Cast<Fields>().ToArray();
+            var optional = Enum.GetValues(typeof(OptionFields)).Cast<OptionFields>().ToArray();
+            foreach (var cfield in comments) { _properties.Add(cfield.ToString(), new MetaData(cfield.ToString(), false, NOVALUE, Version)); }
+            foreach (var field in fields)
+            {
+                switch (field)
+                {
+                    case Fields.VelocityOfTestObject:
+                    case Fields.MassOfTestObject:
+                        _properties.Add(field.ToString(), new MetaData(field.ToString(), false, string.Empty, Version));
+                        break;
+                    default:
+                        _properties.Add(field.ToString(), new MetaData(field.ToString(), false, NOVALUE, Version));
+                        break;
+                }
+            }
+            foreach (var ofield in optional)
+            {
+                _properties.Add(ofield.ToString(), new MetaData(ofield.ToString(), true, NOVALUE, Version));
+            }
+        }
+
+        public char TestObject { get; } = '?';
+        public MetaData[] Properties => _properties.Values.ToArray();
+    }
+    public class MetaData
+    {
+        public string Name { get; }
+
+        public bool IsOptional { get; } = false;
+
+        public double Version { get; } = 1.06D;
+
+        public string Value { get; set; } = "NOVALUE";
+
+        public MetaData(string name, bool optional, string value, double version)
+        {
+            Name = name;
+            IsOptional = optional;
+            Value = value;
+            Version = version;
+        }
+    }
+    public class TestSetupMetaData
+    {
+        public double Version { get; set; } = 1.06;
+
+        public const string NOVALUE = "NOVALUE";
+        public const string MEDIADEFAULT = "1/1";
+
+        public void SetProperty(MetaData meta, bool requireXCrashCompatibilityForISOExports)
+        {
+            switch (meta.Name)
+            {
+                case "LaboratoryName":
+                case "LaboratoryContactName":
+                case "LaboratoryTestReferenceNumber":
+                case "CustomerName":
+                case "CustomerTestReferenceNumber":
+                    if ((meta.Value == NOVALUE) && requireXCrashCompatibilityForISOExports)
+                    {
+                        meta.Value = string.Empty;
+                    }
+                    break;
+            }
+            _properties[meta.Name] = meta;
+        }
+        public enum Fields
+        {
+            LabName,
+            LaboratoryContactName,
+            LaboratoryContactPhone,
+            LaboratoryContactFax,
+            LaboratoryContactEmail,
+            LaboratoryName,
+            LaboratoryTestReferenceNumber,
+            LaboratoryProjectReferenceNumber,
+
+            CustName,
+            CustomerName,
+            CustomerTestReferenceNumber,
+            CustomerProjectReferenceNumber,
+            CustomerOrderNumber,
+            CustomerCostUnit,
+
+            TEName,
+            TestEngineerName,
+            TestEngineerPhone,
+            TestEngineerFax,
+            TestEngineerEmail,
+
+            Title,
+            MediumNoNumberOfMedia,
+            TestComment,
+            TypeOfTheTest,
+            ReferenceTemperature,
+            RelativeAirHumidity,
+            Regulation,
+            Subtype,
+            DateOfTheTest
+        }
+
+        private Dictionary<string, MetaData> _properties = new Dictionary<string, MetaData>();
+        public TestSetupMetaData(bool requireXCrashCompatibilityForISOExports)
+        {
+            TestObject = '_';
+            var fields = Enum.GetValues(typeof(Fields)).Cast<Fields>().ToArray();
+            foreach (var field in fields)
+            {
+                switch (field)
+                {
+                    case Fields.MediumNoNumberOfMedia:
+                        _properties.Add(field.ToString(), new MetaData(field.ToString(), false, MEDIADEFAULT, Version));
+                        break;
+                    case Fields.LaboratoryName:
+                    case Fields.LaboratoryContactName:
+                    case Fields.LaboratoryTestReferenceNumber:
+                    case Fields.CustomerName:
+                    case Fields.CustomerTestReferenceNumber:
+                        if (requireXCrashCompatibilityForISOExports)
+                        {
+                            _properties.Add(field.ToString(), new MetaData(field.ToString(), false, string.Empty, Version));
+                        }
+                        else
+                        {
+                            _properties.Add(field.ToString(), new MetaData(field.ToString(), false, NOVALUE, Version));
+                        }
+                        break;
+                    default:
+                        _properties.Add(field.ToString(), new MetaData(field.ToString(), false, NOVALUE, Version));
+                        break;
+                }
+            }
+        }
+        public void Clear()
+        {
+            _properties.Clear();
+        }
+
+        public char TestObject { get; } = '_';
+
+        public MetaData[] Properties => _properties.Values.ToArray();
+    }
+}

DataPRO/Modules/PreviousDBVersions/Version57/DatabaseExport/ISO/TestObjectTemplate.cs

@@ -0,0 +1,302 @@
+using System;
+using System.Collections.Generic;
+using System.Data;
+
+namespace DatabaseExport.ISO
+{
+    /// <summary>
+    /// this class is a wrapper for the group template per the db, it's supposed to be a lighter weight version of concept of a test object template, with no
+    /// connection to UI, just serialization and structure
+    /// </summary>
+    public class TestObjectTemplate
+    {
+        //        #region Properties
+        /// <summary>
+        /// name of the test object template, this could be a GUID in the case of embedded test object templates
+        /// </summary>
+        public string TemplateName { get; set; }
+        /// <summary>
+        /// a human readable name for the template, for an embedded template this is the original template name, for 
+        /// a non embedded template, this is the template name (embedded templates have guids for names)
+        /// </summary>
+        public string TemplateNameOrOriginalTemplateName => Embedded ? OriginalTemplateName : TemplateName;
+
+        /// <summary>
+        /// the icon for the template
+        /// </summary>
+        public string Icon { get; set; }
+        /// <summary>
+        /// description for the template
+        /// </summary>
+        public string Description { get; set; }
+        /// <summary>
+        /// whether this template is intended to only be used locally or not
+        /// </summary>
+        public bool LocalOnly { get; set; }
+        /// <summary>
+        /// the version number of this template [not currently used?]
+        /// </summary>
+        public int Version { get; set; }
+        /// <summary>
+        /// last person to modify this template
+        /// </summary>
+        public string LastModifiedBy { get; set; }
+        /// <summary>
+        /// when this template was last modified
+        /// </summary>
+        public DateTime LastModified { get; set; }
+        /// <summary>
+        /// a CRC32 for the template, but not currently used
+        /// original idea was to allow us to not have to check changes in the template, just quickly calculate whether anything has changed
+        /// </summary>
+        public int CRC32 { get; set; }
+        /// <summary>
+        /// test object (iso meta field) for this template
+        /// </summary>
+        public string TestObject { get; set; }
+        /// <summary>
+        /// test object type (iso meta field) for this template, all channels are of this type ...
+        /// </summary>
+        public string TestObjectType { get; set; }
+        /// <summary>
+        /// unsure if this is still used, was originally used to build up templates from sub templates, 
+        /// so an ATD could be composed of leg, arm, head, etc
+        /// </summary>
+        public string TemplateParent { get; set; }
+        /// <summary>
+        /// unsure, I think this is whether the group is dynamically added or an existing 
+        /// </summary>
+        public bool SysBuilt { get; set; }
+        /// <summary>
+        /// zones where regions on a test object, this is currently hidden, but the idea
+        /// was to associate a picture with a zone, and to allow constructing regions or areas in that zone
+        /// </summary>
+        public TemplateZone[] Zones { get; set; }
+        /// <summary>
+        /// all channels for the template
+        /// </summary>
+        public TestObjectTemplateChannel[] Channels { get; set; }
+        /// <summary>
+        /// the original template name [if we are embedded we got a new name that was a guid, but we store the old name here for readability purposes]
+        /// </summary>
+        public string OriginalTemplateName { get; set; }
+        /// <summary>
+        /// whether this group is embedded in a test setup, or is a user created and living on it's own template
+        /// </summary>
+        public bool Embedded { get; set; }
+        public TestObjectTemplate(DataRow row, ref ISO13499FileDb db, ref List<string> errors)
+        {
+            TemplateName = (string)row["TemplateName"];
+            Icon = (string)row["Icon"];
+            Description = (string)row["Description"];
+            LocalOnly = Convert.ToBoolean(row["LocalOnly"]);
+            Version = Convert.ToInt32(row["Version"]);
+            LastModifiedBy = (string)row["LastModifiedBy"];
+            LastModified = Convert.ToDateTime(row["LastModified"]);
+            CRC32 = Convert.ToInt32(row["CRC32"]);
+            TestObject = (string)row["TestObject"];
+            TestObjectType = (string)row["TestObjectType"];
+            var oTemplate = row["OrigTemplateName"];
+            OriginalTemplateName = DBNull.Value.Equals(oTemplate) ? string.Empty : Convert.ToString(oTemplate);
+            var oEmbedded = row["Embedded"];
+            if (!DBNull.Value.Equals(oEmbedded))
+            {
+                Embedded = Convert.ToBoolean(oEmbedded);
+            }
+            try
+            {
+                TemplateParent = DBNull.Value.Equals(row["ParentTemplate"]) ? "" : (string)row["ParentTemplate"];
+            }
+            catch (Exception) { TemplateParent = null; }
+            SysBuilt = Convert.ToBoolean(row["SysBuilt"]);
+
+            var channels = new List<TestObjectTemplateChannel>();
+            var possibleChannels = db.GetPossibleChannelsForType(TestObjectType);
+            var channelLookup = new Dictionary<int, Dictionary<long, TestObjectTemplateChannel>>();
+
+            foreach (var pc in possibleChannels)
+            {
+                try
+                {
+                    var newCh = new TestObjectTemplateChannel(pc);
+                    newCh.SetTemplate(this);
+                    channels.Add(newCh);
+                    if (!channelLookup.ContainsKey(newCh.Channel.MMEChannelType))
+                    {
+                        channelLookup.Add(newCh.Channel.MMEChannelType, new Dictionary<long, TestObjectTemplateChannel>());
+                    }
+                    channelLookup[newCh.Channel.MMEChannelType][newCh.Channel.Id] = newCh;
+                }
+                catch (Exception) {/* DTS.Utilities.Logging.APILogger.Log(ex);*/ }
+            }
+            var failedToLoadChannels = 0;
+            try
+            {
+                using (var sql = DbOperations.GetCommand())
+                {
+                    DbOperations.CreateParam(sql, "@TemplateName", SqlDbType.NVarChar, TemplateName);
+                    sql.CommandText = "SELECT * from [tblTemplateChannels] where [TemplateName]=@TemplateName";
+                    using (var ds = DbOperations.Connection.QueryDataSet(sql))
+                    {
+                        if (ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0)
+                        {
+                            foreach (DataRow dr in ds.Tables[0].Rows)
+                            {
+                                TestObjectTemplateChannel ch = null;
+                                try
+                                {
+                                    ch = new TestObjectTemplateChannel(dr, this, ref db);
+                                    if (ch.Required)
+                                    {
+                                        if (null == ch.Channel)
+                                        {
+                                            failedToLoadChannels++;
+                                            continue;
+                                        }
+                                        var old = channelLookup[ch.Channel.MMEChannelType][ch.Channel.Id];
+                                        channelLookup[ch.Channel.MMEChannelType][ch.Channel.Id] = ch;
+                                        var index = channels.IndexOf(old);
+                                        channels.RemoveAt(index);
+                                        channels.Insert(index, ch);
+                                    }
+                                }
+                                catch (Exception)
+                                {
+                                    //DTS.Utilities.Logging.APILogger.Log("Failed to retrieve Template channel", ex2);
+                                    //if (null != ch) { errors.Add("Failed to load " + TemplateName + " - " + ch.Name); }
+                                    if (null != ch) { errors.Add("Failed to load " + ch.Name + " from template " + TemplateName); }
+                                    else { errors.Add("Failed to load a channel in " + TemplateName); }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            catch (Exception)
+            {
+                errors.Add("Failed to load channels for - " + TemplateName);
+                //DTS.Utilities.Logging.APILogger.Log("failed to retrieve template channels, ", TemplateName, ex);
+            }
+            Channels = channels.ToArray();
+            if (failedToLoadChannels > 0)
+            {
+                errors.Add(string.Format("Failed to load {0} channel(s) from template {1}", failedToLoadChannels.ToString("N0"), TemplateNameOrOriginalTemplateName));
+            }
+
+            var zones = new List<TemplateZone>();
+            try
+            {
+                using (var sql = DbOperations.GetCommand())
+                {
+                    DbOperations.CreateParam(sql, "@TemplateName", SqlDbType.NVarChar, TemplateName);
+
+                    sql.CommandText = "SELECT * from [tblTemplateZones] where [TemplateName]=@TemplateName";
+
+                    using (var ds = DbOperations.Connection.QueryDataSet(sql))
+                    {
+                        if (ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0)
+                        {
+                            foreach (DataRow dr in ds.Tables[0].Rows)
+                            {
+                                zones.Add(new TemplateZone(dr));
+                            }
+                        }
+                    }
+                }
+            }
+            catch (Exception)
+            {
+                //DTS.Utilities.Logging.APILogger.Log("failed to retrieve template regions, ", TemplateName, ex);
+            }
+            Zones = zones.ToArray();
+        }
+        public TestObjectTemplate(string templateName, bool bLocalOnly)
+        {
+            Version = 1;
+            TemplateName = templateName;
+            LocalOnly = bLocalOnly;
+            Zones = new TemplateZone[0];
+            Channels = new TestObjectTemplateChannel[0];
+        }
+        public TestObjectTemplate(TestObjectTemplate copy, ref ISO13499FileDb db)
+        {
+            if (null != copy && null != copy.TemplateName)
+            {
+                TemplateName = copy.TemplateName;
+            }
+            if (copy == null) return;
+            LocalOnly = copy.LocalOnly;
+            Zones = copy.Zones;
+            CRC32 = copy.CRC32;
+            Description = copy.Description;
+            Embedded = copy.Embedded;
+            OriginalTemplateName = copy.OriginalTemplateName;
+            Icon = copy.Icon;
+            LastModified = copy.LastModified;
+            LastModifiedBy = copy.LastModifiedBy;
+            LocalOnly = copy.LocalOnly;
+            SysBuilt = copy.SysBuilt;
+            TemplateParent = copy.TemplateParent;
+            TestObject = copy.TestObject;
+            TestObjectType = copy.TestObjectType;
+            Version = copy.Version;
+            var lookup = new Dictionary<string, bool>();
+            var channels = new List<TestObjectTemplateChannel>();
+            foreach (var c in copy.Channels)
+            {
+                var ch = new TestObjectTemplateChannel(c, this);
+                ch.SetTemplate(this);
+                channels.Add(ch);
+                lookup[string.Format("{0}x{1}", c.Channel.Id, c.Channel.MMEChannelType)] = true;
+            }
+            var possibleChannels = db.GetPossibleChannelsForType(TestObjectType);
+            foreach (var pc in possibleChannels)
+            {
+                var key = string.Format("{0}x{1}", pc.Id, pc.MMEChannelType);
+                if (lookup.ContainsKey(key)) continue;
+                lookup[key] = true;
+                var ch = new TestObjectTemplateChannel(pc);
+                ch.SetTemplate(this);
+                channels.Insert(0, ch);
+            }
+            Channels = channels.ToArray();
+        }
+        public static TestObjectTemplate GetTemplate(ref ISO13499FileDb db, string name)
+        {
+
+            if (string.IsNullOrEmpty(name)) return null;
+
+            var errors = new List<string>();
+            var templates = new List<TestObjectTemplate>();
+            try
+            {
+                using (var sql = DbOperations.GetCommand())
+                {
+                    sql.CommandText = "SELECT * from [tblTestObjectTemplates] where TemplateName=@TemplateName";
+                    DbOperations.CreateParam(sql, "@TemplateName", SqlDbType.NVarChar, name);
+                    using (var ds = DbOperations.Connection.QueryDataSet(sql))
+                    {
+                        if (ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0)
+                        {
+                            //foreach (DataRow row in ds.Tables[0].Rows)
+                            if (ds.Tables[0].Rows.Count > 0)
+                            {
+                                try
+                                {
+                                    templates.Add(new TestObjectTemplate(ds.Tables[0].Rows[0], ref db, ref errors));
+                                }
+                                catch (Exception)
+                                {
+                                    //DTS.Utilities.Logging.APILogger.Log("Failed to retrieve template", ex2);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            catch (Exception) { /*DTS.Utilities.Logging.APILogger.Log("failed to get all templates", ex);*/ }
+
+            return templates.Count > 0 ? templates[0] : null;
+        }
+    }
+}

DataPRO/Modules/PreviousDBVersions/Version57/DatabaseExport/ISO/TestObjectTemplateChannel.cs

@@ -0,0 +1,588 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Runtime.Serialization;
+using System.Data;
+
+namespace DatabaseExport
+{
+    public class TestObjectTemplateChannel //: INotifyPropertyChanged
+    {
+        public const string NONISOCHANNELTYPE = "NONISO";
+        private List<string> _channelPropertyNames = new List<string>();
+        private Dictionary<string, ChannelProperty> _channelProperties = new Dictionary<string, ChannelProperty>();
+        protected object GetProperty(string name, object defaultValue)
+        {
+            if (!_channelProperties.ContainsKey(name)) { _channelProperties[name] = new ChannelProperty(name, defaultValue); }
+            return _channelProperties[name].Value;
+        }
+        protected void SetProperty(string name, object value)
+        {
+            if (!_channelProperties.ContainsKey(name)) { _channelProperties[name] = new ChannelProperty(name, value); }
+            else { _channelProperties[name].Value = value; }
+            //OnPropertyChanged("name"); // ? variable name instead of "name"
+        }
+
+        public MMEPossibleChannels Channel { get; }
+
+        public const string SEPARATOR = "_X_";
+        private bool _bRequired = false;
+
+        /// <summary>
+        /// Required channel property raises the OnRequiredChanged event 
+        /// </summary>
+        public bool Required
+        {
+            get => _bRequired;
+            set
+            {
+                _bRequired = value;
+                //OnRequiredChanged(new RequiredChangedEventArgs { NewValue = value });
+                _bRequired = value;
+            }
+        }
+
+        public bool LocalOnly { get; set; } = false;
+
+        public enum ReferenceChannelTypes { IMPLICIT, EXPLICIT, NOVALUE };
+
+        public enum DataSourceTypes
+        {
+            Transducer,
+            Calculation,
+            Camera,
+            Simulation,
+            Parameter
+        };
+
+        public enum DataStatusTypes
+        {
+            OK,
+            ChannelFailed,
+            MeaninglessData,
+            NoData,
+            QuestionableData,
+            ScalingFactorApplied,
+            SystemFailed,
+            LinearisedData,
+            NOVALUE
+        }
+
+        public enum StandardChannelProperties
+        {
+            /*TestObjectNumber,*/
+            NameOfTheChannel,
+            /*LaboratoryChannelCode,
+            CustomerChannelCode,
+            ChannelCode,
+            Comments1,
+            Location,
+            Dimension,
+            Direction,
+            ChannelFrequencyClass,
+            Unit,
+            ReferenceSystem,
+            TransducerType,
+            TransducerId,
+            PreFilterType,
+            CutOffFrequency,
+            ChannelAmplitudeClass,
+            ReferenceChannel,
+            ReferenceChannelName,
+            DataSource,
+            DataStatus,
+            SamplingInterval,
+            BitResolution,
+            TimeOfFirstSample,
+            NumberOfSamples,
+            OffsetPostTest,
+            TransducerNaturalFrequency,
+            TransducerDampingRatio,
+            Comments2,
+            FirstGlobalMaximumValue,
+            TimeOfMaximumValue,
+            FirstGlobalMinimumValue,
+            TimeOfMinimumValue,
+            StartOffsetInterval,
+            EndOffsetInterval,*/
+            DisplayOrder
+        }
+        public override string ToString()
+        {
+            if (null != Channel) { return string.Format("{0}({1})", Name, Channel.Id); }
+            else { return Name; }
+        }
+        public TestObjectTemplateChannel(DataRow dr, ISO.TestObjectTemplate template, ref ISO13499FileDb db)
+        {
+            _template = template;
+            AddStandardProperties();
+            /*_channelProperties[StandardChannelProperties.TestObjectNumber.ToString()].Value = (string)dr["TestObjectNumber"];*/
+            _channelProperties[StandardChannelProperties.NameOfTheChannel.ToString()].Value = (string)dr["NameOfTheChannel"];
+            /*_channelProperties[StandardChannelProperties.LaboratoryChannelCode.ToString()].Value = (string)dr["LaboratoryChannelCode"];
+            _channelProperties[StandardChannelProperties.CustomerChannelCode.ToString()].Value = (string)dr["CustomerChannelCode"];
+            _channelProperties[StandardChannelProperties.Comments1.ToString()].Value = (string)dr["Comments1"];
+            _channelProperties[StandardChannelProperties.Location.ToString()].Value = (string)dr["Location"];
+            _channelProperties[StandardChannelProperties.Dimension.ToString()].Value = (string)dr["Dimension"];
+            _channelProperties[StandardChannelProperties.Direction.ToString()].Value = (string)dr["Direction"];
+            _channelProperties[StandardChannelProperties.ChannelFrequencyClass.ToString()].Value = (string)dr["ChannelFrequencyClass"];
+            _channelProperties[StandardChannelProperties.Unit.ToString()].Value = (string)dr["Unit"];
+            _channelProperties[StandardChannelProperties.ReferenceSystem.ToString()].Value = (string)dr["ReferenceSystem"];
+            _channelProperties[StandardChannelProperties.TransducerType.ToString()].Value = (string)dr["TransducerType"];
+            _channelProperties[StandardChannelProperties.TransducerId.ToString()].Value = (string)dr["TransducerId"];
+            _channelProperties[StandardChannelProperties.PreFilterType.ToString()].Value = (string)dr["PreFilterType"];
+            _channelProperties[StandardChannelProperties.CutOffFrequency.ToString()].Value = (string)dr["CutOffFrequency"];
+            _channelProperties[StandardChannelProperties.ChannelAmplitudeClass.ToString()].Value = (string)dr["ChannelAmplitudeClass"];
+            _channelProperties[StandardChannelProperties.ReferenceChannel.ToString()].Value = (ReferenceChannelTypes)Enum.Parse(typeof(ReferenceChannelTypes), (string)dr["ReferenceChannel"]);
+            _channelProperties[StandardChannelProperties.ReferenceChannelName.ToString()].Value = (string)dr["ReferenceChannelName"];
+            _channelProperties[StandardChannelProperties.DataSource.ToString()].Value = (DataSourceTypes)Enum.Parse(typeof(DataSourceTypes), (string)dr["DataSource"]);
+            _channelProperties[StandardChannelProperties.DataStatus.ToString()].Value = (DataStatusTypes)Enum.Parse(typeof(DataStatusTypes), (string)dr["DataStatus"]);
+            _channelProperties[StandardChannelProperties.SamplingInterval.ToString()].Value = (string)dr["SamplingInterval"];
+            _channelProperties[StandardChannelProperties.BitResolution.ToString()].Value = (string)dr["BitResolution"];
+            _channelProperties[StandardChannelProperties.TimeOfFirstSample.ToString()].Value = (string)dr["TimeOfFirstSample"];
+            _channelProperties[StandardChannelProperties.NumberOfSamples.ToString()].Value = (string)dr["NumberOfSamples"];
+            _channelProperties[StandardChannelProperties.OffsetPostTest.ToString()].Value = (string)dr["OffsetPostTest"];
+            _channelProperties[StandardChannelProperties.TransducerNaturalFrequency.ToString()].Value = (string)dr["TransducerNaturalFrequency"];
+            _channelProperties[StandardChannelProperties.TransducerDampingRatio.ToString()].Value = (string)dr["TransducerDampingRatio"];
+            _channelProperties[StandardChannelProperties.Comments2.ToString()].Value = (string)dr["Comments"];
+            _channelProperties[StandardChannelProperties.FirstGlobalMaximumValue.ToString()].Value = (string)dr["FirstGlobalMaximumValue"];
+            _channelProperties[StandardChannelProperties.TimeOfMaximumValue.ToString()].Value = (string)dr["TimeOfMaximumValue"];
+            _channelProperties[StandardChannelProperties.FirstGlobalMinimumValue.ToString()].Value = (string)dr["FirstGlobalMinimumValue"];
+            _channelProperties[StandardChannelProperties.TimeOfMinimumValue.ToString()].Value = (string)dr["TimeOfMinimumValue"];
+            _channelProperties[StandardChannelProperties.StartOffsetInterval.ToString()].Value = (string)dr["StartOffsetInterval"];
+            _channelProperties[StandardChannelProperties.EndOffsetInterval.ToString()].Value = (string)dr["EndOffsetInterval"];
+            */
+            _channelProperties[StandardChannelProperties.DisplayOrder.ToString()].Value = 0;
+            if (!DBNull.Value.Equals(dr["DisplayOrder"]))
+            {
+                _channelProperties[StandardChannelProperties.DisplayOrder.ToString()].Value = Convert.ToInt32(dr["DisplayOrder"]).ToString(System.Globalization.CultureInfo.InvariantCulture);
+            }
+            _bRequired = Convert.ToBoolean(dr["Required"]);
+            LocalOnly = Convert.ToBoolean(dr["LocalOnly"]);
+            var channelId = Convert.ToInt64(dr["MMEChannelId"]);
+            var channelType = Convert.ToInt32(dr["MMEChannelType"]);
+            Channel = db.GetPossibleChannel(channelId, channelType);
+        }
+        private void AddStandardProperties()
+        {
+            if (null != _channelProperties) { _channelProperties.Clear(); _channelProperties = null; }
+            _channelProperties = new Dictionary<string, ChannelProperty>();
+            var scp = Enum.GetValues(typeof(StandardChannelProperties)).Cast<StandardChannelProperties>().ToArray();
+            foreach (var p in scp)
+            {
+                ChannelProperty cp = null;
+                switch (p)
+                {
+                    /*case StandardChannelProperties.BitResolution:
+                        cp = new ChannelProperty("Bit resolution", "16");
+                        break;
+                    case StandardChannelProperties.ChannelAmplitudeClass:
+                        cp = new ChannelProperty("Channel amplitude class", "NOVALUE");
+                        break;
+                    case StandardChannelProperties.ChannelCode:
+                        cp = new ChannelProperty("Channel code", "NOVALUE");
+                        break;
+                    case StandardChannelProperties.ChannelFrequencyClass:
+                        cp = new ChannelProperty("Channel frequency class", "NOVALUE");
+                        break;
+                    case StandardChannelProperties.Comments1:
+                        cp = new ChannelProperty("Comments", "NOVALUE");
+                        break;*/
+                    case StandardChannelProperties.DisplayOrder:
+                        cp = new ChannelProperty(p.ToString(), "0");
+                        break;
+                    /*case StandardChannelProperties.Comments2:
+                        cp = new ChannelProperty("Comments", "NOVALUE");
+                        break;
+                    case StandardChannelProperties.CustomerChannelCode:
+                        cp = new ChannelProperty("Customer channel code", "NOVALUE");
+                        break;
+                    case StandardChannelProperties.CutOffFrequency:
+                        cp = new ChannelProperty("Cut off frequency", "NOVALUE");
+                        break;
+                    case StandardChannelProperties.DataSource:
+                        cp = new ChannelProperty("Data source", DataSourceTypes.Transducer);
+                        break;
+                    case StandardChannelProperties.DataStatus:
+                        cp = new ChannelProperty("Data status", DataStatusTypes.NOVALUE);
+                        break;
+                    case StandardChannelProperties.Dimension:
+                        cp = new ChannelProperty("Dimension", "NOVALUE");
+                        break;
+                    case StandardChannelProperties.Direction:
+                        cp = new ChannelProperty("Direction", "NOVALUE");
+                        break;
+                    case StandardChannelProperties.EndOffsetInterval:
+                        cp = new ChannelProperty("End Offset Interval", "NOVALUE");
+                        break;
+                    case StandardChannelProperties.FirstGlobalMaximumValue:
+                        cp = new ChannelProperty("First global maximum value", "NOVALUE");
+                        break;
+                    case StandardChannelProperties.FirstGlobalMinimumValue:
+                        cp = new ChannelProperty("First global minimum value", "NOVALUE");
+                        break;
+                    case StandardChannelProperties.LaboratoryChannelCode:
+                        cp = new ChannelProperty("Laboratory channel code", "NOVALUE");
+                        break;
+                    case StandardChannelProperties.Location:
+                        cp = new ChannelProperty("Location", "NOVALUE");
+                        break;*/
+                    case StandardChannelProperties.NameOfTheChannel:
+                        cp = new ChannelProperty("Name of the channel", "NOVALUE");
+                        break;
+                    /*case StandardChannelProperties.NumberOfSamples:
+                        cp = new ChannelProperty("Number of samples", "NOVALUE");
+                        break;
+                    case StandardChannelProperties.OffsetPostTest:
+                        cp = new ChannelProperty("Offset post test", "NOVALUE");
+                        break;
+                    case StandardChannelProperties.PreFilterType:
+                        cp = new ChannelProperty("Pre-filter type", "NOVALUE");
+                        break;
+                    case StandardChannelProperties.ReferenceChannel:
+                        cp = new ChannelProperty("Reference channel", ReferenceChannelTypes.NOVALUE);
+                        break;
+                    case StandardChannelProperties.ReferenceChannelName:
+                        cp = new ChannelProperty("Reference channel name", "NOVALUE");
+                        break;
+                    case StandardChannelProperties.ReferenceSystem:
+                        cp = new ChannelProperty("Reference system", "NOVALUE");
+                        break;
+                    case StandardChannelProperties.SamplingInterval:
+                        cp = new ChannelProperty("Sampling interval", "NOVALUE");
+                        break;
+                    case StandardChannelProperties.StartOffsetInterval:
+                        cp = new ChannelProperty("Start offset interval", "NOVALUE");
+                        break;
+                    case StandardChannelProperties.TestObjectNumber:
+                        cp = new ChannelProperty("Test object number", "NOVALUE");
+                        break;
+                    case StandardChannelProperties.TimeOfFirstSample:
+                        cp = new ChannelProperty("Time of first sample", "NOVALUE");
+                        break;
+                    case StandardChannelProperties.TimeOfMaximumValue:
+                        cp = new ChannelProperty("Time of maximum value", "NOVALUE");
+                        break;
+                    case StandardChannelProperties.TimeOfMinimumValue:
+                        cp = new ChannelProperty("Time of minimum value", "NOVALUE");
+                        break;
+                    case StandardChannelProperties.TransducerDampingRatio:
+                        cp = new ChannelProperty("Transducer damping ratio", "NOVALUE");
+                        break;
+                    case StandardChannelProperties.TransducerId:
+                        cp = new ChannelProperty("Transducer id", "NOVALUE");
+                        break;
+                    case StandardChannelProperties.TransducerNaturalFrequency:
+                        cp = new ChannelProperty("Transducer natural frequency", "NOVALUE");
+                        break;
+                    case StandardChannelProperties.TransducerType:
+                        cp = new ChannelProperty("Transducer type", "NOVALUE");
+                        break;
+                    case StandardChannelProperties.Unit:
+                        cp = new ChannelProperty("Unit", "NOVALUE");
+                        break;*/
+                    default:
+                        cp = new ChannelProperty(p.ToString(), "NOVALUE");
+                        break;
+                }
+                _channelProperties.Add(p.ToString(), cp);
+            }
+        }
+        public TestObjectTemplateChannel(TestObjectTemplateChannel copy, ISO.TestObjectTemplate template)
+        {
+            LocalOnly = copy.LocalOnly;
+            _bRequired = copy.Required;
+            Channel = new MMEPossibleChannels(copy.Channel);
+            _channelProperties = new Dictionary<string, ChannelProperty>();
+            var e = copy._channelProperties.GetEnumerator();
+            while (e.MoveNext())
+            {
+                _channelProperties[e.Current.Key] = new ChannelProperty(e.Current.Value);
+            }
+            _channelPropertyNames = new List<string>(copy._channelPropertyNames.ToArray());
+            _template = template;
+        }
+        public TestObjectTemplateChannel(MMEPossibleChannels channel)
+        {
+            Channel = channel;
+            AddStandardProperties();
+            var scp = Enum.GetValues(typeof(StandardChannelProperties)).Cast<StandardChannelProperties>().ToArray();
+            foreach (var p in scp)
+            {
+                switch (p)
+                {
+                    case StandardChannelProperties.DisplayOrder:
+                        _channelProperties[StandardChannelProperties.DisplayOrder.ToString()].Value = (Convert.ToInt32(Channel.Id)).ToString(System.Globalization.CultureInfo.InvariantCulture);
+                        break;
+                    case StandardChannelProperties.NameOfTheChannel:
+                        break;
+                    /*case StandardChannelProperties.BitResolution:
+                    case StandardChannelProperties.ChannelAmplitudeClass:
+                    case StandardChannelProperties.ChannelCode:
+                    case StandardChannelProperties.ChannelFrequencyClass:
+                    case StandardChannelProperties.Comments1:
+                    case StandardChannelProperties.Comments2:
+                    case StandardChannelProperties.CustomerChannelCode:
+                    case StandardChannelProperties.CutOffFrequency:
+                    case StandardChannelProperties.DataSource:
+                    case StandardChannelProperties.DataStatus:
+                        break;
+                    case StandardChannelProperties.Dimension:
+                        _channelProperties[StandardChannelProperties.Dimension.ToString()].Value = _channel.Physical_Dimension;
+                        break;
+                    case StandardChannelProperties.Direction:
+                        _channelProperties[StandardChannelProperties.Direction.ToString()].Value = _channel.Direction;
+                        break;
+                    case StandardChannelProperties.EndOffsetInterval:
+                    case StandardChannelProperties.FirstGlobalMaximumValue:
+                    case StandardChannelProperties.FirstGlobalMinimumValue:
+                    case StandardChannelProperties.LaboratoryChannelCode:
+                        break;
+                    case StandardChannelProperties.Location:
+                        _channelProperties[StandardChannelProperties.Location.ToString()].Value = _channel.Trans_Main_Loc;
+                        break;
+                    case StandardChannelProperties.NumberOfSamples:
+                    case StandardChannelProperties.OffsetPostTest:
+                    case StandardChannelProperties.PreFilterType:
+                    case StandardChannelProperties.ReferenceChannel:
+                    case StandardChannelProperties.ReferenceChannelName:
+                    case StandardChannelProperties.ReferenceSystem:
+                    case StandardChannelProperties.SamplingInterval:
+                    case StandardChannelProperties.StartOffsetInterval:
+                    case StandardChannelProperties.TestObjectNumber:
+                    case StandardChannelProperties.TimeOfFirstSample:
+                    case StandardChannelProperties.TimeOfMaximumValue:
+                    case StandardChannelProperties.TimeOfMinimumValue:
+                    case StandardChannelProperties.TransducerDampingRatio:
+                    case StandardChannelProperties.TransducerId:
+                    case StandardChannelProperties.TransducerNaturalFrequency:
+                    case StandardChannelProperties.TransducerType:
+                    case StandardChannelProperties.Unit:*/
+                    default:
+                        break;
+                }
+            }
+        }
+
+        private ISO.TestObjectTemplate _template;
+        public void SetTemplate(ISO.TestObjectTemplate template) { _template = template; }
+        public string Name
+        {
+            get
+            {
+                var tokens = Channel.Text_L1.Split(new string[] { SEPARATOR }, StringSplitOptions.None);
+                return tokens.Last();
+            }
+        }
+        public const string TEST_SPECIFIC_DOUT = "TSD_";
+        public string NameOfTheChannel
+        {
+            get
+            {
+                var s = _channelProperties[StandardChannelProperties.NameOfTheChannel.ToString()].Value as string;
+                if (string.IsNullOrWhiteSpace(s) || s == DataStatusTypes.NOVALUE.ToString())
+                {
+                    if (Name.StartsWith(TEST_SPECIFIC_DOUT))
+                    {
+                        return "(Digital Output Setting)";
+                    }
+                    else { return Name; }
+                }
+                return s;
+            }
+            set => _channelProperties[StandardChannelProperties.NameOfTheChannel.ToString()].Value = value;
+        }
+        public string LaboratoryCode
+        {
+            get => DataStatusTypes.NOVALUE.ToString();
+            set {; }
+        }
+        public string CustomerChannelCode
+        {
+            get => DataStatusTypes.NOVALUE.ToString();
+            set {; }
+        }
+        public int DisplayOrder
+        {
+            get => Convert.ToInt32(_channelProperties[StandardChannelProperties.DisplayOrder.ToString()].Value, System.Globalization.CultureInfo.InvariantCulture);
+            set => _channelProperties[StandardChannelProperties.DisplayOrder.ToString()].Value = value.ToString(System.Globalization.CultureInfo.InvariantCulture);
+        }
+        public string Comments1
+        {
+            get => DataStatusTypes.NOVALUE.ToString();
+            set {; }
+        }
+        public string Location
+        {
+            get => DataStatusTypes.NOVALUE.ToString();
+            set {; }
+        }
+        public string Dimension
+        {
+            get => DataStatusTypes.NOVALUE.ToString();
+            set {; }
+        }
+        public string Direction
+        {
+            get => DataStatusTypes.NOVALUE.ToString();
+            set {; }
+        }
+        public string ChannelFrequencyClass
+        {
+            get => DataStatusTypes.NOVALUE.ToString();
+            set {; }
+        }
+        public string Unit
+        {
+            get => DataStatusTypes.NOVALUE.ToString();
+            set {; }
+        }
+        public string ReferenceSystem
+        {
+            get => DataStatusTypes.NOVALUE.ToString();
+            set {; }
+        }
+        public string TestObjectNumber
+        {
+            get => DataStatusTypes.NOVALUE.ToString();
+            set {; }
+        }
+        public string TransducerType
+        {
+            get => DataStatusTypes.NOVALUE.ToString();
+            set {; }
+        }
+        public string TransducerId
+        {
+            get => DataStatusTypes.NOVALUE.ToString();
+            set {; }
+        }
+        public string PreFilterType
+        {
+            get => DataStatusTypes.NOVALUE.ToString();
+            set {; }
+        }
+        public string CutOffFrequency
+        {
+            get => DataStatusTypes.NOVALUE.ToString();
+            set {; }
+        }
+        public string ChannelAmplitudeClass
+        {
+            get => DataStatusTypes.NOVALUE.ToString();
+            set {; }
+        }
+        public ReferenceChannelTypes ReferenceChannel
+        {
+            get => ReferenceChannelTypes.NOVALUE;
+            set {; }
+        }
+        public string ReferenceChannelName
+        {
+            get => DataStatusTypes.NOVALUE.ToString();
+            set {; }
+        }
+        public DataSourceTypes DataSource
+        {
+            get => DataSourceTypes.Parameter;
+            set {; }
+        }
+        public DataStatusTypes DataStatus
+        {
+            get => DataStatusTypes.NOVALUE;
+            set {; }
+        }
+        public string SamplingInterval
+        {
+            get => DataStatusTypes.NOVALUE.ToString();
+            set {; }
+        }
+        public string BitResolution
+        {
+            get => DataStatusTypes.NOVALUE.ToString();
+            set {; }
+        }
+        public string TimeOfFirstSample
+        {
+            get => DataStatusTypes.NOVALUE.ToString();
+            set {; }
+        }
+        public string NumberOfSamples
+        {
+            get => DataStatusTypes.NOVALUE.ToString();
+            set {; }
+        }
+        public string OffsetPostTest
+        {
+            get => DataStatusTypes.NOVALUE.ToString();
+            set {; }
+        }
+        public string TransducerNaturalFrequency
+        {
+            get => DataStatusTypes.NOVALUE.ToString();
+            set {; }
+        }
+        public string TransducerDampingRatio
+        {
+            get => DataStatusTypes.NOVALUE.ToString();
+            set {; }
+        }
+        public string Comments2
+        {
+            get => DataStatusTypes.NOVALUE.ToString();
+            set {; }
+        }
+        public string FirstGlobalMaximumValue
+        {
+            get => DataStatusTypes.NOVALUE.ToString();
+            set {; }
+        }
+
+        public string TimeOfMaximumValue
+        {
+            get => DataStatusTypes.NOVALUE.ToString();
+            set {; }
+        }
+        public string FirstGlobalMinimumValue
+        {
+            get => DataStatusTypes.NOVALUE.ToString();
+            set {; }
+        }
+        public string TimeOfMinimumValue
+        {
+            get => DataStatusTypes.NOVALUE.ToString();
+            set {; }
+        }
+        public string StartOffsetInterval
+        {
+            get => DataStatusTypes.NOVALUE.ToString();
+            set {; }
+        }
+        public string EndOffsetInterval
+        {
+            get => DataStatusTypes.NOVALUE.ToString();
+            set {; }
+        }
+        public class ChannelProperty : ISerializable
+        {
+            public string Name { get; }
+
+            public object Value { get; set; } = "NOVALUE";
+
+            public ChannelProperty(ChannelProperty copy)
+            {
+                Name = copy.Name;
+                Value = copy.Value;
+            }
+            public ChannelProperty(string name, object value)
+            {
+                Name = name;
+                Value = value;
+            }
+            public void GetObjectData(SerializationInfo info, StreamingContext context)
+            {
+                info.AddValue("PropertyName", Name);
+                info.AddValue("PropertyValue", Value, Value.GetType());
+            }
+        }
+    }
+}

DataPRO/Modules/PreviousDBVersions/Version57/DatabaseExport/ISO/TestSetting.cs

@@ -0,0 +1,148 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace DatabaseExport
+{
+    /// <summary>
+    /// a simple setting in a test
+    /// can have a default value, a value, and an id
+    /// default value is used by TestSettingsDictionary for when
+    /// the setting doesn't currently exist or have a value
+    /// </summary>
+    public class TestSetting
+    {
+        public string Id { get; }
+
+        public string Value { get; set; }
+
+        public string DefaultValue { get; }
+
+        private const string SEPARATOR = "_x_";
+        public TestSetting(TestSetting copy, string value)
+        {
+            Id = copy.Id;
+            DefaultValue = copy.DefaultValue;
+            Value = value;
+        }
+        public TestSetting(TestSetting copy)
+        {
+            Id = copy.Id;
+            DefaultValue = copy.DefaultValue;
+            Value = copy.Value;
+        }
+        public TestSetting(string id, string value, string defaultValue)
+        {
+            Id = id;
+            Value = value;
+            DefaultValue = defaultValue;
+        }
+        public string ToSerializeString()
+        {
+            System.Diagnostics.Trace.Assert(Id.IndexOf(SEPARATOR) < 0);
+            return string.Format("{0}={1}", Id.Replace("=", SEPARATOR), Value.Replace("=", SEPARATOR));
+        }
+
+        public static bool TryParse(string s, out TestSetting ts)
+        {
+            ts = null;
+
+            var tokens = s.Split(new[] { "=" }, StringSplitOptions.None);
+            if (tokens.Length < 2) { return false; }
+            var id = tokens[0].Replace(SEPARATOR, "=");
+            var val = tokens[1].Replace(SEPARATOR, "=");
+            ts = new TestSetting(id, val, val);
+            return true;
+        }
+    }
+    /// <summary>
+    /// holds all possible settings for a test
+    /// </summary>
+    public class TestSettingDictionary
+    {
+        public TestSettingDictionary()
+        {
+        }
+        public TestSettingDictionary(TestSettingDictionary copy)
+        {
+            var e = copy._lookup.GetEnumerator();
+            while (e.MoveNext())
+            {
+                _lookup[e.Current.Key] = new TestSetting(e.Current.Value);
+            }
+        }
+        private const string _SEPARATOR = "_X_";
+        private Dictionary<string, TestSetting> _lookup = new Dictionary<string, TestSetting>();
+        public string GetValue(string ID, string defaultValue)
+        {
+            if (!_lookup.ContainsKey(ID)) { return defaultValue; }
+            else
+            {
+                if (null == _lookup[ID].Value) { return _lookup[ID].DefaultValue; }
+                else { return _lookup[ID].Value; }
+            }
+        }
+        public void UnLoad()
+        {
+            _lookup.Clear();
+        }
+        /// <summary>
+        /// used to change the value in the dictionary (just the value, leave everything else the same)
+        /// </summary>
+        /// <param name="setting"></param>
+        /// <param name="value"></param>
+        public void SetValue(TestSetting setting, string value)
+        {
+            //we do it this way to avoid Add() and also to avoid accidentally reusing the input setting inappropriately
+            _lookup[setting.Id] = new TestSetting(setting, value);
+        }
+        /// <summary>
+        /// used to initialize a value in the dictionary
+        /// </summary>
+        /// <param name="setting"></param>
+        public void SetValue(TestSetting setting)
+        {
+            _lookup[setting.Id] = setting;
+        }
+        public void SetValue(string id, string value)
+        {
+            if (!_lookup.ContainsKey(id))
+            {
+                _lookup[id] = new TestSetting(id, value, value);
+            }
+            else { _lookup[id].Value = value; }
+        }
+        public string ToSerializeString()
+        {
+            var sb = new StringBuilder();
+            foreach (var s in _lookup.Values)
+            {
+                var sVal = s.ToSerializeString();
+                System.Diagnostics.Trace.Assert(sVal.IndexOf(_SEPARATOR) < 0);
+                sVal = sVal.Replace(System.Globalization.CultureInfo.InvariantCulture.TextInfo.ListSeparator, _SEPARATOR);
+                if (sb.Length > 0) { sb.Append(System.Globalization.CultureInfo.InvariantCulture.TextInfo.ListSeparator); }
+                sb.Append(sVal);
+            }
+            return sb.ToString();
+        }
+        public void LoadSettings(string s)
+        {
+            var tokens = s.Split(new[] { System.Globalization.CultureInfo.InvariantCulture.TextInfo.ListSeparator }, StringSplitOptions.None);
+            foreach (var token in tokens)
+            {
+                var tok = token.Replace(_SEPARATOR, System.Globalization.CultureInfo.InvariantCulture.TextInfo.ListSeparator);
+                TestSetting ts;
+                //we prefer the default settings from the application
+                //if for some reason this key is no longer used, we can still stick it in the storage and use it as is
+                if (TestSetting.TryParse(tok, out ts))
+                {
+                    if (!_lookup.ContainsKey(ts.Id))//no longer has a default setting, just use as is
+                    {
+                        _lookup[ts.Id] = ts;
+                    }
+                    else { _lookup[ts.Id].Value = ts.Value; }//default setting exists, just set the value
+                }
+            }
+        }
+    }
+}