init

Common/DTS.Common.Serialization/.svn/pristine/9e/9e2a512a04659227f97472c0f1d866ae3fab2af1.svn-base

@@ -0,0 +1,344 @@
+
+/*
+ * SliceRaw.File.cs
+ * 
+ * Copyright © 2009
+ * Diversified Technical Systems, Inc.
+ * All Rights Reserved
+ */
+
+using System;
+using System.IO;
+using DTS.Common.Utilities.DotNetProgrammingConstructs;
+using DTS.Common.Utilities.Logging;
+using System.Linq;
+
+namespace DTS.Serialization.SliceRaw
+{   ///
+    /// <summary>
+    ///  Representation of a SliceRaw-type serialization. 
+    /// </summary>
+    /// 
+    public partial class File
+        : Serialization.File, IReadable<Test>, IWritable<Test>
+    {   ///
+        /// <summary>
+        /// Initialize an instance of the SliceRaw.File class.
+        /// </summary>
+        /// 
+        public File()
+            : base("Slice Raw")
+        {
+        }
+
+        /// <summary>
+        /// Get the file writer for this file type.
+        /// </summary>
+        public IWriter<Test> Exporter
+        {
+            get
+            {
+                try
+                {
+                    if (_Exporter == null)
+                        _Exporter = new Writer(this, DefaultEncoding);
+                    return _Exporter;
+                }
+
+                catch (System.Exception ex)
+                {
+                    throw new Exception("encountered problem getting exporter", ex);
+                }
+            }
+        }
+        private IWriter<Test> _Exporter = null;
+
+        /// <summary>
+        /// Get the file reader for this file type.
+        /// </summary>
+        public IReader<Test> Importer
+        {
+            get
+            {
+                try
+                {
+                    if (_Importer == null)
+                        _Importer = new Reader(this);
+                    return _Importer;
+                }
+
+                catch (System.Exception ex)
+                {
+                    throw new Exception("encountered problem getting importer", ex);
+                }
+            }
+        }
+        private IReader<Test> _Importer = null;
+
+        /// <summary>
+        /// File extension for the disk entity that contains the serialized test information.
+        /// </summary>
+        public static string TestFileExtension
+        {
+            get => _TestFileExtension.Value;
+            private set => _TestFileExtension.Value = value;
+        }
+        private static readonly Property<string> _TestFileExtension = new Property<string>("TestFileExtension", ".dts", true);
+
+        /// <summary>
+        /// File extension for the disk entity that contains serialized channel information.
+        /// </summary>
+        public static string ChannelFileExtension
+        {
+            get => _ChannelFileExtension.Value;
+            private set => _ChannelFileExtension.Value = value;
+        }
+        private static readonly Property<string> _ChannelFileExtension = new Property<string>("ChannelFileExtension", ".chn", true);
+
+        /// <summary>
+        /// File extension for the disk entity that contains serialized channel information.
+        /// </summary>
+        public static string CalculatedChannelFileExtension
+        {
+            get => _CalculatedChannelFileExtension.Value;
+            private set => _CalculatedChannelFileExtension.Value = value;
+        }
+        private static readonly Property<string> _CalculatedChannelFileExtension = new Property<string>("CalculatedChannelFileExtension", ".cchn", true);
+
+        /// <summary>
+        /// File extension for the disk entity that contains binary information.
+        /// </summary>
+        public static string BinaryFileExtension
+        {
+            get => _BinaryFileExtension.Value;
+            private set => _BinaryFileExtension.Value = value;
+        }
+        private static readonly Property<string> _BinaryFileExtension = new Property<string>("BinaryFileExtension", ".bin", true);
+
+        /// <summary>
+        /// File extension for the disk entity that contains NMEA information.
+        /// </summary>
+        public static string NMEAFileExtension
+        {
+            get => _NMEAFileExtension.Value;
+            private set => _NMEAFileExtension.Value = value;
+        }
+        private static readonly Property<string> _NMEAFileExtension = new Property<string>("NMEAFileExtension", ".nmea", true);
+
+        /// <summary>
+        /// File extension for the disk entity that contains plaintext information.
+        /// </summary>
+        public static string PlainTextFileExtension
+        {
+            get => _PlainTextFileExtension.Value;
+            private set => _PlainTextFileExtension.Value = value;
+        }
+        private static readonly Property<string> _PlainTextFileExtension = new Property<string>("PlainTextFileExtension", ".txt", true);
+
+        /// <summary>
+        /// File extension for the disk entity that contains module timestamp information.
+        /// </summary>
+        public static string DasTimestampFileExtension
+        {
+            get => _DasTimestampFileExtension.Value;
+            private set => _DasTimestampFileExtension.Value = value;
+        }
+        private static readonly Property<string> _DasTimestampFileExtension = new Property<string>("DasTimestampFileExtension", ".bin", true);
+
+        /// <summary>
+        /// The string that separates the channel numbers from the riffraff.
+        /// </summary>
+        public const string ChannelNumberDelimiter = ".";
+
+        public const string AbsoluteDisplayOrderDelimiter = "Ch";
+        /// <summary>
+        /// Extract the channel file number from the specified channel name string.
+        /// </summary>
+        /// 
+        /// <param name="testName">
+        /// The test name <see cref="string"/> to be incorporated into the channel filename.
+        /// </param>
+        /// 
+        /// <param name="channelNumber">
+        /// The <see cref="int"/> channel number to be incorporated into the channel filename.
+        /// </param>
+        /// 
+        /// <returns>
+        /// A channel filename <see cref="string"/> that uniquely identifies test and channel
+        /// that this channel informtion belongs to.
+        /// </returns>
+        /// 
+        public string GetChannelFileNameFromTestNameAndChannelNumber(string testName, int channelNumber, int absoluteDisplayOrder)
+        {
+            try
+            {
+                if (string.IsNullOrEmpty(testName))
+                    throw new ArgumentException("cannot construct channel file name from null/empty test name string");
+                else
+                    return string.Format("{0}{5}{1:000}{2}{3:000}{4}",
+                        testName, 1 + absoluteDisplayOrder, ChannelNumberDelimiter, channelNumber, ChannelFileExtension, AbsoluteDisplayOrderDelimiter);
+            }
+            catch (System.Exception ex)
+            {
+                throw new Exception("encountered problem getting channel file name from channel number \"" + channelNumber.ToString() + "\"", ex);
+            }
+        }
+
+        /// 
+        public string GetCalculatedChannelFileNameFromTestNameAndChannelNumber(string testName, int channelNumber)
+        {
+            try
+            {
+                if (string.IsNullOrEmpty(testName))
+                    throw new ArgumentException("cannot construct channel file name from null/empty test name string");
+                return testName + ChannelNumberDelimiter + channelNumber.ToString() + CalculatedChannelFileExtension;
+            }
+            catch (System.Exception ex)
+            {
+                throw new Exception("encountered problem getting channel file name from channel number \"" + channelNumber.ToString() + "\"", ex);
+            }
+        }
+
+        /// <summary>
+        /// Extract the channel number from the specified channel filename.
+        /// </summary>
+        /// 
+        /// <param name="channelFileName">
+        /// The channel filename <see cref="string"/> to be converted into a channel number.
+        /// </param>
+        /// 
+        /// <returns>
+        /// The <see cref="int"/> channel number represented by the specified file.
+        /// </returns>
+        /// 
+        public override int GetChannelNumberFromChannelFileName(string channelFileName)
+        {
+            try
+            {
+                var indexOfExtension = channelFileName.LastIndexOf(ChannelFileExtension);
+                if (!char.IsDigit(channelFileName[indexOfExtension - 1]))
+                {
+                    //extension prefix detected, back up some more
+                    indexOfExtension = channelFileName.LastIndexOf(ChannelNumberDelimiter, indexOfExtension - 1);
+                }
+                var indexOfFirstChannelNumberCharacter = channelFileName.LastIndexOf(ChannelNumberDelimiter, indexOfExtension - 1) + 1;
+                return int.Parse(channelFileName.Substring(indexOfFirstChannelNumberCharacter, indexOfExtension - indexOfFirstChannelNumberCharacter));
+            }
+            catch (System.Exception ex)
+            {
+                throw new Exception("encountered problem getting channel number from channel file name", ex);
+            }
+        }
+
+        /// 
+        public string GetTimestampFileNameFromTestNameAndDASSerialNumber(string testName, string dasSerialNumber)
+        {
+            try
+            {
+                if (string.IsNullOrEmpty(testName))
+                    throw new ArgumentException("cannot construct das file name from null/empty test name string");
+                else
+                    return string.Format("TS-{0}{2}{1}{3}",
+                        testName, dasSerialNumber, ChannelNumberDelimiter, DasTimestampFileExtension);
+            }
+            catch (System.Exception ex)
+            {
+                throw new Exception("encountered problem getting das file name from das serial number \"" + dasSerialNumber.ToString() + "\"", ex);
+            }
+        }
+
+        public static void ReadTestSetup(string testFileName, ref Test _test, ref TestSetup _testSetup)
+        {
+            ReadTestSetup(testFileName, out _test, out _testSetup, false);
+        }
+        public static void ReadTestSetup(string testFileName, out Test test, out TestSetup testSetup,
+            bool justDTSFile)
+        {
+            var fi = new FileInfo(testFileName);
+            var directory = fi.Directory.FullName;
+            test = null;
+            testSetup = null;
+
+            var f = new Serialization.SliceRaw.File();
+            try
+            {
+                using (var reader = new StreamReader(testFileName))
+                {
+                    var allText = reader.ReadToEnd();
+                    const string delimiter = "<?xml version=";
+                    var delimiterArray = new[] { delimiter };
+                    var allTextArray = allText.Split(delimiterArray, StringSplitOptions.RemoveEmptyEntries);
+                    var xmlCounter = 0;
+                    foreach (var fullstring in allTextArray)
+                    {
+                        var fullString = allTextArray[xmlCounter];
+                        xmlCounter++;
+                        if (!fullString.Contains("Test")) continue;
+                        fullString = delimiter + fullString;
+                        var sr = new StringReader(fullString);
+                        var tr = new System.Xml.XmlTextReader(sr);
+                        var xmlType = fullString.Substring(fullString.IndexOf('>') + 4, 5).TrimEnd();
+                        switch (xmlType)
+                        {
+                            case "Test":
+                                try
+                                {
+                                    if (justDTSFile)
+                                    {
+                                        System.Xml.XmlDocument doc = new System.Xml.XmlDocument();
+                                        doc.LoadXml(fullString);
+
+                                        var id = (doc.ChildNodes[1] as System.Xml.XmlElement).GetAttribute("Id");
+                                        var desc =
+                                            (doc.ChildNodes[1] as System.Xml.XmlElement).GetAttribute("Description");
+                                        //FB 18312 Get the event number from xml if it's not in xaml calculate it from file name 
+                                        var eventNum = (doc.ChildNodes[1] as System.Xml.XmlElement).GetAttribute("EventNumber");
+                                        if (!string.IsNullOrWhiteSpace(eventNum))
+                                        {
+                                            var eventNumber = Convert.ToInt32(eventNum);
+                                            test = new Test(id, desc, eventNumber);
+                                        }
+                                        else
+                                        {
+                                            var fileName = fi.Name;
+                                            var segments = fileName.Split('_');
+                                            if (Array.Exists(segments, p => p.Contains(DTS.Common.Constants.EventNumber)))
+                                            {
+                                                var foundEvent = Array.Find(segments, p => p.Contains(DTS.Common.Constants.EventNumber));
+                                                var eventNumber = Convert.ToInt32(foundEvent.Replace(DTS.Common.Constants.EventNumber, ""));
+                                                test = new Test(id, desc, eventNumber);
+                                            }
+                                            else
+                                            {
+                                                test = new Test(id, desc, 0);
+                                            }
+                                        }
+                                    }
+                                    else
+                                    {
+                                        f.Importer.Read(directory, out test);
+                                    }
+                                }
+                                catch (System.Exception ex)
+                                {
+                                    APILogger.Log(ex);
+                                }
+                                break;
+                            case "TestS":
+                                testSetup = new TestSetup();
+                                var xs = new System.Xml.Serialization.XmlSerializer(testSetup.GetType());
+                                testSetup = (TestSetup)xs.Deserialize(tr);
+                                tr.Close();
+                                sr.Close();
+                                break;
+                        }
+                    }
+                }
+            }
+            catch (System.Exception ex)
+            {
+                APILogger.Log("exception in read test setup", ex);
+            }
+        }
+    }
+}