Synnefo » Pithos MS Client

// -----------------------------------------------------------------------

// <copyright file="PreferencesViewModel.cs" company="Microsoft">

// TODO: Update copyright text.

// </copyright>

// -----------------------------------------------------------------------

using System.Collections.Concurrent;

using System.ComponentModel.Composition;

using System.IO;

using System.Reflection;

using System.Windows;

using System.Windows.Forms;

using Caliburn.Micro;

using IWshRuntimeLibrary;

using Pithos.Client.WPF.Configuration;

using Pithos.Client.WPF.Preferences;

using Pithos.Client.WPF.SelectiveSynch;

using Pithos.Core;

using Pithos.Interfaces;

using File = System.IO.File;

using Screen = Caliburn.Micro.Screen;

namespace Pithos.Client.WPF

{

    using System;

    using System.Linq;

    using System.Threading.Tasks;

    /// <summary>

    /// TODO: Update summary.

    /// </summary>

    [Export]

    public class PreferencesViewModel : Screen

    {

        private IEventAggregator _events;

        private PithosSettings _settings;

        public PithosSettings Settings

        {

            get { return _settings; }

            set

            {

                _settings = value;

                NotifyOfPropertyChange(()=>Settings);

            }

        }

        private ObservableConcurrentCollection<AccountSettings> _accounts;

        public ObservableConcurrentCollection<AccountSettings> Accounts

        {

            get { return _accounts; }

            set 

            { 

                _accounts = value;

                NotifyOfPropertyChange(()=>Accounts);

            }

        }

        public bool StartOnSystemStartup { get; set; }

        private static void CreateShortcut(string shortcutPath)

        {

            var wshShell = new WshShellClass();

            var shortcut = (IWshRuntimeLibrary.IWshShortcut) wshShell.CreateShortcut(

                shortcutPath);

            var exePath = Assembly.GetExecutingAssembly().Location;

            shortcut.TargetPath = exePath;

            shortcut.WorkingDirectory = Path.GetDirectoryName(exePath);

            shortcut.Description = "Pithos";            

            shortcut.Save();

        }

        public ShellViewModel Shell { get;  set; }

        //ShellExtensionController _extensionController=new ShellExtensionController();

        public PreferencesViewModel(IWindowManager windowManager, IEventAggregator events, ShellViewModel shell, PithosSettings settings)

        {

            _windowManager = windowManager;

            _events = events;

            DisplayName = "Pithos Preferences";

            Shell = shell;

            Settings=settings;

            Accounts = new ObservableConcurrentCollection<AccountSettings>();

            Accounts.AddFromEnumerable(settings.Accounts);

            var startupPath = Environment.GetFolderPath(Environment.SpecialFolder.Startup);

            _shortcutPath = Path.Combine(startupPath, "Pithos.lnk");

            StartOnSystemStartup = File.Exists(_shortcutPath);

        }

        #region Preferences Properties

        private bool _noProxy;

        public bool NoProxy

        {

            get { return _noProxy; }

            set

            {

                _noProxy = value;

                NotifyOfPropertyChange(()=>NoProxy);

            }

        }

        private bool _defaultProxy;

        public bool DefaultProxy

        {

            get { return _defaultProxy; }

            set

            {

                _defaultProxy = value;

                NotifyOfPropertyChange(() => DefaultProxy);

            }

        }

        private bool _manualProxy;

        public bool ManualProxy

        {

            get { return _manualProxy; }

            set

            {

                _manualProxy = value;

                NotifyOfPropertyChange(() => ManualProxy);

            }

        }

        #endregion

        #region Commands

        public bool CanSelectiveSyncFolders

        {

            get { return CurrentAccount != null; }

        }

        public void SelectiveSyncFolders()

        {

            var monitor = Shell.Monitors[CurrentAccount.AccountName];

            var folders=monitor.GetRootFolders();

            var model = new SelectiveSynchViewModel(folders,_events,CurrentAccount);

            if (_windowManager.ShowDialog(model) == true)

            {

            }

        }

