Synnefo » Pithos MS Client

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

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

// TODO: Update copyright text.

// </copyright>

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

using System.ComponentModel.Composition;

using System.Diagnostics;

using System.IO;

using System.Threading.Tasks;

using System.Windows;

using Caliburn.Micro;

using Pithos.Client.WPF.Properties;

using Pithos.Core;

using Pithos.Interfaces;

namespace Pithos.Client.WPF

{

    using System;

    using System.Collections.Generic;

    using System.Linq;

    using System.Text;

    /// <summary>

    /// TODO: Update summary.

    /// </summary>

    [Export]

    public class TaskbarViewModel:ViewAware,IStatusNotification

    {

        private IStatusChecker _statusChecker;

        private IEventAggregator _events;

        public PithosMonitor Monitor { get; private set; }

        public IPithosSettings Settings { get; private set; }

        public IScreen Parent { get; set; }

        [ImportingConstructor]

        public TaskbarViewModel(IEventAggregator events, IStatusChecker statusChecker,PithosMonitor monitor,IPithosSettings settings)

        {

            OpenPithosFolderCommand = new PithosCommand(OpenPithosFolder);

            _statusChecker = statusChecker;

            _events = events;            

            Settings = settings;

            Monitor = monitor;

            Monitor.StatusNotification = this;

            var account=settings.Accounts.FirstOrDefault(act => act.IsActive);

            if (account != null)

            {

                Monitor.UserName = account.AccountName;

                Monitor.ApiKey = account.ApiKey;

                Monitor.UsePithos = account.UsePithos;

                var appSettings = Properties.Settings.Default;

                Monitor.AuthenticationUrl = account.UsePithos

                                                ? appSettings.PithosAuthenticationUrl

                                                : appSettings.CloudfilesAuthenticationUrl;

                Monitor.RootPath = Path.Combine(Settings.PithosPath, account.RootPath??"");

            }

        }

        #region Status Properties

        private string _statusMessage;

        public string StatusMessage

        {

            get { return _statusMessage; }

            set

            {

                _statusMessage = value;

                NotifyOfPropertyChange(() => StatusMessage);

            }

        }

        private string _usageMessage;

        public string UsageMessage

        {

            get { return _usageMessage; }

            set

            {

                _usageMessage = value;

                NotifyOfPropertyChange(() => UsageMessage);

            }

        }

        private string _pauseSyncCaption="Pause Syncing";

        public string PauseSyncCaption

        {

            get { return _pauseSyncCaption; }

            set

            {

                _pauseSyncCaption = value;

                NotifyOfPropertyChange(() => PauseSyncCaption);

            }

        }

        private readonly IObservableCollection<FileEntry> _recentFiles = new BindableCollection<FileEntry>();

        public IObservableCollection<FileEntry> RecentFiles

        {

            get { return _recentFiles; }

        }

        private string _statusIcon;

        public string StatusIcon

        {

            get { return _statusIcon; }

            set

            {

                _statusIcon = value;

                NotifyOfPropertyChange(() => StatusIcon);

            }

        }

        #endregion

        #region Commands

        public void ShowPreferences()

        {

            Settings.Reload();

        }

        public PithosCommand OpenPithosFolderCommand { get; private set; }

        public void OpenPithosFolder()

        {

            Process.Start(Settings.PithosPath);

        }

        public void GoToSite()

        {

            Process.Start(Properties.Settings.Default.PithosSite);

        }

        public void ToggleSynching()

        {

            Monitor.Pause = !Monitor.Pause;

            PauseSyncCaption = Monitor.Pause ? "Resume syncing" : "Pause syncing";

            var iconKey = Monitor.Pause ? "TraySyncPaused" : "TrayInSynch";

            StatusIcon = String.Format(@"Images/{0}.ico", iconKey);

        }

        public void ExitPithos()

        {

            Monitor.Stop();

            Parent.TryClose();

        }

        #endregion

        private Dictionary<PithosStatus, StatusInfo> iconNames = new List<StatusInfo>

            {

                new StatusInfo(PithosStatus.InSynch, "All files up to date", "TrayInSynch"),

                new StatusInfo(PithosStatus.Syncing, "Syncing Files", "TraySynching"),

                new StatusInfo(PithosStatus.SyncPaused, "Sync Paused", "TraySyncPaused")

            }.ToDictionary(s => s.Status);

        public void UpdateStatus()

        {

            var pithosStatus = _statusChecker.GetPithosStatus();

            if (iconNames.ContainsKey(pithosStatus))

            {

                var info = iconNames[pithosStatus];

                StatusIcon = String.Format(@"Images/{0}.ico", info.IconName);

                StatusMessage = String.Format("Pithos 1.0\r\n{0}", info.StatusText);

            }

            var tv=this.GetView();

            _events.Publish(new Notification { Title = "Start", Message = "Start Monitoring", Level = TraceLevel.Info});

            if (!String.IsNullOrWhiteSpace(Monitor.UserName) &&

                !String.IsNullOrWhiteSpace(Monitor.ApiKey))

                Task.Factory.StartNew(() => 

                    Monitor.Start())

                    .ContinueWith(t =>{

                        if (t.IsFaulted)

                        {

                            var message= String.Format("An exception occured. Can't start monitoring\n{0}",t.Exception);

                            _events.Publish(new Notification { Title = "Error",Message=message,Level= TraceLevel.Error });

                            MessageBox.Show(message);

                        }

                    });                

        }

        public void NotifyChange(string status, TraceLevel level=TraceLevel.Info)

        {

            this.StatusMessage = status;

            _events.Publish(new Notification { Title = "Pithos", Message = status, Level = level });

        }

    }

}