Synnefo » Pithos MS Client

using System;

using System.Collections.Generic;

using System.ComponentModel;

using System.ComponentModel.Composition;

using System.IO;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

using System.Windows;

using System.Windows.Controls;

using System.Windows.Forms;

using Caliburn.Micro;

using Pithos.Client.WPF.Properties;

using Pithos.Core;

using Pithos.Network;

using MessageBox = System.Windows.MessageBox;

using Screen = Caliburn.Micro.Screen;

namespace Pithos.Client.WPF.Preferences

{

    [Export(typeof(AddAccountViewModel))]

    public class AddAccountViewModel:Screen

    {

        private readonly List<string> _servers;

        public List<string> Servers

        {

            get { return _servers; }

        }

        private bool _isValidServer;

        public bool IsValidServer

        {

            get { return _isValidServer; }

            set

            {

                _isValidServer = value;

                NotifyOfPropertyChange(()=>IsValidServer);

            }

        }

        private string _currentServer;

        public string CurrentServer

        {

            get { return _currentServer; }

            set

            {

                if (!Uri.IsWellFormedUriString(value, UriKind.Absolute))

                {

                    IsValidServer = false;

                    throw new UriFormatException();

                }

                _currentServer = value;

                IsValidServer = true;

                HasValidCredentials = false;

                IsConfirmed = false;

                NotifyOfPropertyChange(()=>CurrentServer);

            }

        }

        private string _accountName;

        public string AccountName

        {

            get { return _accountName; }

            set

            {

                _accountName = value;

                NotifyOfPropertyChange(()=>AccountName);

                NotifyOfPropertyChange(() => HasCredentials);

            }

        }

        private string _token;

        public string Token

        {

            get { return _token; }

            set

            {

                _token = value;

                NotifyOfPropertyChange(()=>Token);

                NotifyOfPropertyChange(() => HasCredentials);

            }

        }

        private string _accountPath;

        public string AccountPath

        {

            get { return _accountPath; }

            set

            {

                _accountPath = value;

                NotifyOfPropertyChange(() => AccountPath);

                NotifyOfPropertyChange(() => HasAccountPath);

            }

        }

        public bool HasAccountPath

        {

            get { return !String.IsNullOrWhiteSpace(AccountPath); }

        }

        public bool HasCredentials

        {

            get { return !(String.IsNullOrWhiteSpace(AccountName) || String.IsNullOrWhiteSpace(Token) ) ; }

        }

        private bool  _isConfirmed;

        public bool IsConfirmed

        {

            get { return _isConfirmed; }

            set

            {

                _isConfirmed = value;

                HasValidCredentials = false;

                NotifyOfPropertyChange(() => IsConfirmed);

            }

        }

        private bool _isAccountActive;

        public bool IsAccountActive

        {

            get { return _isAccountActive; }

            set

            {

                _isAccountActive = value;

                NotifyOfPropertyChange(() => IsAccountActive);

            }

        }

        public void SelectAccount()

        {

            using (var dlg = new FolderBrowserDialog())

            {

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

                AccountPath= dlg.SelectedPath;

            }

        }

        private bool _isRetrieving;

        public bool IsRetrieving

        {

            get { return _isRetrieving; }

            set

            {

                _isRetrieving = value;

                NotifyOfPropertyChange(() => IsRetrieving);

            }

        }

        public async void RetrieveCredentials()

        {

            IsRetrieving = true;

            IsConfirmed = false;

            try

            {

                var credentials = await PithosAccount.RetrieveCredentials(Settings.Default.PithosLoginUrl);

                AccountName = credentials.UserName;

                Token = credentials.Password;

                IsConfirmed = true;

            }

            catch (Exception exc)

            {

                IsConfirmed = false;

                MessageBox.Show(exc.ToString(), "Error");

                throw;

            }

            IsRetrieving = false;

        }

        public AddAccountViewModel()

        {

            _servers=new List<string>

                         {

                             Settings.Default.ProductionServer, 

                             Settings.Default.DevelopmentServer

                         };

            CurrentServer = _servers[0];

        }

        private bool _hasValidCredentials;

        public bool HasValidCredentials

        {

            get { return _hasValidCredentials; }

            set

            {

                _hasValidCredentials = value;

                NotifyOfPropertyChange(()=>HasValidCredentials);

            }

        }

        private bool _isValidating;

        public bool IsValidating

        {

            get { return _isValidating; }

            set

            {

                _isValidating = value;

                NotifyOfPropertyChange(()=>IsValidating);

            }

        }

        public async void TestAccount()

        {

            try

            {

                IsValidating = true;

                var client = new CloudFilesClient(AccountName, Token) {AuthenticationUrl = CurrentServer};                

                var containers = await TaskEx.Run(()=>

                                                      {

                                                          client.Authenticate();

                                                          return client.ListContainers(AccountName);

                                                      });

                HasValidCredentials = true;                

            }

            catch (Exception ex)

            {

                HasValidCredentials = false;

                MessageBox.Show("The account is not valid", "Account Error", MessageBoxButton.OK, MessageBoxImage.Stop);

                throw;

            }

            finally

            {

                IsValidating = false;

            }

        }

    }

}