init

DataPRO/IService/.svn/pristine/21/21b4306d317283c6ac806fe61ada3e7082d16767.svn-base

@@ -0,0 +1,325 @@
+
+using DASFactoryDb.Download;
+using DTS.Common.Interface.DASFactory;
+using DTS.Common.Interface.DASFactory.Config;
+using DTS.Common.Interface.DASFactory.Download;
+using DTS.Common.Interface.DownloadEvent;
+using DTS.Common.Utilities.Logging;
+using System;
+using System.Data.SqlClient;
+using System.Data.SqlTypes;
+using System.IO;
+using System.Text;
+using System.Xml;
+
+namespace DTS.DASLib.Service
+{
+
+    /// <summary>
+    /// This class represent all events stored on the DAS.  It is populated during
+    /// <see cref="DownloadService.QueryDownload" />.
+    /// </summary>
+    public class DownloadReport : IDownloadReport
+    {
+        /// <summary>
+        /// This class represent one event/test.
+        /// </summary>
+        public class EventInfo : IEventInfo
+        {
+            /// <summary>
+            /// Information about each module that was part of the event.  Addressable by
+            /// ModuleArrayIndex of the corresponding module.
+            /// </summary>
+            public IDASModule[] Modules { get; set; }
+
+            /// <summary>
+            /// The event number this information is regarding.
+            /// </summary>
+            public int EventNumber { get; set; }
+
+            /// <summary>
+            /// The GUID of the corresponding event.
+            /// </summary>
+            public Guid TestGUID { get; set; }
+
+            /// <summary>
+            /// Fault flags (if any)
+            /// </summary>
+            public ushort FaultFlags { get; set; }
+            /// <summary>
+            /// fault flags extended (if any)
+			/// </summary>
+            public ushort FaultFlagsEx { get; set; }
+
+            /// <summary>
+            /// Arm Attempts (if any)
+            /// </summary>
+            public byte ArmAttempts { get; set; }
+            /// <summary>
+            /// The timestamp of this event.
+            /// </summary>
+            public DateTime TestTime { get; set; }
+
+            /// <summary>
+            /// The ID of this event.
+            /// </summary>
+            public string TestID { get; set; }
+
+            /// <summary>
+            /// A text description that was stored.
+            /// </summary>
+            public string Description { get; set; }
+
+            /// <summary>
+            /// True if this event has already been downloaded.
+            /// </summary>
+            public bool HasBeenDownloaded { get; set; }
+
+            /// <summary>
+            /// True if this event received a trigger.
+            /// </summary>
+            public bool WasTriggered { get; set; }
+            /// <summary>
+            /// clears any fault flags
+            /// </summary>
+            public void ClearFaults()
+            {
+                FaultFlags = 0;
+                FaultFlagsEx = 0;
+            }
+            public EventInfo() { }
+            public EventInfo(EventInfo copy)
+            {
+                Modules = copy.Modules;
+
+                EventNumber = copy.EventNumber;
+
+                TestGUID = copy.TestGUID;
+
+                FaultFlags = copy.FaultFlags;
+                FaultFlagsEx = copy.FaultFlagsEx;
+
+                ArmAttempts = copy.ArmAttempts;
+                TestTime = copy.TestTime;
+
+                TestID = copy.TestID;
+
+                Description = copy.Description;
+
+                HasBeenDownloaded = copy.HasBeenDownloaded;
+
+                WasTriggered = copy.WasTriggered;
+            }
+        }
+
+        /// <summary>
+        /// This class represent one event/test.
+        /// </summary>
+        public class UARTEventInfo : IUARTEventInfo
+        {
+            /// <summary>
+            /// From which event do we want to download data?
+            /// </summary>
+            public ushort EventNumber { get; set; }
+
+            /// <summary>
+            /// Is data present?
+            /// </summary>
+            public bool DataPresent { get; set; }
+
+            /// <summary>
+            /// Has data already been downloaded?
+            /// </summary>
+            public bool DataDownloaded { get; set; }
+
+            /// <summary>
+            /// How much data is there?
+            /// </summary>
+            public ulong TotalByteCount { get; set; }
+
+            /// <summary>
+            /// Where in the data did the trigger occur?
+            /// </summary>
+            public ulong TriggerByteCount { get; set; }
+            /// <summary>
+            /// Where are the faults?
+            /// </summary>
+            public ulong FaultByteCount { get; set; }
+
+            /// <summary>
+            /// When did the UART stream start?
+            /// </summary>
+            public ulong StartTimestamp { get; set; }
+
+            /// <summary>
+            /// When did the UART stream end?
+            /// </summary>
+            public ulong EndTimestamp { get; set; }
+
+            /// <summary>
+            /// What was the baud rate during UART recording?
+            /// </summary>
+            public uint BaudRate { get; set; }
+        }
+
+        /// <summary>
+        /// An array of all events stored on this DAS.
+        /// </summary>
+        public IEventInfo[] Events { get; set; }
+
+        /// <summary>
+        /// An array of all UART events stored on this DAS.
+        /// </summary>
+        public IUARTEventInfo[] UARTEvents { get; set; }
+
+        public static void SetEventDownloadStatus(IDASCommunication das, bool[] status, bool bStoreInDb)
+        {
+            if (null == das) { return; }
+            das.EventDownloadedStatus = status;
+            if (!bStoreInDb || !DASFactoryDb.DbWrapper.Connected) { return; }
+
+            try
+            {
+                Download.ClearExistingEventDownloadStatus(das.RecordId);
+                if (null == status) { return; }
+                foreach (var statum in status)
+                {
+                    Download.InsertEventDownloadStatus(das.RecordId, statum);
+                }
+            }
+            catch (Exception ex)
+            {
+                APILogger.Log(ex);
+            }
+        }
+        public static void SetEventArmAttempts(IDASCommunication das, byte[] armAttempts, bool storeInDb)
+        {
+            if (null == das) { return; }
+            das.ArmAttempts = armAttempts;
+
+            if (!storeInDb || !DASFactoryDb.DbWrapper.Connected) { return; }
+
+            try
+            {
+                Download.ClearExistingEventArmAttempts(das.RecordId);
+                if (null == armAttempts) { return; }
+                foreach (byte armAttempt in armAttempts)
+                {
+                    Download.InsertEventArmAttempts(das.RecordId, armAttempt);
+                }
+            }
+            catch (Exception ex)
+            {
+                APILogger.Log(ex);
+            }
+        }
+        public static void SetEventFaultFlags(IDASCommunication das, ushort[] faultFlags, bool storeInDb)
+        {
+            if (null == das) { return; }
+            das.FaultFlags = faultFlags;
+            if (!storeInDb || !DASFactoryDb.DbWrapper.Connected) { return; }
+
+            try
+            {
+                Download.ClearExistingFaultFlags(das.RecordId);
+                if (null == faultFlags) { return; }
+                foreach (var flag in faultFlags)
+                {
+                    Download.InsertEventFaultFlags(das.RecordId, flag);
+                }
+            }
+            catch (Exception ex)
+            {
+                APILogger.Log(ex);
+            }
+        }
+
+        public static void SetEventInfo(IDASCommunication das, IDownloadReport eventInfo, bool storeInDB)
+        {
+            if (null == das) { return; }
+            das.EventInfo = eventInfo;
+            if (!storeInDB || !DASFactoryDb.DbWrapper.Connected) { return; }
+
+            try
+            {
+                Download.ClearExistingDownloadReports(das.RecordId);
+                if (null == eventInfo || null == eventInfo.Events) { return; }
+                foreach (var eventData in eventInfo.Events)
+                {
+                    InsertEventInfo(das, eventData);
+                }
+            }
+            catch (Exception ex)
+            {
+                APILogger.Log(ex);
+            }
+        }
+
+        private static void InsertEventInfo(IDASCommunication das, IEventInfo eventInfo)
+        {
+            try
+            {
+                if (null == eventInfo || null == das)
+                {
+                    return;
+                }
+                var xml = string.Empty;
+                using (var sw = new StringWriter())
+                {
+                    using (var xw = XmlWriter.Create(sw,
+                        new XmlWriterSettings() { ConformanceLevel = ConformanceLevel.Document }))
+                    {
+                        xw.WriteStartDocument();
+                        xw.WriteStartElement("Modules");
+                        foreach (var mod in eventInfo.Modules)
+                        {
+                            mod.WriteXml(xw);
+                        }
+
+                        xw.WriteEndElement();
+                        xw.WriteEndDocument();
+                    }
+                    sw.Flush();
+                    xml = sw.ToString();
+                }
+
+                Download.InsertEventInfo(das.RecordId,
+                    eventInfo.EventNumber,
+                    eventInfo.TestGUID,
+                    eventInfo.FaultFlags,
+                    eventInfo.ArmAttempts,
+                    eventInfo.TestTime,
+                    eventInfo.TestID,
+                    eventInfo.Description,
+                    eventInfo.HasBeenDownloaded,
+                    eventInfo.WasTriggered,
+                    xml
+                );
+            }
+            catch (Exception ex)
+            {
+                APILogger.Log(ex);
+            }
+        }
+        public static void SetEventGuids(IDASCommunication das, Guid[] guids, bool storeInDb)
+        {
+            if (null == das) { return; }
+            das.EventGuids = guids;
+            if (!storeInDb || !DASFactoryDb.DbWrapper.Connected) { return; }
+
+            try
+            {
+                Download.ClearExistingEventGuids(das.RecordId);
+                if (null == guids) { return; }
+                foreach (var guid in guids)
+                {
+                    Download.EventGuidInsert(das.RecordId, guid);
+                }
+            }
+            catch (Exception ex)
+            {
+                APILogger.Log(ex);
+            }
+        }
+    }
+}

