Synnefo » Pithos MS Client

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

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

// TODO: Update copyright text.

// </copyright>

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

using System.Collections;

using System.ComponentModel.Composition;

using System.Diagnostics;

using System.IO;

using System.IO.IsolatedStorage;

using System.Linq.Expressions;

using System.Net;

using System.Reflection;

using System.Runtime.InteropServices;

using System.Runtime.Serialization;

using System.Windows;

using System.Windows.Forms;

using System.Windows.Interop;

using Caliburn.Micro;

using Hardcodet.Wpf.TaskbarNotification;

using Pithos.Client.WPF.Configuration;

using Pithos.Core;

using Pithos.Interfaces;

using IWin32Window = System.Windows.Forms.IWin32Window;

using Screen = Caliburn.Micro.Screen;

namespace Pithos.Client.WPF

{

    using System;

    using System.Collections.Generic;

    using System.Linq;

    using System.Text;

    using System.Threading.Tasks;

    /// <summary>

    /// TODO: Update summary.

    /// </summary>

    [Export(typeof(IShell))]

    public class PreferencesViewModel : Screen, IShell, IHandle<Notification>

    {

        private IEventAggregator _events;

        private PithosSettings _settings;

        public PithosSettings Settings

        {

            get { return _settings; }

            set

            {

                _settings = value;

                foreach (var account in _settings.Accounts.Where(account=>account.IsActive))

                {

                    if (String.IsNullOrWhiteSpace(account.RootPath))

                    {

                        account.RootPath = _settings.PithosPath;

                        _settings.Save();

                    }

                }

                NotifyOfPropertyChange(()=>Settings);

            }

        }

        private Dictionary<string,PithosMonitor> _monitors=new Dictionary<string, PithosMonitor>();

        public Dictionary<string, PithosMonitor> Monitors

        {

            get { return _monitors; }            

        }

        private TaskbarViewModel _taskbar;

        public TaskbarViewModel Taskbar

        {

            get { return _taskbar; }

            set

            {

                _taskbar = value;

            }

        }

        //ShellExtensionController _extensionController=new ShellExtensionController();

        [ImportingConstructor]

        public PreferencesViewModel(IEventAggregator events, TaskbarViewModel taskbar, PithosSettings settings)

        {

            _events = events;

            _events.Subscribe(this);

            DisplayName = "Pithos Preferences";

            Taskbar=taskbar;

            Taskbar.Parent = this;

            Settings=settings;            

            Taskbar.UsageMessage = "Using 15% of 50 GB";

            Taskbar.StatusMessage = "In Synch";            

        }

        protected override void OnViewAttached(object view, object context)

        {

            var window = (Window)view;

            base.OnViewAttached(view, context);

        }

        protected override void OnViewLoaded(object view)

        {

            var window = (Window)view;

            window.Hide();

            Taskbar.UpdateStatus();

            base.OnViewLoaded(view);

        }

        #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 void SaveChanges()

        {

            DoSave();

        }

        public void RejectChanges()

        {

            Settings.Reload();

        }

        public void ApplyChanges()

        {

            DoSave();

        }

        private void DoSave()

        {

            Settings.Save();

            NotifyOfPropertyChange(()=>Settings);

            var activeAccount = Settings.Accounts.FirstOrDefault(account => account.IsActive);

            if (activeAccount == null)

                return;

            if (String.IsNullOrWhiteSpace(activeAccount.AccountName))

                return;

            var monitor = Monitors[activeAccount.AccountName];

            monitor.ApiKey = activeAccount.ApiKey;

            monitor.UserName = activeAccount.AccountName;

            monitor.UsePithos = activeAccount.UsePithos;

            monitor.Start();

        }

        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;

                Directory.Move(Settings.PithosPath, newPath);

                Settings.PithosPath = newPath;

                Settings.Save();

                NotifyOfPropertyChange(() => Settings);

            }

        }

       public void AddAccount()

        {

            var newAccount = new AccountSettings();

            Settings.Accounts.Add(newAccount);

            SelectedAccountIndex= Settings.Accounts.Count-1;

            NotifyOfPropertyChange(()=>Settings);

        }

        public void AddPithosAccount()

       {

           var task=PithosAccount.RetrieveCredentialsAsync(Settings.PithosSite)

               .ContinueWith(t=>

                   {                       

                       var credentials=t.Result;

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

                       }

                       else

                       {

                           account.ApiKey=credentials.Password;

                       }

                       SelectedAccountIndex= Settings.Accounts.IndexOf(account);

                       NotifyOfPropertyChange(()=>Settings);

                   });

            ((Task)task).WaitWithPumping();

       }

        public void RemoveAccount()

        {

            Settings.Accounts.RemoveAll(account => account.AccountName == CurrentAccount.AccountName);

            NotifyOfPropertyChange(()=>CurrentAccount);

            NotifyOfPropertyChange(()=>Settings);

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

            }

        }

        public void RefreshOverlays()

        {

            string path=Settings.PithosPath;

            if (String.IsNullOrWhiteSpace(path))

                throw new ArgumentNullException("path", "The path parameter must not be emtpy");

            if (!Directory.Exists(path) && !File.Exists(path))

                throw new FileNotFoundException("The specified file or path does not exist", path);

            IntPtr pathPointer = Marshal.StringToCoTaskMemAuto(path);

            try

            {

                NativeMethods.SHChangeNotify(HChangeNotifyEventID.SHCNE_UPDATEITEM,

                                             HChangeNotifyFlags.SHCNF_PATHW | HChangeNotifyFlags.SHCNF_FLUSHNOWAIT,

                                             pathPointer, IntPtr.Zero);

            }

            finally

            {

                Marshal.FreeHGlobal(pathPointer);

            }

        }

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

        public AccountSettings CurrentAccount

        {

            get {

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

                    return Settings.Accounts[SelectedAccountIndex];

                return null;

            }

        }

        public void Handle(Notification notification)

        {

            if (!Settings.ShowDesktopNotifications)

                return;

            BalloonIcon icon = BalloonIcon.None;

            switch (notification.Level)

            {

                case TraceLevel.Error:

                    icon = BalloonIcon.Error;

                    break;

                case TraceLevel.Info:

                case TraceLevel.Verbose:

                    icon = BalloonIcon.Info;

                    break;

                case TraceLevel.Warning:

                    icon = BalloonIcon.Warning;

                    break;

                default:

                    icon = BalloonIcon.None;

                    break;

            }

            var tv = (PreferencesView)this.GetView();

            tv.TaskbarView.ShowBalloonTip(notification.Title, notification.Message, icon);

        }

    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

            var monitor = Monitors[CurrentAccount.AccountName];            

            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

                Directory.Move(oldPath, newPath);

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

                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            

            monitor.RootPath = newPath;

            monitor.Start();

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

            NotifyOfPropertyChange(() => CurrentAccount);

            NotifyOfPropertyChange(() => Settings);

        }

    }

    }

}