init

Common/DTS.Common.ISO/MMETestObjectWrapper.cs

@@ -0,0 +1,366 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.IO;
+using System.Xml.Serialization;
+using System.Xml;
+using System.Xml.Schema;
+using DTS.Common.XMLUtils;
+
+namespace DTS.Common.ISO
+{
+    [System.Diagnostics.CodeAnalysis.SuppressMessage("Minor Code Smell", "S101:Types should be named in PascalCase", Justification = "Acronym")]
+    public class MMETestObjectWrapper : IXmlSerializable
+    {
+        /// <summary>
+        /// part of IXmlSerializable - from MS documentation this should return null
+        /// when implementing IXmlSerializable
+        /// https://learn.microsoft.com/en-us/dotnet/api/system.xml.serialization.ixmlserializable.getschema?view=net-9.0
+        /// </summary>
+        public XmlSchema GetSchema()
+        {
+            return null;
+        }
+        /// <summary>
+        /// writes an element with a text value into xml
+        /// this is used for adding properties into the xml body for the class
+        /// </summary>
+        private void WriteField(XmlWriter writer, string field, string value)
+        {
+            if (null == writer) { throw new ArgumentException("MMETestObjectWrapper::WriteField - writer was null"); }
+            if (string.IsNullOrEmpty(field)) { return; } //nothing to add
+            writer.WriteStartElement(field);
+            writer.WriteString(value);
+            writer.WriteEndElement();
+        }
+        /// <summary>
+        /// serializes class to xml
+        /// </summary>
+        public void WriteXml(XmlWriter writer)
+        {
+            if (null == writer)
+            {
+                throw new ArgumentException("MMETestObjectWrapper::WriteXml - XmlWriter was null");
+            }
+            writer.WriteStartElement("TestObject");
+            WriteField(writer, "BarrierHeightOfTestObject", BarrierHeightOfTestObject);
+            WriteField(writer, "BarrierWidthOfTestObject", BarrierWidthOfTestObject);
+            WriteField(writer, "ClassOfTestObject", ClassOfTestObject);
+            WriteField(writer, "CodeOfTestObject", CodeOfTestObject);
+            WriteField(writer, "DriverPosition", DriverPosition);
+            WriteField(writer, "File", File);
+            WriteField(writer, "ImpactSide", ImpactSide);
+            WriteField(writer, "MMETestObjectGUID", MMETestObjectGUID);
+            WriteField(writer, "MassOfTestObject", MassOfTestObject);
+            WriteField(writer, "Name", Name);
+            WriteField(writer, "NumberOfLoadcellsOfTestObject", NumberOfLoadcellsOfTestObject);
+            WriteField(writer, "OffsetOfTestObject", OffsetOfTestObject);
+            WriteField(writer, "OriginXOfTestObject", OriginXOfTestObject);
+            WriteField(writer, "OriginYOfTestObject", OriginYOfTestObject);
+            WriteField(writer, "OriginZOfTestObject", OriginZOfTestObject);
+            WriteField(writer, "ReferenceNumberOfTestObject", ReferenceNumberOfTestObject);
+            WriteField(writer, "ReferenceSystemOfTestObject", ReferenceSystemOfTestObject);
+            WriteField(writer, "TypeOfTestObject", TypeOfTestObject);
+            WriteField(writer, "Velocity", Velocity);
+            WriteField(writer, "VelocityMeasurementUnit", VelocityMeasurementUnit);
+            WriteField(writer, "YawAngleOfTestObject", YawAngleOfTestObject);
+
+            WriteComments(writer);
+            WriteISOTestObjectChannels(writer);
+
+            WriteExtraProperties(writer);
+            writer.WriteEndElement();
+        }
+        private void WriteISOTestObjectChannels(XmlWriter writer)
+        {
+            if (null == writer) { throw new ArgumentException("MMETestObjectWrapper::WriteISOTestObjectChannels - writer was null"); }
+            writer.WriteStartElement("Channels");
+
+            if (null != ISOTestObjectChannels)
+            {
+                foreach (var channel in ISOTestObjectChannels)
+                {
+                    writer.WriteStartElement("Channel");
+                    writer.WriteString(channel);
+                    writer.WriteEndElement();
+                }
+            }
+            writer.WriteEndElement();
+        }
+        private void ReadISOTestObjectChannels(XmlReader reader)
+        {
+            if (null == reader) { throw new ArgumentException("MMETestObjectWrapper::ReadISOTestObjectChannels - reader was null"); }
+            var channels = new List<string>();
+            //if the element tag is empty there's nothing else to process, move to next node
+            if (reader.Name == "Channels" && reader.IsEmptyElement) { reader.Read(); }
+            else
+            {
+                reader.ReadStartElement("Channels");
+
+                while (reader.IsStartElement() && reader.Name == "Channel")
+                {
+                    channels.Add(DTSXMLFile.GetInnerXML(reader));
+                    reader.Read();
+                }
+
+                ISOTestObjectChannels = channels.ToArray();
+
+                reader.ReadEndElement();
+            }
+        }
+        private void ReadComments(XmlReader reader)
+        {
+            if (null == reader) { throw new ArgumentException("MMETestObjectWrapper::ReadComments - XmlReader was null"); }
+            var comments = new List<string>();
+            //if top level element is empty, nothing to process, just move to next node
+            if (reader.IsEmptyElement && reader.Name == "Comments") { reader.Read(); }
+            else
+            {
+                reader.ReadStartElement("Comments");
+
+                while( reader.IsStartElement() && reader.Name == "Comment")
+                {
+                    comments.Add(DTSXMLFile.GetInnerXML(reader));
+                }
+
+                reader.ReadEndElement();
+            }
+            Comments = comments.ToArray();
+        }
+        private void WriteComments(XmlWriter writer)
+        {
+            if (null == writer) { throw new ArgumentException("MMETestObjectWrapper::WriteComments - XmlWriter was null"); }
+            writer.WriteStartElement("Comments");
+            foreach( var comment in Comments)
+            {
+                writer.WriteStartElement("Comment");
+                writer.WriteString(comment);
+                writer.WriteEndElement();
+            }
+            writer.WriteEndElement();
+        }
+        private void ReadExtraProperties(XmlReader reader)
+        {
+            if (null == reader) { throw new ArgumentException("MMETestObjectWrapper::ReadExtraProperties - XmlReader was null"); }
+            var list = new List<KeyValuePair<string, string>>();
+            if (reader.Name == "ExtraProperties" && reader.IsEmptyElement) { reader.Read(); }
+            else
+            {
+                reader.ReadStartElement("ExtraProperties");
+
+                while (reader.IsStartElement() && reader.Name == "ExtraProperty")
+                {
+                    var key = reader.GetAttribute("Key");
+                    var value = reader.GetAttribute("Value");
+                    list.Add(new KeyValuePair<string, string>(key, value));
+                    reader.Read();
+                }
+
+                reader.ReadEndElement();
+            }
+            ExtraProperties = list.ToArray();
+        }
+        private void WriteExtraProperties(XmlWriter writer)
+        {
+            if (null == writer) { throw new ArgumentException("MMETestObjectWrapper::WriteExtraProperties - XmlWriter was null"); }
+            writer.WriteStartElement("ExtraProperties");
+
+            if (null != ExtraProperties)
+            {
+                foreach( var kvp in ExtraProperties)
+                {
+                    writer.WriteStartElement("ExtraProperty");
+
+                    writer.WriteAttributeString("Key", kvp.Key);
+                    writer.WriteAttributeString("Value", kvp.Value);
+
+                    writer.WriteEndElement();
+                }
+            }
+
+            writer.WriteEndElement();
+        }
+        
+        public void ReadXml(XmlReader reader)
+        {
+            if (null == reader) { throw new ArgumentException("MMETestObjectWrapper::ReadXml - XmlReader was null"); }
+            reader.ReadStartElement("TestObject");
+            while (reader.IsStartElement())
+            {
+                switch (reader.Name)
+                {
+                    case "BarrierHeightOfTestObject":
+                        BarrierHeightOfTestObject = DTSXMLFile.GetInnerXML(reader); break;
+                    case "BarrierWidthOfTestObject":
+                        BarrierWidthOfTestObject = DTSXMLFile.GetInnerXML(reader); break;
+                    case "ClassOfTestObject":
+                        ClassOfTestObject = DTSXMLFile.GetInnerXML(reader); break;
+                    case "CodeOfTestObject":
+                        CodeOfTestObject = DTSXMLFile.GetInnerXML(reader); break;
+                    case "DriverPosition":
+                        DriverPosition = DTSXMLFile.GetInnerXML(reader); break;
+                    case "File":
+                        File = DTSXMLFile.GetInnerXML(reader); break;
+                    case "ImpactSide":
+                        ImpactSide = DTSXMLFile.GetInnerXML(reader); break;
+                    case "MMETestObjectGUID":
+                        MMETestObjectGUID = DTSXMLFile.GetInnerXML(reader); break;
+                    case "MassOfTestObject":
+                        MassOfTestObject = DTSXMLFile.GetInnerXML(reader); break;
+                    case "Name":
+                        Name = DTSXMLFile.GetInnerXML(reader); break;
+                    case "NumberOfLoadcellsOfTestObject":
+                        NumberOfLoadcellsOfTestObject = DTSXMLFile.GetInnerXML(reader); break;
+                    case "OffsetOfTestObject":
+                        OffsetOfTestObject = DTSXMLFile.GetInnerXML(reader); break;
+                    case "OriginXOfTestObject":
+                        OriginXOfTestObject = DTSXMLFile.GetInnerXML(reader); break;
+                    case "OriginYOfTestObject":
+                        OriginYOfTestObject = DTSXMLFile.GetInnerXML(reader); break;
+                    case "OriginZOfTestObject":
+                        OriginZOfTestObject = DTSXMLFile.GetInnerXML(reader); break;
+                    case "ReferenceNumberOfTestObject":
+                        ReferenceNumberOfTestObject = DTSXMLFile.GetInnerXML(reader); break;
+                    case "ReferenceSystemOfTestObject":
+                        ReferenceSystemOfTestObject = DTSXMLFile.GetInnerXML(reader); break;
+                    case "TypeOfTestObject":
+                        TypeOfTestObject = DTSXMLFile.GetInnerXML(reader); break;
+                    case "Velocity":
+                        Velocity = DTSXMLFile.GetInnerXML(reader); break;
+                    case "VelocityMeasurementUnit":
+                        VelocityMeasurementUnit = DTSXMLFile.GetInnerXML(reader); break;
+                    case "YawAngleOfTestObject":
+                        YawAngleOfTestObject = DTSXMLFile.GetInnerXML(reader); break;
+                    case "Comments":
+                        ReadComments(reader);
+                        break;
+                    case "Channels":
+                        ReadISOTestObjectChannels(reader);
+                        break;
+                    case "ExtraProperties":
+                        ReadExtraProperties(reader);
+                        break;
+                    default:
+                        throw new ArgumentException($"MMETestObjectWrapper::ReadXml - invalid node - {reader.Name}");
+                }
+            }
+            //end of TestObject element
+            reader.ReadEndElement();
+        }
+        public string GetDirectory() { return "Test Objects"; }
+
+        public string BarrierHeightOfTestObject { get; set; } = "NOVALUE";
+
+        public string BarrierWidthOfTestObject { get; set; } = "NOVALUE";
+
+        public string ClassOfTestObject { get; set; } = "NOVALUE";
+
+        public string CodeOfTestObject { get; set; } = "NOVALUE";
+
+        public string[] Comments { get; set; } = new string[0];
+
+        public string DriverPosition { get; set; } = "NOVALUE";
+
+        public string File { get; set; } = "Not Saved Yet";
+
+        public string ImpactSide { get; set; } = "NOVALUE";
+
+        public string[] ISOTestObjectChannels { get; set; }
+
+        public string MMETestObjectGUID { get; set; } = "";
+
+        public string MassOfTestObject { get; set; } = "NOVALUE";
+
+        public string Name { get; set; } = "NOVALUE";
+
+        public string NumberOfLoadcellsOfTestObject { get; set; } = "NOVALUE";
+
+        public string OffsetOfTestObject { get; set; } = "NOVALUE";
+
+        public string OriginXOfTestObject { get; set; } = "NOVALUE";
+
+        public string OriginYOfTestObject { get; set; } = "NOVALUE";
+
+        public string OriginZOfTestObject { get; set; } = "NOVALUE";
+
+        public string ReferenceNumberOfTestObject { get; set; } = "NOVALUE";
+
+        public string ReferenceSystemOfTestObject { get; set; } = "NOVALUE";
+
+        public string TypeOfTestObject { get; set; } = "NOVALUE";
+
+        public string Velocity { get; set; } = "NOVALUE";
+
+        public string VelocityMeterPerSecond => ConvertVelocityToMeterPerSecond(Velocity, VelocityMeasurementUnit);
+
+        public string VelocityMeasurementUnit { get; set; } = "NOVALUE";
+
+        public string YawAngleOfTestObject { get; set; } = "NOVALUE";
+
+        /// <summary>
+        /// Convert Velocity to m/sec unit
+        /// </summary>
+        /// <param name="velocity"></param>
+        /// <param name="velocityUnit">VelocityUnit enum index</param>
+        /// <returns>Velocity in m/sec</returns>
+        private string ConvertVelocityToMeterPerSecond(string velocity, string velocityUnit)
+        {
+            if (velocity == "NOVALUE" || velocityUnit == "NOVALUE")
+            {
+                return velocity;
+            }
+
+            if ((DTS.Common.Enums.VelocityUnit)Convert.ToInt32(velocityUnit) == Enums.VelocityUnit.KilometerPerHour)
+            {
+                return (Convert.ToDouble(velocity) / 3.6).ToString();
+            }
+            return velocity;
+        }
+
+        public KeyValuePair<string, string>[] ExtraProperties { get; set; } = new KeyValuePair<string, string>[0];
+
+
+        public MMETestObjectWrapper()
+        {
+        }
+
+        public MMETestObjectWrapper(string location)
+        {
+            if (!location.Contains(Path.DirectorySeparatorChar) && !location.Contains(Path.AltDirectorySeparatorChar))
+            {
+                var dir = Path.Combine(Environment.CurrentDirectory, GetDirectory());
+                location = Path.Combine(dir, location);
+            }
+            File = location;
+            var serializer = new XmlSerializer(typeof(MMETestObjectWrapper));
+            using (TextReader tr = new StreamReader(location))
+            {
+                var cd = (MMETestObjectWrapper)serializer.Deserialize(tr);
+                ClassOfTestObject = cd.ClassOfTestObject;
+                CodeOfTestObject = cd.CodeOfTestObject;
+                Comments = cd.Comments;
+                DriverPosition = cd.DriverPosition;
+                ExtraProperties = cd.ExtraProperties;
+                File = cd.File;
+                ImpactSide = cd.ImpactSide;
+                MassOfTestObject = cd.MassOfTestObject;
+                MMETestObjectGUID = cd.MMETestObjectGUID;
+                Name = cd.Name;
+                ReferenceNumberOfTestObject = cd.ReferenceNumberOfTestObject;
+                Velocity = cd.Velocity;
+                VelocityMeasurementUnit = cd.VelocityMeasurementUnit;
+                OffsetOfTestObject = cd.OffsetOfTestObject;
+                BarrierWidthOfTestObject = cd.BarrierWidthOfTestObject;
+                BarrierHeightOfTestObject = cd.BarrierHeightOfTestObject;
+                YawAngleOfTestObject = cd.YawAngleOfTestObject;
+                ReferenceSystemOfTestObject = cd.ReferenceSystemOfTestObject;
+                OriginXOfTestObject = cd.OriginXOfTestObject;
+                OriginYOfTestObject = cd.OriginYOfTestObject;
+                OriginZOfTestObject = cd.OriginZOfTestObject;
+                NumberOfLoadcellsOfTestObject = cd.NumberOfLoadcellsOfTestObject;
+
+                tr.Close();
+            }
+        }
+    }
+}