Software/Visual_Studio/Tango.UnitTesting/Integration/JobDescriptionFile_TST.cs


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65

using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Collections.Specialized;
using System.ComponentModel;
using System.ComponentModel.DataAnnotations;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Data;
using Tango.BL;
using Tango.BL.Builders;
using Tango.BL.Entities;
using Tango.BL.Enumerations;
using Tango.Core.Commands;
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.Messages;
using Tango.SharedUI.Components;
using Tango.WiFi;

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
    {
        #region Properties

        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<Rml> _rmls;
        public ObservableCollection<Rml> Rmls
        {
            get { return _rmls; }
            set { _rmls = 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 _defaultSpoolType;
        public SpoolType DefaultSpoolType
        {
            get { return _defaultSpoolType; }
            set { _defaultSpoolType = 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(); }
        }

        #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()
        {
            SaveCommand = new RelayCommand(Save);
            DiscardCommand = new RelayCommand(Discard);
            SynchronizeCommand = new RelayCommand(Synchronize, () => !MachineDataSynchronizer.IsSynchronizing && IsFree && (SynchronizeJobs || SynchronizeDiagnostics));
        }

        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;
                Settings.DefaultSpoolTypeGuid = DefaultSpoolType?.Guid;
                Settings.SynchronizeJobs = SynchronizeJobs;
                Settings.SynchronizeDiagnostics = SynchronizeDiagnostics;
                Settings.AutoCheckForUpdates = AutoCheckForUpdates;

                MachineDataSynchronizer.IsEnabled = SynchronizeJobs || SynchronizeDiagnostics;

                Settings.Save();

                await MachineProvider.SaveMachine();
                await NavigationManager.NavigateBack();
            }
        }

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

        /// <summary>
        /// Called when the application has been started
        /// </summary>
        public override void OnApplicationStarted()
        {

        }

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

            using (ObservablesContext db = ObservablesContext.CreateDefault())
            {
                Rmls = await new RmlsCollectionBuilder(db).SetAll().ForSite(MachineProvider.Machine.SiteGuid).BuildAsync();
            }
        }

        public 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;

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

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

            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());

            DefaultRML = Adapter.Rmls.SingleOrDefault(x => x.Guid == Settings.DefaultRmlGuid);
            DefaultSpoolType = Adapter.SpoolTypes.SingleOrDefault(x => x.Guid == Settings.DefaultSpoolTypeGuid);

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

            AutoCheckForUpdates = Settings.AutoCheckForUpdates;
        }

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