init

Common/DTS.Common.ISO/.svn/pristine/49/49cc8442a65b60f3e1b353c582bfcc767781751e.svn-base

@@ -0,0 +1,327 @@
+using System;
+using System.Collections.Generic;
+using System.Data;
+using System.Data.SqlClient;
+using System.Linq;
+using System.Text;
+using DTS.Common.Interface.Groups;
+using DTS.Common.Storage;
+using DTS.Common.Utilities.Logging;
+using DTS.Common.Enums.Sensors;
+using DTS.Common.Interface.GroupTemplate;
+
+// ReSharper disable once CheckNamespace
+namespace DTS.Common.ISO
+{
+    public class TestObject : IComparable, ITestObject
+    {
+        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()
+        {
+            if (Embedded)
+            {
+                if (string.IsNullOrWhiteSpace(DisplaySerialNumber))
+                {
+                    var index = SerialNumber.LastIndexOf('_');
+                    var displaySerialNumber = SerialNumber;
+                    if (index >= 0)
+                    {
+                        displaySerialNumber = SerialNumber.Substring(index + 1);
+                    }
+                    return displaySerialNumber;
+                }
+                return DisplaySerialNumber;
+            }
+            return SerialNumber;
+            //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 = TestObjectTemplate.GetTemplate(ref db, Template);
+            SetTemplate(template);
+        }
+        public void SetTemplate(TestObjectTemplate template)
+        {
+            _allChannels.Clear();
+            if (null == template) return;
+            Template = template.TemplateName;
+            AllChannels = template.Channels.Select(c => new TestObjectChannel(c, this, template)).ToArray();
+        }
+
+        public bool LocalOnly { get; set; }
+
+        public string LastModifiedBy { get; set; }
+
+        public DateTime LastModified { get; set; }
+
+        public TestObject(TestObject copy, TestObjectTemplate template, ISO13499FileDb db)
+        {
+            SerialNumberConverted = string.Empty;
+            _allChannels = new List<TestObjectChannel>();
+            foreach (var ch in copy.AllChannels) { _allChannels.Add(new TestObjectChannel(ch, this, template)); }
+            Embedded = copy.Embedded;
+            _hardwareIds = new List<string>();
+            _hardwareIds.AddRange(copy.HardwareIds.ToArray());
+            LastModified = copy.LastModified;
+            LastModifiedBy = copy.LastModifiedBy;
+            LocalOnly = copy.LocalOnly;
+            OriginalSerialNumber = copy.OriginalSerialNumber;
+            OriginalTemplate = copy.OriginalTemplate;
+            ParentObject = copy.ParentObject;
+            _sensorSettings = new Dictionary<string, Dictionary<string, Dictionary<SensorConstants.SensorSettings, SensorSetting>>>();
+            using (var e1 = copy._sensorSettings.GetEnumerator())
+            {
+                while (e1.MoveNext())
+                {
+                    using (var e2 = e1.Current.Value.GetEnumerator())
+                    {
+                        while (e2.MoveNext())
+                        {
+                            using (var e3 = e2.Current.Value.GetEnumerator())
+                            {
+                                while (e3.MoveNext())
+                                {
+                                    if (!_sensorSettings.ContainsKey(e1.Current.Key))
+                                    {
+                                        _sensorSettings.Add(e1.Current.Key,
+                                            new Dictionary<string, Dictionary<SensorConstants.SensorSettings, SensorSetting>>());
+                                    }
+                                    if (!_sensorSettings[e1.Current.Key].ContainsKey(e2.Current.Key))
+                                    {
+                                        _sensorSettings[e1.Current.Key].Add(e2.Current.Key,
+                                            new Dictionary<SensorConstants.SensorSettings, SensorSetting>());
+                                    }
+                                    if (!_sensorSettings[e1.Current.Key][e2.Current.Key].ContainsKey(e3.Current.Key))
+                                    {
+                                        _sensorSettings[e1.Current.Key][e2.Current.Key].Add(e3.Current.Key,
+                                            new SensorSetting(e3.Current.Value));
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            SerialNumber = copy.SerialNumber;
+            SysBuilt = copy.SysBuilt;
+            Template = copy.Template;
+            TestObjectType = copy.TestObjectType;
+            TextL1 = copy.TextL1;
+        }
+
+        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; }
+
+
+        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 = (SensorConstants.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 class SensorSetting
+        {
+            public string ChannelId { get; set; }
+            public string SerialNumber { get; set; }
+            public SensorConstants.SensorSettings Setting { get; set; }
+            public string Value { get; set; }
+            public SensorSetting(SensorConstants.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 readonly Dictionary<string, Dictionary<string, Dictionary<SensorConstants.SensorSettings, SensorSetting>>> _sensorSettings =
+            new Dictionary<string, Dictionary<string, Dictionary<SensorConstants.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<SensorConstants.SensorSettings, SensorSetting>>(); }
+            if (!_sensorSettings[channelId].ContainsKey(serialNumber)) { _sensorSettings[channelId][serialNumber] = new Dictionary<SensorConstants.SensorSettings, SensorSetting>(); }
+            _sensorSettings[channelId][serialNumber][setting.Setting] = setting;
+        }
+        private void RemoveSensorSetting(string channelId, string serialNumber)
+        {
+            if (!_sensorSettings.ContainsKey(channelId)) return;
+            if (_sensorSettings[channelId].ContainsKey(serialNumber)) { _sensorSettings[channelId].Remove(serialNumber); }
+        }
+
+        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;
+            using (var e = copy._sensorSettings.GetEnumerator())
+            {
+                _sensorSettings =
+                    new Dictionary<string, Dictionary<string, Dictionary<SensorConstants.SensorSettings, SensorSetting>>>();
+                while (e.MoveNext())
+                {
+                    if (!_sensorSettings.ContainsKey(e.Current.Key))
+                    {
+                        _sensorSettings[e.Current.Key] =
+                            new Dictionary<string, Dictionary<SensorConstants.SensorSettings, SensorSetting>>();
+                    }
+                    using (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<SensorConstants.SensorSettings, SensorSetting>();
+                            }
+                            using (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);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+
+        }
+
+        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();
+        }
+
+        private static int CompareTestObject(TestObject left, TestObject right)
+        {
+            if (left == right) { return 0; }
+            if (null == left) { return -1; }
+            return null == right ? 1 : string.Compare(left.SerialNumber, right.SerialNumber, StringComparison.Ordinal);
+        }
+
+        public int CompareTo(object o)
+        {
+            if (o is TestObject testObject)
+            {
+                return CompareTestObject(this, testObject);
+            }
+            throw new ArgumentException($"object {o} is not the same type as this instance (TestObject)");
+        }
+    }
+}