        public void SaveChanges()

        {

            DoSave();

            TryClose(true);

        }

        public void RejectChanges()

        {

            Settings.Reload();

            TryClose(false);

        }

        public void ApplyChanges()

        {

            DoSave();

        }

        private void DoSave()

        {

            Settings.Save();

            SetStartupMode();

            foreach (var account in Settings.Accounts)

            {                                

                Shell.MonitorAccount(account);

            }

            NotifyOfPropertyChange(()=>Settings);

        }

        private void SetStartupMode()

        {

            if (StartOnSystemStartup && !File.Exists(_shortcutPath))

            {

                CreateShortcut(_shortcutPath);

            }

            else if (!StartOnSystemStartup && File.Exists(_shortcutPath))

            {

                if (File.Exists(_shortcutPath))

                    File.Delete(_shortcutPath);

            }

        }

     /*   public void ChangePithosFolder()

        {

            var browser = new FolderBrowserDialog();

            browser.SelectedPath = Settings.PithosPath;

            var result = browser.ShowDialog((IWin32Window)GetView());

            if (result == DialogResult.OK)

            {

                var newPath = browser.SelectedPath;

                var accountName = CurrentAccount.AccountName;

                var monitor = Shell.Monitors[accountName];

                monitor.Stop();

                Shell.Monitors.Remove(accountName);

                Directory.Move(Settings.PithosPath, newPath);

                Settings.PithosPath = newPath;

                Settings.Save();

                Shell.MonitorAccount(CurrentAccount);

                NotifyOfPropertyChange(() => Settings);                

            }

        }

*/

       public void AddAccount()

       {

           var wizard = new AddAccountViewModel();

           if (_windowManager.ShowDialog(wizard) == true)

           {

               var newAccount = new AccountSettings

                                    {

                                        AccountName = wizard.AccountName,

                                        ApiKey=wizard.Token,

                                        RootPath=wizard.AccountPath,

                                        IsActive=wizard.IsAccountActive,

                                        UsePithos=true

                                    };

               Settings.Accounts.Add(newAccount);

               (Accounts as IProducerConsumerCollection<AccountSettings>).TryAdd(newAccount);

               CurrentAccount = newAccount;

               NotifyOfPropertyChange(() => Accounts);

               NotifyOfPropertyChange(() => Settings);   

           }

       }

        public async void AddPithosAccount()

       {

            var credentials=await PithosAccount.RetrieveCredentialsAsync(Settings.PithosLoginUrl);

            var account = Settings.Accounts.FirstOrDefault(act => act.AccountName == credentials.UserName);

            if (account == null)

            {

                account=new AccountSettings{

                    AccountName=credentials.UserName,

                    ApiKey=credentials.Password,

                    UsePithos=true

                };

                Settings.Accounts.Add(account);

                (Accounts as IProducerConsumerCollection<AccountSettings>).TryAdd(account);

            }

            else

            {

                account.ApiKey=credentials.Password;

            }

            //SelectedAccountIndex= Settings.Accounts.IndexOf(account);

            CurrentAccount = account;

            NotifyOfPropertyChange(() => Accounts);

            NotifyOfPropertyChange(()=>Settings);                       

       }

        public void RemoveAccount()

        {

            var accountName = CurrentAccount.AccountName;

            Settings.Accounts.Remove(CurrentAccount);

            Accounts.TryRemove(CurrentAccount);

            CurrentAccount = null;

            //Accounts = Settings.Accounts;

            //Settings.Save();            

            Shell.RemoveMonitor(accountName);

            //NotifyOfPropertyChange("Settings.Accounts");

        }

        public bool CanRemoveAccount

        {

            get { return (CurrentAccount != null); }

        }

        public bool ExtensionsActivated

        {

            get { return Settings.ExtensionsActivated; }

            set

            {

                if (Settings.ExtensionsActivated == value)

                    return;

                Settings.ExtensionsActivated = value;

/*

                if (value)

                    _extensionController.RegisterExtensions();

                else

                {

                    _extensionController.UnregisterExtensions();

                }

*/

                NotifyOfPropertyChange(() => ExtensionsActivated);

            }

        }

