aboutsummaryrefslogtreecommitdiffstats
path: root/Software/Visual_Studio/Tango.FileSystem/FileSystemItem.cs
blob: c78a1173254d510e4f3eee7a96cc1db00c87591f (plain)
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
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Media.Imaging;
using Tango.Core;
using Tango.FileSystem.Network;

namespace Tango.FileSystem
{
    public abstract class FileSystemItem : ExtendedObject
    {
        private String _path;
        public String Path
        {
            get { return _path; }
            set { _path = value; RaisePropertyChangedAuto(); RaisePropertyChanged(nameof(Name)); }
        }

        public FileSystemItemType Type { get; protected set; }

        public abstract String Description { get; }

        public DateTime DateModified { get; set; }

        public DateTime DateCreated { get; set; }

        public long Size { get; set; }

        public String Name
        {
            get { return OnGetName(); }
        }

        public FileSystemItem()
        {
            DateModified = DateTime.Now;
            Size = 1000 * 1000;
        }

        protected virtual String OnGetName()
        {
            return System.IO.Path.GetFileName(Path);
        }

        public override string ToString()
        {
            return Name;
        }

        public static FileSystemItem FromDTO(FileSystemItemDTO dto)
        {
            FileSystemItem item = null;

            if (dto.Type == FileSystemItemType.Drive)
            {
                item = new DriveItem()
                {
                    DriveType = dto.DriveType,
                    Label = dto.DriveLabel,
                    Items = dto.Items?.Select(x => FromDTO(x)).ToObservableCollection()
                };
            }
            else if (dto.Type == FileSystemItemType.Folder)
            {
                item = new FolderItem()
                {
                    Items = dto.Items?.Select(x => FromDTO(x)).ToObservableCollection(),
                    IsRoot = dto.IsRoot,
                };
            }
            else if (dto.Type == FileSystemItemType.File)
            {
                item = new FileItem();
            }

            item.DateModified = dto.DateModified;
            item.DateCreated = dto.DateCreated;
            item.Path = dto.Path;
            item.Size = dto.Size;
            item.Type = dto.Type;

            return item;
        }

        public String GetParent()
        {
            if (Path == "/") return null;

            String root = System.IO.Path.GetPathRoot(Path);
            var parent = Directory.GetParent(Path);

            if (root == "\\")
            {
                return parent.FullName.Replace(parent.Root.FullName, "/").Replace("\\", "/");
            }
            else if (parent != null)
            {
                return parent.FullName;
            }
            else
            {
                return null;
            }
        }
    }
}
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); } 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().ForHeadType(MachineProvider.Machine.MachineHeadType).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; } } } }