Software/Visual_Studio/PPC/Modules/Tango.PPC.MachineSettings/ViewModels/MainViewVM.cs


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
pre { line-height: 125%; }
td.linenos .normal { color: inherit; background-color: transparent; padding-left: 5px; padding-right: 5px; }
span.linenos { color: inherit; background-color: transparent; padding-left: 5px; padding-right: 5px; }
td.linenos .special { color: #000000; background-color: #ffffc0; padding-left: 5px; padding-right: 5px; }
span.linenos.special { color: #000000; background-color: #ffffc0; padding-left: 5px; padding-right: 5px; }
.highlight .hll { background-color: #ffffcc }
.highlight .c { color: #888888 } /* Comment */
.highlight .err { color: #a61717; background-color: #e3d2d2 } /* Error */
.highlight .k { color: #008800; font-weight: bold } /* Keyword */
.highlight .ch { color: #888888 } /* Comment.Hashbang */
.highlight .cm { color: #888888 } /* Comment.Multiline */
.highlight .cp { color: #cc0000; font-weight: bold } /* Comment.Preproc */
.highlight .cpf { color: #888888 } /* Comment.PreprocFile */
.highlight .c1 { color: #888888 } /* Comment.Single */
.highlight .cs { color: #cc0000; font-weight: bold; background-color: #fff0f0 } /* Comment.Special */
.highlight .gd { color: #000000; background-color: #ffdddd } /* Generic.Deleted */
.highlight .ge { font-style: italic } /* Generic.Emph */
.highlight .ges { font-weight: bold; font-style: italic } /* Generic.EmphStrong */
.highlight .gr { color: #aa0000 } /* Generic.Error */
.highlight .gh { color: #333333 } /* Generic.Heading */
.highlight .gi { color: #000000; background-color: #ddffdd } /* Generic.Inserted */
.highlight .go { color: #888888 } /* Generic.Output */
.highlight .gp { color: #555555 } /* Generic.Prompt */
.highlight .gs { font-weight: bold } /* Generic.Strong */
.highlight .gu { color: #666666 } /* Generic.Subheading */
.highlight .gt { color: #aa0000 } /* Generic.Traceback */
.highlight .kc { color: #008800; font-weight: bold } /* Keyword.Constant */
.highlight .kd { color: #008800; font-weight: bold } /* Keyword.Declaration */
.highlight .kn { color: #008800; font-weight: bold } /* Keyword.Namespace */
.highlight .kp { color: #008800 } /* Keyword.Pseudo */
.highlight .kr { color: #008800; font-weight: bold } /* Keyword.Reserved */
.highlight .kt { color: #888888; font-weight: bold } /* Keyword.Type */
.highlight .m { color: #0000DD; font-weight: bold } /* Literal.Number */
.highlight .s { color: #dd2200; background-color: #fff0f0 } /* Literal.String */
.highlight .na { color: #336699 } /* Name.Attribute */
.highlight .nb { color: #003388 } /* Name.Builtin */
.highlight .nc { color: #bb0066; font-weight: bold } /* Name.Class */
.highlight .no { color: #003366; font-weight: bold } /* Name.Constant */
.highlight .nd { color: #555555 } /* Name.Decorator */
.highlight .ne { color: #bb0066; font-weight: bold } /* Name.Exception */
.highlight .nf { color: #0066bb; font-weight: bold } /* Name.Function */
.highlight .nl { color: #336699; font-style: italic } /* Name.Label */
.highlight .nn { color: #bb0066; font-weight: bold } /* Name.Namespace */
.highlight .py { color: #336699; font-weight: bold } /* Name.Property */
.highlight .nt { color: #bb0066; font-weight: bold } /* Name.Tag */
.highlight .nv { color: #336699 } /* Name.Variable */
.highlight .ow { color: #008800 } /* Operator.Word */
.highlight .w { color: #bbbbbb } /* Text.Whitespace */
.highlight .mb { color: #0000DD; font-weight: bold } /* Literal.Number.Bin */
.highlight .mf { color: #0000DD; font-weight: bold } /* Literal.Number.Float */
.highlight .mh { color: #0000DD; font-weight: bold } /* Literal.Number.Hex */
.highlight .mi { color: #0000DD; font-weight: bold } /* Literal.Number.Integer */
.highlight .mo { color: #0000DD; font-weight: bold } /* Literal.Number.Oct */
.highlight .sa { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Affix */
.highlight .sb { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Backtick */
.highlight .sc { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Char */
.highlight .dl { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Delimiter */
.highlight .sd { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Doc */
.highlight .s2 { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Double */
.highlight .se { color: #0044dd; background-color: #fff0f0 } /* Literal.String.Escape */
.highlight .sh { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Heredoc */
.highlight .si { color: #3333bb; background-color: #fff0f0 } /* Literal.String.Interpol */
.highlight .sx { color: #22bb22; background-color: #f0fff0 } /* Literal.String.Other */
.highlight .sr { color: #008800; background-color: #fff0ff } /* Literal.String.Regex */
.highlight .s1 { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Single */
.highlight .ss { color: #aa6600; background-color: #fff0f0 } /* Literal.String.Symbol */
.highlight .bp { color: #003388 } /* Name.Builtin.Pseudo */
.highlight .fm { color: #0066bb; font-weight: bold } /* Name.Function.Magic */
.highlight .vc { color: #336699 } /* Name.Variable.Class */
.highlight .vg { color: #dd7700 } /* Name.Variable.Global */
.highlight .vi { color: #3333bb } /* Name.Variable.Instance */
.highlight .vm { color: #336699 } /* Name.Variable.Magic */
.highlight .il { color: #0000DD; font-weight: bold } /* Literal.Number.Integer.Long */using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Tango.DAL.Observables
{
    internal static class LoadedObjectsService
    {
        private static List<KeyValuePair<String, IObservableEntity>> LoadedObjects;

        public static Object Get(String guid)
        {
            return LoadedObjects.SingleOrDefault(x => x.Key == guid).Value;
        }

        public static void Add(String guid, IObservableEntity observable)
        {
            if (!LoadedObjects.Exists(x => x.Key == guid))
            {
                LoadedObjects.Add(new KeyValuePair<string, IObservableEntity>(guid, observable));
            }
        }

        public static bool Exists(String guid)
        {
            return LoadedObjects.Exists(x => x.Key == guid);
        }

        public static void Reset()
        {
            LoadedObjects.Clear();
        }

        static LoadedObjectsService()
        {
            LoadedObjects = new List<KeyValuePair<String, IObservableEntity>>();
        }
    }
}
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Collections.Specialized;
using System.ComponentModel;
using System.ComponentModel.DataAnnotations;
using System.Diagnostics;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Data;
using Tango.BL;
using System.Data.Entity;
using Tango.BL.Builders;
using Tango.BL.Entities;
using Tango.BL.Enumerations;
using Tango.ColorConversion;
using Tango.Core.Commands;
using Tango.Core.Components;
using Tango.Core.DI;
using Tango.Core.ExtensionMethods;
using Tango.PPC.Common;
using Tango.PPC.Common.Connection;
using Tango.PPC.Common.ExternalBridge;
using Tango.PPC.Common.Lubrication;
using Tango.PPC.Common.Messages;
using Tango.PPC.Common.OS;
using Tango.PPC.Common.UWF;
using Tango.Settings;
using Tango.SharedUI.Components;
using Tango.WiFi;
using static Tango.Core.Components.CmdCommand;

namespace Tango.PPC.MachineSettings.ViewModels
{
    /// <summary>
    /// Represents the main view VM and entry point for <see cref="Synchronization.MyModule"/>.
    /// </summary>
    /// <seealso cref="Tango.PPC.Common.PPCViewModel" />
    public class MainViewVM : PPCViewModel
    {
        private TimeZoneInfo _previousTimeZone;
        private bool _previousEnableUWF;

        #region Classes

        public class PowerDownTime
        {
            public PowerSavingModes Minutes { get; set; }

            public String Name
            {
                get { return Minutes.ToDescription(); }
            }
        }

        public class RmlLubricationLevelSettings : RmlLubricationLevel
        {
            public String Name { get; set; }

            public RmlLubricationLevelSettings()
            {

            }

            public RmlLubricationLevelSettings(RmlLubricationLevel rmlLevel, String name)
            {
                RmlGuid = rmlLevel.RmlGuid;
                LubricationLevel = rmlLevel.LubricationLevel;
                Name = name;
            }

            public RmlLubricationLevel ToRmlLubricationLevel()
            {
                return new RmlLubricationLevel()
                {
                    RmlGuid = RmlGuid,
                    LubricationLevel = LubricationLevel,
                };
            }
        }

        #endregion

        #region Properties

        [TangoInject]
        private IOperationSystemManager OperationSystemManager { get; set; }

        [TangoInject]
        private IUnifiedWriteFilterManager UnifiedWriteFilterManager { get; set; }

        private Machine _machine;
        public Machine Machine
        {
            get { return _machine; }
            set { _machine = value; RaisePropertyChangedAuto(); }
        }

        private SelectedObjectCollection<JobTypes> _selectedJobTypes;
        public SelectedObjectCollection<JobTypes> SelectedJobTypes
        {
            get { return _selectedJobTypes; }
            set { _selectedJobTypes = value; RaisePropertyChangedAuto(); }
        }

        private SelectedObjectCollection<ColorSpaces> _selectedColorSpaces;
        public SelectedObjectCollection<ColorSpaces> SelectedColorSpaces
        {
            get { return _selectedColorSpaces; }
            set { _selectedColorSpaces = value; RaisePropertyChangedAuto(); }
        }

        private ObservableCollection<ColorSpaces> _tabsColorSpaces;
        public ObservableCollection<ColorSpaces> TabsColorSpaces
        {
            get { return _tabsColorSpaces; }
            set { _tabsColorSpaces = value; RaisePropertyChangedAuto(); }
        }

        private ObservableCollection<Rml> _rmls;
        public ObservableCollection<Rml> Rmls
        {
            get { return _rmls; }
            set { _rmls = value; RaisePropertyChangedAuto(); }
        }

        private ObservableCollection<SpoolType> _spoolTypes;
        public ObservableCollection<SpoolType> SpoolTypes
        {
            get { return _spoolTypes; }
            set { _spoolTypes = value; RaisePropertyChangedAuto(); }
        }

        private bool _enableHotSpot;
        public bool EnableHotSpot
        {
            get { return _enableHotSpot; }
            set { _enableHotSpot = value; RaisePropertyChangedAuto(); OnEnableHotSpotChanged(); }
        }

        private String _hotSpotPassword;
        public String HotSpotPassword
        {
            get { return _hotSpotPassword; }
            set { _hotSpotPassword = value; RaisePropertyChangedAuto(); }
        }

        private bool _enableExternalBridge;
        public bool EnableExternalBridge
        {
            get { return _enableExternalBridge; }
            set { _enableExternalBridge = value; RaisePropertyChangedAuto(); OnEnableExternalBridgeChanged(); }
        }

        private String _externalBridgePassword;
        public String ExternalBridgePassword
        {
            get { return _externalBridgePassword; }
            set { _externalBridgePassword = value; RaisePropertyChangedAuto(); }
        }

        private bool _enableRemoteAssistance;
        public bool EnableRemoteAssistance
        {
            get { return _enableRemoteAssistance; }
            set { _enableRemoteAssistance = value; RaisePropertyChangedAuto(); OnEnableRemoteAssistanceChanged(); }
        }

        private bool _enableLockScreen;
        public bool EnableLockScreen
        {
            get { return _enableLockScreen; }
            set { _enableLockScreen = value; RaisePropertyChangedAuto(); }
        }

        private int _lockScreenTimeoutMinutes;
        public int LockScreenTimeoutMinutes
        {
            get { return _lockScreenTimeoutMinutes; }
            set { _lockScreenTimeoutMinutes = value; RaisePropertyChangedAuto(); }
        }

        private String _lockScreenPassword;
        public String LockScreenPassword
        {
            get { return _lockScreenPassword; }
            set { _lockScreenPassword = value; RaisePropertyChangedAuto(); }
        }

        private Rml _defaultRML;
        public Rml DefaultRML
        {
            get { return _defaultRML; }
            set { _defaultRML = value; RaisePropertyChangedAuto(); }
        }

        private SpoolType _selectedSpoolType;
        public SpoolType SelectedSpoolType
        {
            get { return _selectedSpoolType; }
            set { _selectedSpoolType = value; RaisePropertyChangedAuto(); }
        }

        private ColorSpaces _defaultTabColorSpace;
        public ColorSpaces DefaultTabColorSpace
        {
            get { return _defaultTabColorSpace; }
            set { _defaultTabColorSpace = value; RaisePropertyChangedAuto(); }
        }

        private bool _synchronizeJobs;
        public bool SynchronizeJobs
        {
            get { return _synchronizeJobs; }
            set { _synchronizeJobs = value; RaisePropertyChangedAuto(); InvalidateRelayCommands(); }
        }

        private bool _synchronizeDiagnostics;
        public bool SynchronizeDiagnostics
        {
            get { return _synchronizeDiagnostics; }
            set { _synchronizeDiagnostics = value; RaisePropertyChangedAuto(); InvalidateRelayCommands(); }
        }

        private bool _autoCheckForUpdates;
        public bool AutoCheckForUpdates
        {
            get { return _autoCheckForUpdates; }
            set { _autoCheckForUpdates = value; RaisePropertyChangedAuto(); }
        }

        private List<TimeZoneInfo> _timeZones;
        /// <summary>
        /// Gets or sets the available time zones.
        /// </summary>
        public List<TimeZoneInfo> TimeZones
        {
            get { return _timeZones; }
            set { _timeZones = value; RaisePropertyChangedAuto(); }
        }

        private TimeZoneInfo _selectedTimeZone;
        /// <summary>
        /// Gets or sets the selected time zone.
        /// </summary>
        public TimeZoneInfo SelectedTimeZone
        {
            get { return _selectedTimeZone; }
            set { _selectedTimeZone = value; RaisePropertyChangedAuto(); }
        }

        private bool _enableUWF;
        public bool EnableUWF
        {
            get { return _enableUWF; }
            set { _enableUWF = value; RaisePropertyChangedAuto(); }
        }

        private List<RmlLubricationLevelSettings> _lubricationLevels;
        public List<RmlLubricationLevelSettings> LubricationLevels
        {
            get { return _lubricationLevels; }
            set { _lubricationLevels = value; RaisePropertyChangedAuto(); }
        }

        private RmlLubricationLevelSettings _selectedLubricationLevel;
        public RmlLubricationLevelSettings SelectedLubricationLevel
        {
            get { return _selectedLubricationLevel; }
            set { _selectedLubricationLevel = value; RaisePropertyChangedAuto(); }
        }

        private bool _useLightInks;
        public bool UseLightInks
        {
            get { return _useLightInks; }
            set { _useLightInks = value; RaisePropertyChangedAuto(); }
        }

        private bool _enableProxy;
        public bool EnableProxy
        {
            get { return _enableProxy; }
            set { _enableProxy = value; RaisePropertyChangedAuto(); }
        }

        private int _manualFineTuningLength;
        public int FineTuningLength
        {
            get { return _manualFineTuningLength; }
            set { _manualFineTuningLength = value; RaisePropertyChangedAuto(); }
        }

        public List<PowerDownTime> PowerSavingModes { get; set; }

        private PowerDownTime _selectedPoweroffTime;
        public PowerDownTime SelectedPowerOffTime
        {
            get { return _selectedPoweroffTime; }
            set { _selectedPoweroffTime = value; RaisePropertyChangedAuto(); }
        }

        private PowerDownTime _selectedIdleTime;
        public PowerDownTime SelectedIdleTime
        {
            get { return _selectedIdleTime; }
            set { _selectedIdleTime = value; RaisePropertyChangedAuto(); RaisePropertyChanged(nameof(PowerOffTimeVisible)); }
        }
        
        public bool PowerOffTimeVisible
        {
            get { return SelectedIdleTime.Minutes != Common.PowerSavingModes.Never; }
        }

        #endregion

        #region Commands

        /// <summary>
        /// Gets or sets the save command.
        /// </summary>
        public RelayCommand SaveCommand { get; set; }

        /// <summary>
        /// Gets or sets the discard command.
        /// </summary>
        public RelayCommand DiscardCommand { get; set; }

        /// <summary>
        /// Gets or sets the synchronize command.
        /// </summary>
        public RelayCommand SynchronizeCommand { get; set; }

        #endregion

        public MainViewVM()
        {
            LubricationLevels = new List<RmlLubricationLevelSettings>();
            SaveCommand = new RelayCommand(Save);
            DiscardCommand = new RelayCommand(Discard);
            SynchronizeCommand = new RelayCommand(Synchronize, () => !MachineDataSynchronizer.IsSynchronizing && IsFree);

            PowerSavingModes = new List<PowerDownTime>()
            {
                new PowerDownTime() { Minutes = Common.PowerSavingModes.Minimum },
                new PowerDownTime() { Minutes = Common.PowerSavingModes.Default },
                new PowerDownTime() { Minutes = Common.PowerSavingModes.Maximum },
                new PowerDownTime() { Minutes = Common.PowerSavingModes.Never },
            };
        }

        private void Discard()
        {
            NavigationManager.NavigateBack();
        }

        private async void Save()
        {
            if (Validate())
            {
                Settings.SupportedJobTypes = SelectedJobTypes.SynchedSource.ToList();
                Settings.SupportedColorSpaces = SelectedColorSpaces.SynchedSource.ToList();

                Machine.MapPropertiesTo(MachineProvider.Machine, MappingFlags.NoReferenceTypes);

                Settings.EnableHotSpot = EnableHotSpot;
                Settings.HotSpotPassword = HotSpotPassword;
                Settings.EnableExternalBridge = EnableExternalBridge;
                Settings.ExternalBridgePassword = ExternalBridgePassword;
                Settings.EnableLockScreen = EnableLockScreen;
                Settings.LockScreenTimeout = TimeSpan.FromMinutes(LockScreenTimeoutMinutes);
                Settings.LockScreenPassword = LockScreenPassword;
                Settings.DefaultRmlGuid = DefaultRML?.Guid;
                String previousSpoolType = Settings.SpoolTypeGuid;
                Settings.SpoolTypeGuid = SelectedSpoolType?.Guid;
                Settings.SynchronizeJobs = SynchronizeJobs;
                Settings.SynchronizeDiagnostics = SynchronizeDiagnostics;
                Settings.AutoCheckForUpdates = AutoCheckForUpdates;
                Settings.LubricationLevels = LubricationLevels.Where(x => x.LubricationLevel != LubricationLevel.Standard).Select(x => x.ToRmlLubricationLevel()).ToList();
                Settings.DefaultTabColorSpace = DefaultTabColorSpace;
                Settings.FineTuningTrialLengthMeters = FineTuningLength;

                Settings.PowerSavingModeIdle = SelectedIdleTime.Minutes;
                Settings.PowerSavingModePowerOff = SelectedPowerOffTime.Minutes;

                MachineDataSynchronizer.IsEnabled = SynchronizeJobs || SynchronizeDiagnostics;

                var colorConversionSettings = SettingsManager.Default.GetOrCreate<ColorConversionSettings>();
                colorConversionSettings.UseLightInks = UseLightInks;

                Settings.Save();

                await MachineProvider.SaveMachine();

                bool isRestarting = false;

                if (SelectedSpoolType != null && previousSpoolType != Settings.SpoolTypeGuid)
                {
                    await MachineProvider.MachineOperator.SetSpoolType((PMR.Printing.JobSpoolType)SelectedSpoolType.Code);
                }

                if (MachineProvider.IsConnected && BuildProvider.IsEureka)
                {
                    try
                    {
                        await MachineProvider.MachineOperator.SetPowerSavingMode((int)Settings.PowerSavingModeIdle, (int)Settings.PowerSavingModePowerOff);
                    }
                    catch { }
                }

                if (_previousTimeZone.ToStringSafe() != SelectedTimeZone.ToStringSafe())
                {
                    if (await NotificationProvider.ShowQuestion("Changing the time zone requires the application to restart. Do you wish to restart the application?"))
                    {
                        try
                        {
                            LogManager.Log($"Setting new time zone to '{SelectedTimeZone.ToString()}'.");
                            NotificationProvider.SetGlobalBusyMessage("Setting new time zone...");
                            await OperationSystemManager.ChangeTimeZone(SelectedTimeZone);
                            NotificationProvider.ReleaseGlobalBusyMessage();
                            isRestarting = true;
                            ApplicationManager.Restart();
                        }
                        catch (Exception ex)
                        {
                            LogManager.Log(ex, "Error changing the time zone.");
                            NotificationProvider.ReleaseGlobalBusyMessage();
                            await NotificationProvider.ShowError($"Error setting timezone.\n{ex.FlattenMessage()}");
                        }
                    }
                }

                if (!BuildProvider.IsEureka)
                {
                    if (EnableProxy != Settings.EnableProxifier)
                    {
                        CmdCommand cmd = null;
                        CmdCommandResult result = null;

                        if (!EnableProxy)
                        {
                            try
                            {
                                cmd = new CmdCommand("taskkill", "/F /IM proxifier.exe");
                                result = await cmd.Run();
                                Settings.EnableProxifier = false;
                                Settings.Save();
                            }
                            catch (Exception ex)
                            {
                                LogManager.Log(ex, $"Unable to disable the proxy.\n{ex.Message}");
                                await NotificationProvider.ShowError($"Unable to disable the proxy.\n{ex.Message}");
                            }
                        }
                        else
                        {
                            try
                            {
                                Process.Start(@"C:\Program Files (x86)\Proxifier\Proxifier.exe");
                                Settings.EnableProxifier = true;
                                Settings.Save();
                            }
                            catch (Exception ex)
                            {
                                LogManager.Log(ex, $"Unable to start the proxy service.\n{ex.Message}");
                                await NotificationProvider.ShowError($"Unable to start the proxy service.\n{ex.Message}");
                            }
                        }
                    }

                    if (_previousEnableUWF != EnableUWF)
                    {
                        await NotificationProvider.ShowWarning("Changes to disk protection (UWF) will take effect only after a full system restart.");

                        try
                        {
                            LogManager.Log($"Changing UWF mode to '{EnableUWF}'.");
                            if (EnableUWF)
                            {
                                NotificationProvider.SetGlobalBusyMessage("Enabling disk protection (UWF)...");
                                await UnifiedWriteFilterManager.Enable();
                            }
                            else
                            {
                                NotificationProvider.SetGlobalBusyMessage("Disabling disk protection (UWF)...");
                                await UnifiedWriteFilterManager.Disable();
                            }
                            NotificationProvider.ReleaseGlobalBusyMessage();
                        }
                        catch (Exception ex)
                        {
                            NotificationProvider.ReleaseGlobalBusyMessage();
                            LogManager.Log(ex, "Error setting UWF mode.");
                            await NotificationProvider.ShowError($"Could not change the disk protection mode\n{ex.FlattenMessage()}");
                        }
                    }

                    if (!isRestarting)
                    {
                        await NavigationManager.NavigateBack();
                    }
                }
            }
        }

        protected override void OnValidating()
        {
            base.OnValidating();
        }

        /// <summary>
        /// Called when the application has been started
        /// </summary>
        public override void OnApplicationStarted()
        {
            try
            {
                TimeZones = OperationSystemManager.GetAvailableTimeZones().ToList();
            }
            catch (Exception ex)
            {
                LogManager.Log(ex, "Error retrieving available time zones.");
            }
        }

        public async override void OnApplicationReady()
        {
            base.OnApplicationReady();
            MachineDataSynchronizer.SynchronizationStarted += (_, __) => InvalidateRelayCommands();
            MachineDataSynchronizer.SynchronizationEnded += (_, __) => InvalidateRelayCommands();

            if (!BuildProvider.IsEureka)
            {
                if (!Settings.EnableProxifier)
                {
                    CmdCommand cmd = null;
                    CmdCommandResult result = null;

                    try
                    {
                        cmd = new CmdCommand("taskkill", "/F /IM proxifier.exe");
                        result = await cmd.Run();
                    }
                    catch (Exception ex)
                    {
                        LogManager.Log(ex, $"Unable to disable the proxy.\n{ex.Message}");
                    }
                }
            }

            using (ObservablesContext db = ObservablesContext.CreateDefault())
            {
                Rmls = (await new RmlsCollectionBuilder(db).SetAll().ForHeadType(MachineProvider.Machine.MachineHeadType).ForSite(MachineProvider.Machine.SiteGuid).BuildAsync()).OrderBy(x => x.FinalName).ToObservableCollection();
                SpoolTypes = await MachineProvider.Machine.GetSiteSpoolTypes(db);
            }
        }

        public async override void OnNavigatedTo()
        {
            base.OnNavigatedTo();

            Machine = MachineProvider.Machine.ShallowClone();

            RaisePropertyChanged(nameof(Machine));

            _enableHotSpot = HotSpotProvider.IsEnabled;
            RaisePropertyChanged(nameof(EnableHotSpot));

            HotSpotPassword = Settings.HotSpotPassword;

            _enableExternalBridge = ExternalBridgeService.Enabled;
            RaisePropertyChanged(nameof(EnableExternalBridge));

            ExternalBridgePassword = Settings.ExternalBridgePassword;

            SelectedIdleTime = PowerSavingModes.FirstOrDefault(x => x.Minutes == Settings.PowerSavingModeIdle);
            SelectedPowerOffTime = PowerSavingModes.FirstOrDefault(x => x.Minutes == Settings.PowerSavingModePowerOff);

            _enableRemoteAssistance = RemoteAssistanceProvider.IsEnabled;
            RaisePropertyChanged(nameof(EnableRemoteAssistance));

            EnableLockScreen = Settings.EnableLockScreen;
            LockScreenTimeoutMinutes = (int)Settings.LockScreenTimeout.TotalMinutes;
            LockScreenPassword = Settings.LockScreenPassword;

            FineTuningLength = Settings.FineTuningTrialLengthMeters;

            SelectedJobTypes = new SelectedObjectCollection<JobTypes>(Enum.GetValues(typeof(JobTypes)).Cast<JobTypes>().ToObservableCollection(), Settings.SupportedJobTypes.ToObservableCollection());
            SelectedColorSpaces = new SelectedObjectCollection<ColorSpaces>(Enum.GetValues(typeof(ColorSpaces)).Cast<ColorSpaces>().Where(x => x.IsUserSpace()).ToObservableCollection(), Settings.SupportedColorSpaces.ToObservableCollection());

            TabsColorSpaces = new ObservableCollection<ColorSpaces>(Enum.GetValues(typeof(ColorSpaces)).Cast<ColorSpaces>().Where(x => x != ColorSpaces.Volume /*&& x!= ColorSpaces.HSB*/).ToObservableCollection());
            DefaultTabColorSpace = Settings.DefaultTabColorSpace == null ? ColorSpaces.CMYK : TabsColorSpaces.SingleOrDefault(x => x == Settings.DefaultTabColorSpace);

            DefaultRML = Rmls.SingleOrDefault(x => x.Guid == Settings.DefaultRmlGuid);
            SelectedSpoolType = SpoolTypes.SingleOrDefault(x => x.Guid == Settings.SpoolTypeGuid);

            if (SelectedSpoolType == null)
            {
                SelectedSpoolType = SpoolTypes.FirstOrDefault(x => x.Code == (int)BL.Enumerations.SpoolTypes.StandardSpool);
            }

            SynchronizeJobs = Settings.SynchronizeJobs;
            SynchronizeDiagnostics = Settings.SynchronizeDiagnostics;

            AutoCheckForUpdates = Settings.AutoCheckForUpdates;

            var colorConversionSettings = SettingsManager.Default.GetOrCreate<ColorConversionSettings>();
            UseLightInks = colorConversionSettings.UseLightInks;

            SelectedTimeZone = TimeZones.SingleOrDefault(x => x.StandardName == TimeZone.CurrentTimeZone.StandardName);
            _previousTimeZone = SelectedTimeZone;

            if (!BuildProvider.IsEureka)
            {
                try
                {
                    EnableUWF = await UnifiedWriteFilterManager.IsEnabled();
                    _previousEnableUWF = EnableUWF;
                }
                catch (Exception ex)
                {
                    LogManager.Log(ex, "Error getting UWF status.");
                }
            }

            try
            {
                List<RmlLubricationLevelSettings> levels = new List<RmlLubricationLevelSettings>();

                foreach (var rml in Rmls)
                {
                    RmlLubricationLevel userLevel = Settings.LubricationLevels.FirstOrDefault(x => x.RmlGuid == rml.Guid);

                    RmlLubricationLevelSettings rmlLevel = new RmlLubricationLevelSettings();
                    rmlLevel.RmlGuid = rml.Guid;
                    rmlLevel.Name = rml.Name;
                    rmlLevel.LubricationLevel = userLevel != null ? userLevel.LubricationLevel : LubricationLevel.Standard;

                    levels.Add(rmlLevel);
                }

                LubricationLevels = levels;

                if (SelectedLubricationLevel != null)
                {
                    SelectedLubricationLevel = LubricationLevels.FirstOrDefault(x => x.RmlGuid == SelectedLubricationLevel.RmlGuid);
                }
                else
                {
                    SelectedLubricationLevel = LubricationLevels.FirstOrDefault();
                }
            }
            catch (Exception ex)
            {
                LogManager.Log(ex, "Error loading lubrication levels.");
            }

            if (!BuildProvider.IsEureka)
            {
                EnableProxy = Settings.EnableProxifier;
            }
        }

        private async void OnEnableRemoteAssistanceChanged()
        {
            if (EnableRemoteAssistance)
            {
                try
                {
                    await RemoteAssistanceProvider.EnableRemoteAssistance();
                }
                catch
                {
                    await NotificationProvider.ShowError("An error occurred while trying to activate the remote assistance service. Please check your device settings and try again.");
                    _enableRemoteAssistance = false;
                }
            }
            else
            {
                try
                {
                    await RemoteAssistanceProvider.DisableRemoteAssistance();
                }
                catch
                {
                    await NotificationProvider.ShowError("An error occurred while trying to deactivate the remote assistance service. Please check your device settings and try again.");
                    _enableRemoteAssistance = true;
                }
            }

            RaisePropertyChanged(nameof(EnableRemoteAssistance));
        }

        private async void OnEnableHotSpotChanged()
        {
            if (EnableHotSpot)
            {
                if (HotSpotPassword == null || HotSpotPassword.Length < 8 || HotSpotPassword.Length > 16)
                {
                    await NotificationProvider.ShowError("Hot spot requires a password of 8 to 16 characters.");
                    _enableHotSpot = false;
                    RaisePropertyChanged(nameof(EnableHotSpot));
                    return;
                }

                try
                {
                    await HotSpotProvider.EnableHotSpot(HotSpotPassword);
                }
                catch
                {
                    await NotificationProvider.ShowError("An error occurred while trying to activate the hot spot network. Please check your device settings and try again.");
                    _enableHotSpot = false;
                }
            }
            else
            {
                try
                {
                    await HotSpotProvider.DisableHotSpot();
                }
                catch
                {
                    await NotificationProvider.ShowError("An error occurred while trying to deactivate the hot spot network.");
                    _enableHotSpot = true;
                }
            }

            RaisePropertyChanged(nameof(EnableHotSpot));
        }

        private void OnEnableExternalBridgeChanged()
        {
            ExternalBridgeService.Enabled = EnableExternalBridge;
        }

        private async void Synchronize()
        {
            try
            {
                IsFree = false;
                NotificationProvider.SetGlobalBusyMessage("Synchronizing...");

                await MachineDataSynchronizer.Synchronize();

                NotificationProvider.ReleaseGlobalBusyMessage();
                await NotificationProvider.ShowSuccess("Synchronization completed successfully.");
            }
            catch (Exception ex)
            {
                NotificationProvider.ReleaseGlobalBusyMessage();
                await NotificationProvider.ShowError($"Error occurred while trying to synchronize.\n{ex.FlattenMessage()}");
            }
            finally
            {
                NotificationProvider.ReleaseGlobalBusyMessage();
                IsFree = true;
            }
        }
    }
}