        #endregion

       /* private int _selectedAccountIndex;

        public int SelectedAccountIndex

        {

            get { return _selectedAccountIndex; }

            set

            {

                //var accountCount=Settings.Accounts.Count;

                //if (accountCount == 0)

                //    return;

                //if (0 <= value && value < accountCount)

                //    _selectedAccountIndex = value;

                //else

                //    _selectedAccountIndex = 0;

                _selectedAccountIndex = value;

                NotifyOfPropertyChange(() => CurrentAccount);

                NotifyOfPropertyChange(() => CanRemoveAccount);

                NotifyOfPropertyChange(()=>SelectedAccountIndex);

            }

        }*/

        private AccountSettings _currentAccount;

        private IWindowManager _windowManager;

        private string _shortcutPath;

        public AccountSettings CurrentAccount

        {

            get { return _currentAccount; }

            set

            {

                _currentAccount = value;

                NotifyOfPropertyChange(()=>CurrentAccount);

                NotifyOfPropertyChange(() => CanRemoveAccount);

                NotifyOfPropertyChange(() => CanSelectiveSyncFolders);

                NotifyOfPropertyChange(() => CanMoveAccountFolder);

            }

        }

/*

        public AccountSettings CurrentAccount

        {

            get {

                if (0 <= SelectedAccountIndex && SelectedAccountIndex < Settings.Accounts.Count)                    

                    return Settings.Accounts[SelectedAccountIndex];

                return null;

            }

        }

*/

        public bool CanMoveAccountFolder

        {

            get { return CurrentAccount != null; }

        }

    public void MoveAccountFolder()

    {

        using (var dlg = new FolderBrowserDialog())

        {

            var currentFolder = CurrentAccount.RootPath;

            dlg.SelectedPath = currentFolder;

            //Ask the user to select a folder

            //Note: We need a parent window here, which we retrieve with GetView            

            var view = (Window)GetView();            

            if (DialogResult.OK != dlg.ShowDialog(new Wpf32Window(view)))

                return;            

            var newPath= dlg.SelectedPath;                

            //Find the account's monitor and stop it

            PithosMonitor monitor;

            if (Shell.Monitors.TryGetValue(CurrentAccount.AccountName, out monitor))

            {

                monitor.Stop();

                var oldPath = monitor.RootPath;

                //The old directory may not exist eg. if we create an account for the first time

                if (Directory.Exists(oldPath))

                {

                    //If it does, do the move

                    //Now Create all of the directories

                    foreach (string dirPath in Directory.EnumerateDirectories(oldPath, "*",

                                                           SearchOption.AllDirectories))

                        Directory.CreateDirectory(dirPath.Replace(oldPath, newPath));

                    //Copy all the files

                    foreach (string newFilePath in Directory.EnumerateFiles(oldPath, "*.*",

                                                                            SearchOption.AllDirectories))

                        File.Copy(newFilePath, newFilePath.Replace(oldPath, newPath));

                    Directory.Delete(oldPath, true);

                    //We also need to change the path of the existing file states

                    if (monitor != null)

                        monitor.MoveFileStates(oldPath, newPath);

                }

            }

            //Replace the old rootpath with the new

            CurrentAccount.RootPath = newPath;

            //TODO: This will save all settings changes. Too coarse grained, need to fix at a later date

            Settings.Save();            

            //And start the monitor on the new RootPath            

            if (monitor != null)

            {

                monitor.RootPath = newPath;

                if (CurrentAccount.IsActive)

                    monitor.Start();

            }

            else

                Shell.MonitorAccount(CurrentAccount);

            //Finally, notify that the Settings, CurrentAccount have changed

            NotifyOfPropertyChange(() => CurrentAccount);

            NotifyOfPropertyChange(() => Settings);

        }

    }

    }

}