init

DataPRO/Modules/DatabaseImporter/DatabaseImport/.svn/pristine/ee/ee3781f6cdd1d7774d8ffbdf7aee55f1680e2e5a.svn-base

@@ -0,0 +1,189 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace DatabaseImport
+{
+    public class TestGraph //: BasePropertyChanged
+    {
+        private const string SEPARATOR = "§";
+        public void SetThresholdsFromSQL(string sThresholds)
+        {
+            //for now we take an easy parse
+            sThresholds = sThresholds.Replace("{", "").Replace("}", "");
+            var sTokens = sThresholds.Split(new[] { SEPARATOR }, StringSplitOptions.None);
+            foreach (var token in sTokens)
+            {
+                double d;
+                if (double.TryParse(token, out d))
+                {
+                    _thresholds.Add(d);
+                }
+            }
+        }
+
+
+        public void SetChannelsFromSQL(string sChannels)
+        {
+            var lookup = new Dictionary<string, TestObjectChannel>();
+            if (null == AvailableChannels)
+            {
+                return;
+            }
+            foreach (var channel in AvailableChannels)
+            {
+                lookup[channel.GetGraphId()] = channel;
+            }
+            sChannels = sChannels.Replace("{", "").Replace("}", "");
+            var tokens = sChannels.Split(new[] { SEPARATOR }, StringSplitOptions.None);
+            foreach (var token in tokens)
+            {
+                var sChannelId = token.Replace("(", "").Replace(")", "");
+                if (lookup.ContainsKey(sChannelId)) { AddChannel(lookup[sChannelId]); }
+            }
+        }
+        private List<TestObjectChannel> _channels = new List<TestObjectChannel>();
+        private readonly Dictionary<string, TestObjectChannel> _lookup = new Dictionary<string, TestObjectChannel>();
+        private void AddGroup(TestTestObject group)
+        {
+            _groups.Add(group);
+        }
+        private void AddAddedGroup(TestTestObject addedGroup)
+        {
+            _addedGroups.Add(addedGroup);
+        }
+        private void AddChannel(TestObjectChannel channel)
+        {
+            _channels.Add(channel);
+            _lookup[channel.GetGraphId()] = channel;
+            //OnPropertyChanged("Channels");
+            //OnPropertyChanged("AvailableChannels");
+        }
+        private bool ContainsChannel(TestObjectChannel channel)
+        {
+            return _lookup.ContainsKey(channel.GetGraphId());
+        }
+        private bool ContainsCurrentChannel(TestObjectChannel channel)
+        {
+            if (channel.SquibChannelType == TestObjectChannel.SquibChannelTypes.Current)
+            {
+                return ContainsChannel(channel);
+            }
+            else
+            {
+                return _lookup.ContainsKey(channel.GetGraphId() + DTS.Common.Constants.CURRENT_SUFFIX);
+            }
+        }
+        private bool ContainsVoltageChannel(TestObjectChannel channel)
+        {
+            return ContainsChannel(channel);
+        }
+        private const int MAX_CHANNELS_PER_GRAPH = 8;
+        public TestObjectChannel[] AvailableChannels
+        {
+            get
+            {
+                _lookup.Clear();
+                var channels = new List<TestObjectChannel>();
+                if (_channels.Count >= MAX_CHANNELS_PER_GRAPH) return channels.ToArray();
+                foreach (var setChannel in _channels)
+                {
+                    _lookup[setChannel.GetGraphId()] = setChannel;
+                }
+                if (_groups.Exists(to => !AddChannels(to, channels)))
+                {
+                    return null;
+                }
+                if (_addedGroups.Where(to => to.Hardware.Any()).Any(to => !AddChannels(to, channels)))
+                {
+                    return null;
+                }
+                channels.Sort();
+                return channels.ToArray();
+            }
+        }
+
+        private bool AddChannels(TestTestObject to, List<TestObjectChannel> channels)
+        {
+            var isoTestObject = to.GetISOTestObject();
+            if (null == isoTestObject)
+            {
+                return false;
+            }
+            foreach (var channel in isoTestObject.AllChannels)
+            {
+                if (!channel.Required || channel.Disabled) { continue; }
+                if (string.IsNullOrWhiteSpace(channel.SensorSerialNumber)) { continue; }
+                var sd = SensorsCollection.SensorsList.GetSensorBySerialNumber(channel.SensorSerialNumber);
+                if (null == sd || !sd.IsDigitalOutput())
+                {
+                    if ((sd != null) && (sd.Bridge == Test.Module.Channel.Sensor.BridgeType.SQUIB))
+                    {
+                        //Put squib channels (Current and/or Voltage) in the
+                        //Available list if and only if they are not in the graph
+                        if (!ContainsCurrentChannel(channel))
+                        {
+                            var currentChannel = new TestObjectChannel(channel, isoTestObject, new TestObjectTemplate().ToISOTestObjectTemplate())
+                            {
+                                SquibChannelType = TestObjectChannel.SquibChannelTypes.Current,
+                                NameOfTheChannel = channel.Name + " " + "Graph_SquibCurrent"
+                            };
+                            channels.Add(currentChannel);
+                        }
+
+                        if (!ContainsVoltageChannel(channel))
+                        {
+                            channel.SquibChannelType = TestObjectChannel.SquibChannelTypes.Voltage;
+                            channel.NameOfTheChannel = channel.Name + " " + "Graph_SquibVoltage";
+                            channels.Add(channel);
+                        }
+                    }
+                    else
+                    {
+                        if (ContainsChannel(channel)) { continue; }
+                        channels.Add(channel);
+                    }
+                }
+            }
+
+            return true;
+        }
+
+        public string GraphName { get; set; } = "";
+
+        public string GraphDescription { get; set; } = "";
+
+        public bool UseDomainMin { get; set; }
+
+        public double DomainMin { get; set; } = double.MinValue;
+
+        public bool UseDomainMax { get; set; }
+
+        public double DomainMax { get; set; } = double.MaxValue;
+
+        public bool UseRangeMin { get; set; }
+
+        public double RangeMin { get; set; } = double.MinValue;
+
+        public bool UseRangeMax { get; set; }
+
+        public double RangeMax { get; set; } = double.MaxValue;
+
+        private List<double> _thresholds = new List<double>();
+        private readonly TestTemplate _template;
+        private List<TestTestObject> _groups = new List<TestTestObject>();
+        private List<TestTestObject> _addedGroups = new List<TestTestObject>();
+        public TestGraph(TestTemplate template)
+        {
+            _template = template;
+            foreach (var group in _template.TestObjectsWithChannels)
+            {
+                AddGroup(new TestTestObject(group));
+            }
+            foreach (var addedGroup in _template.AddedGroups)
+            {
+                AddAddedGroup(new TestTestObject(addedGroup));
+            }
+        }
+    }
+}

DataPRO/Modules/DatabaseImporter/DatabaseImport/.svn/pristine/ee/ee702e3777cd000b610f2efbb1fe9cc68deab4b8.svn-base

@@ -0,0 +1,9 @@
+namespace DatabaseImport
+{
+    /// <summary>
+    /// this class encapsulates a single user
+    /// </summary>
+    public class User : TagAwareBase
+    {
+    }
+}