init

DataPRO/SensorDB/AnalogSettingDefaults.cs

@@ -0,0 +1,298 @@
+using DTS.Common.Classes.Sensors;
+using DTS.Common.Enums.Sensors;
+using DTS.Common.Interface.Sensors;
+using DTS.Common.Interface.Sensors.SoftwareFilters;
+using Prism.Ioc;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using DTS.Common.Settings;
+using Prism.Events;
+
+namespace DTS.SensorDB
+{
+    public class AnalogSettingDefaults : Common.Base.BasePropertyChanged, IAnalogDefaults
+    {
+        private List<ISoftwareFilter> _softwareFilters;
+        private IEventAggregator _eventAggregator;
+        public AnalogSettingDefaults()
+        {
+            _softwareFilters = SoftwareFilter.GetSoftwareFilters().ToList();
+            _eventAggregator = ContainerLocator.Container.Resolve<IEventAggregator>();
+            _eventAggregator.GetEvent<DTS.Common.Events.Sensors.SensorsList.SensorSavedEvent>().Subscribe(SelectSoftwareFilter);
+        }
+
+        //FB 13120 select default filter for new add hoc filter 
+        private void SelectSoftwareFilter(double frequency)
+        {
+            if (_softwareFilters.Where(p => p.Frequency == frequency).Any())
+            {
+                return;
+            }
+            SoftwareFilter softwareFilter = new SoftwareFilter(-1, frequency.ToString(), 'S', DateTime.Now, "", frequency, true);
+            foreach (var sf in _softwareFilters)
+            {
+                sf.IsDefault = false;
+            }
+            _softwareFilters.Add(softwareFilter);
+            Save();
+
+            SelectedFilterOption = new FilterClass(FilterClassType.AdHoc, frequency);
+            OnPropertyChanged("FilterOptions");
+        }
+
+        //Fb 13120 save the filters to db 
+        public void Save()
+        {
+            foreach (var sf in _softwareFilters)
+            {
+                sf.Commit();
+            }
+        }
+        //FB 13120 identify the selected filter option to be used in combo box 
+        public IFilterClass SelectedFilterOption
+        {
+            get
+            {
+                var softwareFilter = _softwareFilters.Find(p => p.IsDefault);
+                FilterClass fc = null;
+
+                if (softwareFilter?.Id == 1)
+                {
+                    fc = new FilterClass(FilterClassType.Unfiltered);
+                }
+                else if (softwareFilter?.Id == 2)
+                {
+                    fc = new FilterClass(FilterClassType.None);
+                }
+                else if (softwareFilter?.ISOCode == 'S')
+                {
+                    fc = new FilterClass(FilterClassType.AdHoc, softwareFilter.Frequency);
+                }
+                else
+                {
+                    foreach (var fct in Enum.GetValues(typeof(FilterClassType))
+                          .Cast<FilterClassType>().ToArray())
+                    {
+                        if (fct == FilterClassType.AdHoc
+                            || fct == FilterClassType.CFC10)
+                        {
+                            continue;
+                        }
+                        if (fct.ToString() == softwareFilter?.Description.Replace(" ", ""))
+                        {
+                            fc = new FilterClass(fct);
+                            break;
+                        }
+                    }
+                }
+                return fc;
+            }
+            set
+            {
+                if (value == null)
+                    return;
+
+                foreach (var sf in _softwareFilters)
+                {
+                    sf.IsDefault = false;
+                }
+
+                ISoftwareFilter softwareFilter = null;
+
+                if (value.FClass == FilterClassType.Unfiltered)
+                {
+                    softwareFilter = _softwareFilters.Find(p => p.Id == 1);
+                }
+                else if (value.FClass == FilterClassType.None)
+                {
+                    softwareFilter = _softwareFilters.Find(p => p.Id == 2);
+                }
+                else if (value.FClass == FilterClassType.AdHoc && !_softwareFilters.Where(p => p.Frequency == value.Frequency).Any())
+                {
+                    _filterOptions.Add(new FilterClass(FilterClassType.AdHoc, value.Frequency));
+                    _softwareFilters.Add(new SoftwareFilter(-1, value.Frequency.ToString(), 'S', DateTime.Now, "", value.Frequency, false));
+                    softwareFilter = _softwareFilters.Find(p => p.Frequency == value.Frequency);
+                }
+                else
+                {
+                    softwareFilter = _softwareFilters.Find(p => p.Frequency == value.Frequency);
+                }
+
+                softwareFilter.IsDefault = true;
+                OnPropertyChanged("SelectedFilterOption");
+            }
+        }
+
+        public static IAnalogDefaults GetAnalogDefaults()
+        {
+            return new AnalogSettingDefaults();
+        }
+
+        private List<IFilterClass> _filterOptions;
+
+        //FB 13120 available filter classes to be used in drop down 
+        public List<IFilterClass> FilterOptions
+        {
+            get
+            {
+                if (null == _filterOptions)
+                {
+                    var softwareFilters = SoftwareFilter.GetSoftwareFilters();
+                    var customFilters = softwareFilters.Where(p => p.ISOCode == 'S');
+                    _filterOptions = new List<IFilterClass>();
+
+                    foreach (var fct in Enum.GetValues(typeof(FilterClassType))
+                        .Cast<FilterClassType>().ToArray())
+                    {
+                        if (fct == FilterClassType.AdHoc
+                            || fct == FilterClassType.CFC10)
+                        {
+                            //Dont include until we can handle this type.
+                            continue;
+                        }
+
+                        FilterClass fc = new FilterClass(fct);
+                        _filterOptions.Add(fc);
+                    }
+
+                    foreach (var filter in customFilters)
+                    {
+                        FilterClass fc = new FilterClass(FilterClassType.AdHoc, filter.Frequency);
+                        _filterOptions.Add(fc);
+                    }
+                }
+                _filterOptions.Sort(CompareFilters);
+                return _filterOptions;
+            }
+        }
+
+        //FB 18727 UseMeasuredExcitation setting
+        public bool UseMeasuredExcitation
+        {
+            get
+            {
+                return SettingsDB.GetGlobalValueBool(Common.Constants.UseMeasuredExcitation, false);
+            }
+            set
+            {
+                SettingsDB.SetGlobalValueBoolean(Common.Constants.UseMeasuredExcitation, value);
+                OnPropertyChanged(Common.Constants.UseMeasuredExcitation);
+            }
+        }
+        
+        public bool TrackAnalogDiagnosticsEnabled
+        {
+            get => DTS.Common.Storage.DbOperations.GetConnectionDbVersion() >= Common.Constants.TRACK_ANALOG_DIAGNOSTICS_DB_VERSION;
+        }
+        //http://manuscript.dts.local/f/cases/39148/DataPRO-Instrumentation-Tracking-Functions-FAA-Request-Diagnostics-Tracking
+        public bool TrackAnalogDiagnostics
+        {
+            get => TrackAnalogDiagnosticsEnabled && SettingsDB.GetGlobalValueBool(Common.Constants.TrackAnalogDiagnostics, false);
+            set
+            {
+                SettingsDB.SetGlobalValueBoolean(Common.Constants.TrackAnalogDiagnostics, value);
+                OnPropertyChanged(Common.Constants.TrackAnalogDiagnostics);
+            }
+        }
+
+        private static int CompareFilters(IFilterClass f1, IFilterClass f2)
+        {
+            if (f1 == null)
+            {
+                if (f2 == null)
+                {
+                    // both null, equal
+                    return 0;
+                }
+                // left null but not right
+                return -1;
+            }
+            if (f2 == null)
+            {
+                // left not null, right null
+                return 1;
+            }
+
+            if (f1.FClass != FilterClassType.None)
+                return f2.FClass == FilterClassType.None ? 1 : f1.Frequency.CompareTo(f2.Frequency);
+            if (f2.FClass == FilterClassType.None)
+            {
+                return 0;
+            }
+            return -1;
+        }
+
+        public bool Validate()
+        {
+            return true;
+        }
+
+        public void ReadXML(System.Xml.XmlElement root)
+        {
+            var frequency = 0D;
+            var fClass = FilterClassType.None;
+            foreach (var node in root.ChildNodes)
+            {
+                if (node is System.Xml.XmlElement nodex)
+                {
+                    if (Enum.TryParse(nodex.Name, out FilterXMLFields field))
+                    {
+                        switch (field)
+                        {
+                            case FilterXMLFields.Frequency:
+                                frequency = Convert.ToDouble(nodex.InnerText);
+                                break;
+                            case FilterXMLFields.FClass:
+                                if (Enum.TryParse(nodex.InnerText, out FilterClassType filterClass))
+                                {
+                                    fClass = filterClass;
+                                }
+                                break;
+
+                            default:
+                                throw new NotSupportedException(
+                                    "AnalogSettingDefaults::ReadXML unsupported field: " + field);
+                        }
+                    }
+                }
+            }
+
+            SelectedFilterOption = new FilterClass(fClass, frequency);
+        }
+        public void WriteXML(ref System.Xml.XmlWriter writer)
+        {
+            writer.WriteStartElement("AnalogSettingDefaults");
+
+            writer.WriteStartElement("SelectedFilterOption");
+
+            writer.WriteStartElement(FilterXMLFields.Frequency.ToString());
+            writer.WriteString(SelectedFilterOption.Frequency.ToString(System.Globalization.CultureInfo.InvariantCulture));
+            writer.WriteEndElement();
+
+            writer.WriteStartElement(FilterXMLFields.FClass.ToString());
+            writer.WriteString(SelectedFilterOption.FClass.ToString());
+            writer.WriteEndElement();
+
+            writer.WriteEndElement();
+
+            writer.WriteEndElement();
+        }
+        
+        /// <summary>
+        /// restores digital input settings to defaults
+        /// </summary>
+        /// <param name="sensorDefaults"></param>
+        public static void RestoreDefaults(IAnalogDefaults sensorDefaults)
+        {
+            sensorDefaults.TrackAnalogDiagnostics = false;
+        }
+    }
+
+    public enum FilterXMLFields
+    {
+        FilterName,
+        Frequency,
+        FClass
+    }
+}