Synnefo » Pithos MS Client

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

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

// TODO: Update copyright text.

// </copyright>

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

using System.Collections.Concurrent;

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 ObservableConcurrentCollection<FileEntry> _recentFiles = new ObservableConcurrentCollection<FileEntry>();

        public ObservableConcurrentCollection<FileEntry> RecentFiles

        {

            get { return _recentFiles; }

        }

        private string _statusIcon="Images/Tray.ico";

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

                StartMonitor();                

        }

        private void StartMonitor()

        {

            Task.Factory.StartNew(() =>

            {

                try

                {

                    Monitor.Start();

                }

                catch(Exception exc)

                {

                    var message = String.Format("An exception occured. Can't start monitoring\nWill retry in 10 seconds\n{0}",exc);

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

                    Task.Factory.StartNewDelayed(10000, StartMonitor);                    

                }

            });

        }

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

        {

            this.StatusMessage = status;

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

        }

        public void NotifyChangedFile(string filePath)

        {

            var entry = new FileEntry {FullPath=filePath};

            IProducerConsumerCollection<FileEntry> files=this.RecentFiles;

            FileEntry popped;

            while (files.Count > 5)

                files.TryTake(out popped);

            files.TryAdd(entry);

        }

    }

}