DP44/DataPRO/SensorDB/AnalogSettingDefaults.cs

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
    }
}