DataPRO/IService/.svn/pristine/21/21dd421492d9415e3c1176cec86174e26ac0a0ca.svn-base

@@ -0,0 +1,39 @@
+using System;
+
+// ReSharper disable once CheckNamespace
+namespace DTS.DASLib.Service
+{
+    /// <inheritdoc />
+    /// <summary>
+    /// allows a input range in mV to send to firmware based on a gain
+    /// this is a right now just the middle between the given gain and the next gain, however
+    /// we can control this a bit more in the future if we wish.
+    /// we don't send directly the input range based on the gain because calibration factors could affect
+    /// what range is actually achieved at each gain step
+    /// but we want to make sure we don't change gain steps [so we can avoid certain gains]
+    /// http://fogbugz/fogbugz/default.asp?10080
+    /// </summary>
+    public class FirmwareInputRangeAttribute : Attribute
+    {
+        /// <summary>
+        /// input range to send to firmware for the given gain
+        /// http://fogbugz/fogbugz/default.asp?10080
+        /// </summary>
+        /// <param name="o"></param>
+        /// <returns></returns>
+        public static double GetFirmwareInputRangemV(object o)
+        {
+            if (o == null) return 0D;
+            var mi = o.GetType().GetMember(o.ToString());
+            if (mi.Length <= 0) return 0D;
+            var attr = GetCustomAttribute(mi[0], typeof(FirmwareInputRangeAttribute)) as FirmwareInputRangeAttribute;
+            return attr?._firmwareInputRangeAttribute ?? 0D;
+        }
+
+        private readonly double _firmwareInputRangeAttribute;
+        public FirmwareInputRangeAttribute(double firmwareInputRangemV)
+        {
+            _firmwareInputRangeAttribute = firmwareInputRangemV;
+        }
+    }
+}