Statistics
| Branch: | Revision:

root / trunk / Pithos.Client.WPF / Shell / ShellViewModel.cs @ 8f44fd3a

History | View | Annotate | Download (34.8 kB)

1
#region
2
/* -----------------------------------------------------------------------
3
 * <copyright file="ShellViewModel.cs" company="GRNet">
4
 * 
5
 * Copyright 2011-2012 GRNET S.A. All rights reserved.
6
 *
7
 * Redistribution and use in source and binary forms, with or
8
 * without modification, are permitted provided that the following
9
 * conditions are met:
10
 *
11
 *   1. Redistributions of source code must retain the above
12
 *      copyright notice, this list of conditions and the following
13
 *      disclaimer.
14
 *
15
 *   2. Redistributions in binary form must reproduce the above
16
 *      copyright notice, this list of conditions and the following
17
 *      disclaimer in the documentation and/or other materials
18
 *      provided with the distribution.
19
 *
20
 *
21
 * THIS SOFTWARE IS PROVIDED BY GRNET S.A. ``AS IS'' AND ANY EXPRESS
22
 * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
23
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
24
 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL GRNET S.A OR
25
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
26
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
27
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
28
 * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
29
 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
30
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
31
 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
32
 * POSSIBILITY OF SUCH DAMAGE.
33
 *
34
 * The views and conclusions contained in the software and
35
 * documentation are those of the authors and should not be
36
 * interpreted as representing official policies, either expressed
37
 * or implied, of GRNET S.A.
38
 * </copyright>
39
 * -----------------------------------------------------------------------
40
 */
41
#endregion
42
using System.Collections.Concurrent;
43
using System.Diagnostics;
44
using System.Diagnostics.Contracts;
45
using System.IO;
46
using System.Net;
47
using System.Reflection;
48
using System.Runtime.InteropServices;
49
using System.ServiceModel;
50
using System.Threading.Tasks;
51
using System.Windows;
52
using System.Windows.Controls.Primitives;
53
using AppLimit.NetSparkle;
54
using Caliburn.Micro;
55
using Hardcodet.Wpf.TaskbarNotification;
56
using Pithos.Client.WPF.Configuration;
57
using Pithos.Client.WPF.FileProperties;
58
using Pithos.Client.WPF.Preferences;
59
using Pithos.Client.WPF.SelectiveSynch;
60
using Pithos.Client.WPF.Services;
61
using Pithos.Client.WPF.Shell;
62
using Pithos.Core;
63
using Pithos.Core.Agents;
64
using Pithos.Interfaces;
65
using System;
66
using System.Collections.Generic;
67
using System.Linq;
68
using Pithos.Network;
69
using StatusService = Pithos.Client.WPF.Services.StatusService;
70

    
71
namespace Pithos.Client.WPF {
72
	using System.ComponentModel.Composition;
73

    
74
	
75
	///<summary>
76
	/// The "shell" of the Pithos application displays the taskbar  icon, menu and notifications.
77
	/// The shell also hosts the status service called by shell extensions to retrieve file info
78
	///</summary>
79
	///<remarks>
80
	/// It is a strange "shell" as its main visible element is an icon instead of a window
81
	/// The shell subscribes to the following events:
82
	/// * Notification:  Raised by components that want to notify the user. Usually displayed in a balloon
83
	/// * SelectiveSynchChanges: Notifies that the user made changes to the selective synch folders for an account. Raised by the Selective Synch dialog. Located here because the monitors are here
84
	/// * ShowFilePropertiesEvent: Raised when a shell command requests the display of the file/container properties dialog
85
	///</remarks>		
86
	//TODO: CODE SMELL Why does the shell handle the SelectiveSynchChanges?
87
    [Export(typeof(IShell)), Export(typeof(ShellViewModel))]
88
	public class ShellViewModel : Screen, IStatusNotification, IShell,
89
		IHandle<Notification>, IHandle<SelectiveSynchChanges>, IHandle<ShowFilePropertiesEvent>
90
	{
91

    
92
		//The Status Checker provides the current synch state
93
		//TODO: Could we remove the status checker and use events in its place?
94
		private readonly IStatusChecker _statusChecker;
95
		private readonly IEventAggregator _events;
96

    
97
		public PithosSettings Settings { get; private set; }
98

    
99

    
100
		private readonly ConcurrentDictionary<Uri, PithosMonitor> _monitors = new ConcurrentDictionary<Uri, PithosMonitor>();
101
		///<summary>
102
		/// Dictionary of account monitors, keyed by account
103
		///</summary>
104
		///<remarks>
105
		/// One monitor class is created for each account. The Shell needs access to the monitors to execute start/stop/pause commands,
106
		/// retrieve account and boject info		
107
		///</remarks>
108
		// TODO: Does the Shell REALLY need access to the monitors? Could we achieve the same results with a better design?
109
		// TODO: The monitors should be internal to Pithos.Core, even though exposing them makes coding of the Object and Container windows easier
110
		public ConcurrentDictionary<Uri, PithosMonitor> Monitors
111
		{
112
			get { return _monitors; }
113
		}
114

    
115

    
116
		///<summary>
117
		/// The status service is used by Shell extensions to retrieve file status information
118
		///</summary>
119
		//TODO: CODE SMELL! This is the shell! While hosting in the shell makes executing start/stop commands easier, it is still a smell
120
		private ServiceHost _statusService;
121

    
122
		//Logging in the Pithos client is provided by log4net
123
        private static readonly log4net.ILog Log = log4net.LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
124

    
125
	    private readonly PollAgent _pollAgent;
126

    
127

    
128
	    private MiniStatusViewModel _miniStatus;
129

    
130
	    [Import]
131
        public MiniStatusViewModel MiniStatus
132
	    {
133
	        get { return _miniStatus; }
134
	        set
135
	        {
136
	            _miniStatus = value;
137
	            _miniStatus.Shell = this;
138
	            _miniStatus.Deactivated += (sender, arg) =>
139
	                                           {
140
	                                               _statusVisible = false;
141
                                                   NotifyOfPropertyChange(()=>MiniStatusCaption);
142
	                                           };
143
	        }
144
	    }
145

    
146
	    ///<summary>
147
		/// The Shell depends on MEF to provide implementations for windowManager, events, the status checker service and the settings
148
		///</summary>
149
		///<remarks>
150
		/// The PithosSettings class encapsulates the app's settings to abstract their storage mechanism (App settings, a database or registry)
151
		///</remarks>
152
		[ImportingConstructor]		
153
		public ShellViewModel(IWindowManager windowManager, IEventAggregator events, IStatusChecker statusChecker, PithosSettings settings,PollAgent pollAgent)
154
		{
155
			try
156
			{
157

    
158
				_windowManager = windowManager;
159
				//CHECK: Caliburn doesn't need explicit command construction
160
				//OpenPithosFolderCommand = new PithosCommand(OpenPithosFolder);
161
				_statusChecker = statusChecker;
162
				//The event subst
163
				_events = events;
164
				_events.Subscribe(this);
165

    
166
			    _pollAgent = pollAgent;
167
				Settings = settings;
168

    
169
				Proxy.SetFromSettings(settings);
170

    
171
                StatusMessage = Settings.Accounts.Count==0 
172
                    ? "No Accounts added\r\nPlease add an account" 
173
                    : "Starting";
174

    
175
				_accounts.CollectionChanged += (sender, e) =>
176
												   {
177
													   NotifyOfPropertyChange(() => OpenFolderCaption);
178
													   NotifyOfPropertyChange(() => HasAccounts);
179
												   };
180

    
181
                SetVersionMessage();
182
			}
183
			catch (Exception exc)
184
			{
185
				Log.Error("Error while starting the ShellViewModel",exc);
186
				throw;
187
			}
188

    
189
		}
190

    
191
	    private void SetVersionMessage()
192
	    {
193
	        Assembly assembly = Assembly.GetExecutingAssembly();
194
	        var fileVersion = FileVersionInfo.GetVersionInfo(assembly.Location);
195
	        VersionMessage = String.Format("Pithos+ {0}", fileVersion.FileVersion);
196
	    }
197

    
198
        public void OnStatusAction()
199
        {
200
            if (Accounts.Count==0)
201
            {
202
                ShowPreferences("AccountTab");
203
            }
204
        }
205
	    protected override void OnActivate()
206
		{
207
			base.OnActivate();
208

    
209
            InitializeSparkle();
210

    
211
	        //Must delay opening the upgrade window
212
            //to avoid Windows Messages sent by the TaskbarIcon
213
            TaskEx.Delay(5000).ContinueWith(_=>
214
                Execute.OnUIThread(()=> _sparkle.StartLoop(true,Settings.UpdateForceCheck,Settings.UpdateCheckInterval)));
215

    
216

    
217
			StartMonitoring();                    
218
		}
219

    
220

    
221
	    private void OnCheckFinished(object sender, bool updaterequired)
222
	    {
223
            
224
            Log.InfoFormat("Upgrade check finished. Need Upgrade: {0}", updaterequired);
225
            if (_manualUpgradeCheck)
226
            {
227
                _manualUpgradeCheck = false;
228
                if (!updaterequired)
229
                    //Sparkle raises events on a background thread
230
                    Execute.OnUIThread(()=>
231
                        ShowBalloonFor(new Notification{Title="Pithos+ is up to date",Message="You have the latest Pithos+ version. No update is required"}));
232
            }
233
	    }
234

    
235
	    private void OnUpgradeDetected(object sender, UpdateDetectedEventArgs e)
236
	    {            
237
	        Log.InfoFormat("Update detected {0}",e.LatestVersion);
238
	    }
239

    
240
        public void CheckForUpgrade()
241
        {
242
            ShowBalloonFor(new Notification{Title="Checking for upgrades",Message="Contacting the server to retrieve the latest Pithos+ version."});
243
            _sparkle.StopLoop();
244
            _sparkle.updateDetected -= OnUpgradeDetected;
245
            _sparkle.checkLoopFinished -= OnCheckFinished;
246
            _sparkle.Dispose();
247

    
248
            _manualUpgradeCheck = true;
249
            InitializeSparkle();
250
            _sparkle.StartLoop(true,true,Settings.UpdateCheckInterval);
251
        }
252

    
253
        private void InitializeSparkle()
254
        {
255
            _sparkle = new Sparkle(Settings.UpdateUrl);
256
            _sparkle.updateDetected += OnUpgradeDetected;
257
            _sparkle.checkLoopFinished += OnCheckFinished;
258
            _sparkle.ShowDiagnosticWindow = Settings.UpdateDiagnostics;
259
        }
260

    
261
	    private async void StartMonitoring()
262
		{
263
			try
264
			{
265
                if (Settings.IgnoreCertificateErrors)
266
                {
267
                    ServicePointManager.ServerCertificateValidationCallback = (sender, certificate, chain, errors) => true;
268
                }
269
                    
270
				var accounts = Settings.Accounts.Select(MonitorAccount);
271
				await TaskEx.WhenAll(accounts);
272
				_statusService = StatusService.Start();
273

    
274
			}
275
			catch (AggregateException exc)
276
			{
277
				exc.Handle(e =>
278
				{
279
					Log.Error("Error while starting monitoring", e);
280
					return true;
281
				});
282
				throw;
283
			}
284
		}
285

    
286
		protected override void OnDeactivate(bool close)
287
		{
288
			base.OnDeactivate(close);
289
			if (close)
290
			{
291
				StatusService.Stop(_statusService);
292
				_statusService = null;
293
			}
294
		}
295

    
296
		public Task MonitorAccount(AccountSettings account)
297
		{
298
			return Task.Factory.StartNew(() =>
299
			{                                                
300
				PithosMonitor monitor;
301
				var accountName = account.AccountName;
302

    
303
				if (Monitors.TryGetValue(account.AccountKey, out monitor))
304
				{
305
					//If the account is active
306
                    if (account.IsActive)
307
                    {
308
                        //The Api Key may have changed throuth the Preferences dialog
309
                        monitor.ApiKey = account.ApiKey;
310
						Debug.Assert(monitor.StatusNotification == this,"An existing monitor should already have a StatusNotification service object");
311
                        monitor.RootPath = account.RootPath;
312
                        //Start the monitor. It's OK to start an already started monitor,
313
                        //it will just ignore the call                        
314
                        StartMonitor(monitor).Wait();
315
                    }
316
                    else
317
                    {
318
                        //If the account is inactive
319
                        //Stop and remove the monitor
320
                        RemoveMonitor(account.ServerUrl,accountName);
321
                    }
322
					return;
323
				}
324

    
325
				
326
				//Create a new monitor/ Can't use MEF here, it would return a single instance for all monitors
327
				monitor = new PithosMonitor
328
							  {
329
								  UserName = accountName,
330
								  ApiKey = account.ApiKey,                                  
331
								  StatusNotification = this,
332
								  RootPath = account.RootPath
333
							  };
334
				//PithosMonitor uses MEF so we need to resolve it
335
				IoC.BuildUp(monitor);
336

    
337
				monitor.AuthenticationUrl = account.ServerUrl;
338

    
339
				Monitors[account.AccountKey] = monitor;
340

    
341
				if (account.IsActive)
342
				{
343
					//Don't start a monitor if it doesn't have an account and ApiKey
344
					if (String.IsNullOrWhiteSpace(monitor.UserName) ||
345
						String.IsNullOrWhiteSpace(monitor.ApiKey))
346
						return;
347
					StartMonitor(monitor);
348
				}
349
			});
350
		}
351

    
352

    
353
		protected override void OnViewLoaded(object view)
354
		{
355
			UpdateStatus();
356
			var window = (Window)view;            
357
			TaskEx.Delay(1000).ContinueWith(t => Execute.OnUIThread(window.Hide));
358
			base.OnViewLoaded(view);
359
		}
360

    
361

    
362
		#region Status Properties
363

    
364
		private string _statusMessage;
365
		public string StatusMessage
366
		{
367
			get { return _statusMessage; }
368
			set
369
			{
370
				_statusMessage = value;
371
				NotifyOfPropertyChange(() => StatusMessage);
372
                NotifyOfPropertyChange(() => TooltipMessage);
373
			}
374
		}
375

    
376
        public string VersionMessage { get; set; }
377

    
378
	    public string TooltipMessage
379
	    {
380
	        get
381
	        {
382
	            return String.Format("{0}\r\n{1}",VersionMessage,StatusMessage);
383
	        }
384
	    }
385

    
386
	    private readonly ObservableConcurrentCollection<AccountInfo> _accounts = new ObservableConcurrentCollection<AccountInfo>();
387
		public ObservableConcurrentCollection<AccountInfo> Accounts
388
		{
389
			get { return _accounts; }
390
		}
391

    
392
		public bool HasAccounts
393
		{
394
			get { return _accounts.Count > 0; }
395
		}
396

    
397

    
398
		public string OpenFolderCaption
399
		{
400
			get
401
			{
402
				return (_accounts.Count == 0)
403
						? "No Accounts Defined"
404
						: "Open Pithos Folder";
405
			}
406
		}
407

    
408
		private string _pauseSyncCaption="Pause Synching";
409
		public string PauseSyncCaption
410
		{
411
			get { return _pauseSyncCaption; }
412
			set
413
			{
414
				_pauseSyncCaption = value;
415
				NotifyOfPropertyChange(() => PauseSyncCaption);
416
			}
417
		}
418

    
419
		private readonly ObservableConcurrentCollection<FileEntry> _recentFiles = new ObservableConcurrentCollection<FileEntry>();
420
		public ObservableConcurrentCollection<FileEntry> RecentFiles
421
		{
422
			get { return _recentFiles; }
423
		}
424

    
425

    
426
		private string _statusIcon="../Images/Pithos.ico";
427
		public string StatusIcon
428
		{
429
			get { return _statusIcon; }
430
			set
431
			{
432
				//TODO: Ensure all status icons use the Pithos logo
433
				_statusIcon = value;
434
				NotifyOfPropertyChange(() => StatusIcon);
435
			}
436
		}
437

    
438
		#endregion
439

    
440
		#region Commands
441

    
442
        public void ShowPreferences()
443
        {
444
            ShowPreferences(null);
445
        }
446

    
447
		public void ShowPreferences(string currentTab)
448
		{
449
			//Settings.Reload();
450
		    var preferences = new PreferencesViewModel(_windowManager, _events, this, Settings,currentTab);
451
		    _windowManager.ShowDialog(preferences);
452
			
453
		}
454

    
455
		public void AboutPithos()
456
		{
457
			var about = IoC.Get<AboutViewModel>();
458
		    about.LatestVersion=_sparkle.LatestVersion;
459
			_windowManager.ShowWindow(about);
460
		}
461

    
462
		public void SendFeedback()
463
		{
464
			var feedBack =  IoC.Get<FeedbackViewModel>();
465
			_windowManager.ShowWindow(feedBack);
466
		}
467

    
468
		//public PithosCommand OpenPithosFolderCommand { get; private set; }
469

    
470
		public void OpenPithosFolder()
471
		{
472
			var account = Settings.Accounts.FirstOrDefault(acc => acc.IsActive);
473
			if (account == null)
474
				return;
475
			Process.Start(account.RootPath);
476
		}
477

    
478
		public void OpenPithosFolder(AccountInfo account)
479
		{
480
			Process.Start(account.AccountPath);
481
		}
482

    
483
		
484

    
485
		public void GoToSite()
486
		{            
487
			var site = Properties.Settings.Default.ProductionServer;
488
			Process.Start(site);            
489
		}
490

    
491

    
492
		public void GoToSite(AccountInfo account)
493
		{
494
		    var uri = account.SiteUri.Replace("http://","https://");            
495
		    Process.Start(uri);
496
		}
497

    
498
	    private bool _statusVisible;
499

    
500
	    public string MiniStatusCaption
501
	    {
502
	        get
503
	        {
504
	            return  _statusVisible ? "Hide Status Window" : "Show Status Window";
505
	        }
506
	    }
507

    
508
	    public void ShowMiniStatus()
509
        {            
510
            if (!_statusVisible)
511
                _windowManager.ShowWindow(MiniStatus);
512
            else
513
            {           
514
                if (MiniStatus.IsActive)
515
                    MiniStatus.TryClose();
516
            }
517
            _statusVisible=!_statusVisible;
518

    
519
	        NotifyOfPropertyChange(()=>MiniStatusCaption);
520
        }
521

    
522
	    public bool HasConflicts
523
	    {
524
            get { return true; }
525
	    }
526
        public void ShowConflicts()
527
        {
528
            _windowManager.ShowWindow(IoC.Get<ConflictsViewModel>());            
529
        }
530

    
531
	    /// <summary>
532
        /// Open an explorer window to the target path's directory
533
        /// and select the file
534
        /// </summary>
535
        /// <param name="entry"></param>
536
        public void GoToFile(FileEntry entry)
537
        {
538
            var fullPath = entry.FullPath;
539
            if (!File.Exists(fullPath) && !Directory.Exists(fullPath))
540
                return;
541
            Process.Start("explorer.exe","/select, " + fullPath);
542
        }
543

    
544
        public void OpenLogPath()
545
        {
546
            var pithosDataPath = PithosSettings.PithosDataPath;
547

    
548
            Process.Start(pithosDataPath);
549
        }
550
        
551
        public void ShowFileProperties()
552
		{
553
			var account = Settings.Accounts.First(acc => acc.IsActive);            
554
			var dir = new DirectoryInfo(account.RootPath + @"\pithos");
555
			var files=dir.GetFiles();
556
			var r=new Random();
557
			var idx=r.Next(0, files.Length);
558
			ShowFileProperties(files[idx].FullName);            
559
		}
560

    
561
		public void ShowFileProperties(string filePath)
562
		{
563
			if (String.IsNullOrWhiteSpace(filePath))
564
				throw new ArgumentNullException("filePath");
565
			if (!File.Exists(filePath) && !Directory.Exists(filePath))
566
				throw new ArgumentException(String.Format("Non existent file {0}",filePath),"filePath");
567
			Contract.EndContractBlock();
568

    
569
			var pair=(from monitor in  Monitors
570
							   where filePath.StartsWith(monitor.Value.RootPath, StringComparison.InvariantCultureIgnoreCase)
571
								   select monitor).FirstOrDefault();
572
			var accountMonitor = pair.Value;
573

    
574
			if (accountMonitor == null)
575
				return;
576

    
577
			var infoTask=Task.Factory.StartNew(()=>accountMonitor.GetObjectInfo(filePath));
578

    
579
			
580

    
581
			var fileProperties = new FilePropertiesViewModel(this, infoTask,filePath);
582
			_windowManager.ShowWindow(fileProperties);
583
		} 
584
		
585
		public void ShowContainerProperties()
586
		{
587
			var account = Settings.Accounts.First(acc => acc.IsActive);            
588
			var dir = new DirectoryInfo(account.RootPath);
589
			var fullName = (from folder in dir.EnumerateDirectories()
590
							where (folder.Attributes & FileAttributes.Hidden) == 0
591
							select folder.FullName).First();
592
			ShowContainerProperties(fullName);            
593
		}
594

    
595
		public void ShowContainerProperties(string filePath)
596
		{
597
			if (String.IsNullOrWhiteSpace(filePath))
598
				throw new ArgumentNullException("filePath");
599
			if (!Directory.Exists(filePath))
600
				throw new ArgumentException(String.Format("Non existent file {0}",filePath),"filePath");
601
			Contract.EndContractBlock();
602

    
603
			var pair=(from monitor in  Monitors
604
							   where filePath.StartsWith(monitor.Value.RootPath, StringComparison.InvariantCultureIgnoreCase)
605
								   select monitor).FirstOrDefault();
606
			var accountMonitor = pair.Value;            
607
			var info = accountMonitor.GetContainerInfo(filePath);
608

    
609
			
610

    
611
			var containerProperties = new ContainerPropertiesViewModel(this, info,filePath);
612
			_windowManager.ShowWindow(containerProperties);
613
		}
614

    
615
		public void SynchNow()
616
		{
617
			_pollAgent.SynchNow();
618
		}
619

    
620
		public ObjectInfo RefreshObjectInfo(ObjectInfo currentInfo)
621
		{
622
			if (currentInfo==null)
623
				throw new ArgumentNullException("currentInfo");
624
			Contract.EndContractBlock();		    
625
            var monitor = Monitors[currentInfo.AccountKey];
626
			var newInfo=monitor.CloudClient.GetObjectInfo(currentInfo.Account, currentInfo.Container, currentInfo.Name);
627
			return newInfo;
628
		}
629

    
630
		public ContainerInfo RefreshContainerInfo(ContainerInfo container)
631
		{
632
			if (container == null)
633
				throw new ArgumentNullException("container");
634
			Contract.EndContractBlock();
635

    
636
			var monitor = Monitors[container.AccountKey];
637
			var newInfo = monitor.CloudClient.GetContainerInfo(container.Account, container.Name);
638
			return newInfo;
639
		}
640

    
641

    
642
		public void ToggleSynching()
643
		{
644
			bool isPaused=false;
645
			foreach (var pair in Monitors)
646
			{
647
				var monitor = pair.Value;
648
				monitor.Pause = !monitor.Pause;
649
				isPaused = monitor.Pause;
650
			}
651
                        
652

    
653
			PauseSyncCaption = isPaused ? "Resume syncing" : "Pause syncing";
654
			var iconKey = isPaused? "TraySyncPaused" : "TrayInSynch";
655
			StatusIcon = String.Format(@"../Images/{0}.ico", iconKey);
656
		}
657

    
658
        public void ExitPithos()
659
        {
660
            try
661
            {
662

    
663
                foreach (var monitor in Monitors.Select(pair => pair.Value))
664
                {
665
                    monitor.Stop();
666
                }
667

    
668
                var view = GetView() as Window;
669
                if (view != null)
670
                    view.Close();
671
            }
672
            catch (Exception exc)
673
            {
674
                Log.Info("Exception while exiting", exc);                
675
            }
676
            finally
677
            {
678
                Application.Current.Shutdown();
679
            }
680
        }
681

    
682
	    #endregion
683

    
684

    
685
		private readonly Dictionary<PithosStatus, StatusInfo> _iconNames = new List<StatusInfo>
686
			{
687
				new StatusInfo(PithosStatus.InSynch, "All files up to date", "TrayInSynch"),
688
				new StatusInfo(PithosStatus.PollSyncing, "Polling Files", "TraySynching"),
689
                new StatusInfo(PithosStatus.LocalSyncing, "Syncing Files", "TraySynching"),
690
				new StatusInfo(PithosStatus.SyncPaused, "Sync Paused", "TraySyncPaused")
691
			}.ToDictionary(s => s.Status);
692

    
693
		readonly IWindowManager _windowManager;
694
		
695
        //private int _syncCount=0;
696

    
697

    
698
        private PithosStatus _pithosStatus = PithosStatus.Disconnected;
699

    
700
        public void SetPithosStatus(PithosStatus status)
701
        {
702
            if (_pithosStatus == PithosStatus.LocalSyncing && status == PithosStatus.PollComplete)
703
                return;
704
            if (_pithosStatus == PithosStatus.PollSyncing && status == PithosStatus.LocalComplete)
705
                return;
706
            if (status == PithosStatus.LocalComplete || status == PithosStatus.PollComplete)
707
                _pithosStatus = PithosStatus.InSynch;
708
            else
709
                _pithosStatus = status;
710
            UpdateStatus();
711
        }
712

    
713
        public void SetPithosStatus(PithosStatus status,string message)
714
        {
715
            StatusMessage = message;
716
            SetPithosStatus(status);
717
        }
718

    
719
	  /*  public Notifier GetNotifier(Notification startNotification, Notification endNotification)
720
	    {
721
	        return new Notifier(this, startNotification, endNotification);
722
	    }*/
723

    
724
	    public Notifier GetNotifier(string startMessage, string endMessage, params object[] args)
725
	    {
726
	        return new Notifier(this, 
727
                new StatusNotification(String.Format(startMessage,args)), 
728
                new StatusNotification(String.Format(endMessage,args)));
729
	    }
730

    
731

    
732
	    ///<summary>
733
		/// Updates the visual status indicators of the application depending on status changes, e.g. icon, stat		
734
		///</summary>
735
		public void UpdateStatus()
736
		{
737

    
738
			if (_iconNames.ContainsKey(_pithosStatus))
739
			{
740
				var info = _iconNames[_pithosStatus];
741
				StatusIcon = String.Format(@"../Images/{0}.ico", info.IconName);
742
			}
743

    
744
            if (_pithosStatus == PithosStatus.InSynch)
745
                StatusMessage = "All files up to date";
746
		}
747

    
748

    
749
	   
750
		private Task StartMonitor(PithosMonitor monitor,int retries=0)
751
		{
752
			return Task.Factory.StartNew(() =>
753
			{
754
				using (log4net.ThreadContext.Stacks["Monitor"].Push("Start"))
755
				{
756
					try
757
					{
758
						Log.InfoFormat("Start Monitoring {0}", monitor.UserName);
759

    
760
						monitor.Start();
761
					}
762
					catch (WebException exc)
763
					{
764
						if (AbandonRetry(monitor, retries))
765
							return;
766

    
767
						HttpStatusCode statusCode =HttpStatusCode.OK;
768
						var response = exc.Response as HttpWebResponse;
769
						if(response!=null)
770
							statusCode = response.StatusCode;
771

    
772
						switch (statusCode)
773
						{
774
							case HttpStatusCode.Unauthorized:
775
								var message = String.Format("API Key Expired for {0}. Starting Renewal",
776
															monitor.UserName);
777
								Log.Error(message, exc);
778
                                var account = Settings.Accounts.Find(acc => acc.AccountKey == new Uri(new Uri(monitor.AuthenticationUrl), monitor.UserName));                                
779
						        account.IsExpired = true;
780
                                Notify(new ExpirationNotification(account));
781
								//TryAuthorize(monitor.UserName, retries).Wait();
782
								break;
783
							case HttpStatusCode.ProxyAuthenticationRequired:
784
								TryAuthenticateProxy(monitor,retries);
785
								break;
786
							default:
787
								TryLater(monitor, exc, retries);
788
								break;
789
						}
790
					}
791
					catch (Exception exc)
792
					{
793
						if (AbandonRetry(monitor, retries)) 
794
							return;
795

    
796
						TryLater(monitor,exc,retries);
797
					}
798
				}
799
			});
800
		}
801

    
802
		private void TryAuthenticateProxy(PithosMonitor monitor,int retries)
803
		{
804
			Execute.OnUIThread(() =>
805
								   {                                       
806
									   var proxyAccount = IoC.Get<ProxyAccountViewModel>();
807
										proxyAccount.Settings = Settings;
808
									   if (true != _windowManager.ShowDialog(proxyAccount)) 
809
										   return;
810
									   StartMonitor(monitor, retries);
811
									   NotifyOfPropertyChange(() => Accounts);
812
								   });
813
		}
814

    
815
		private bool AbandonRetry(PithosMonitor monitor, int retries)
816
		{
817
			if (retries > 1)
818
			{
819
				var message = String.Format("Monitoring of account {0} has failed too many times. Will not retry",
820
											monitor.UserName);
821
				_events.Publish(new Notification
822
									{Title = "Account monitoring failed", Message = message, Level = TraceLevel.Error});
823
				return true;
824
			}
825
			return false;
826
		}
827

    
828

    
829
	    private void TryLater(PithosMonitor monitor, Exception exc,int retries)
830
		{
831
			var message = String.Format("An exception occured. Can't start monitoring\nWill retry in 10 seconds");
832
			Task.Factory.StartNewDelayed(10000, () => StartMonitor(monitor,retries+1));
833
			_events.Publish(new Notification
834
								{Title = "Error", Message = message, Level = TraceLevel.Error});
835
			Log.Error(message, exc);
836
		}
837

    
838

    
839
		public void NotifyChange(string status, TraceLevel level=TraceLevel.Info)
840
		{
841
			StatusMessage = status;
842
			
843
			_events.Publish(new Notification { Title = "Pithos+", Message = status, Level = level });
844
		}
845

    
846
		public void NotifyChangedFile(string filePath)
847
		{
848
            if (RecentFiles.Any(e => e.FullPath == filePath))
849
                return;
850
            
851
			IProducerConsumerCollection<FileEntry> files=RecentFiles;
852
			FileEntry popped;
853
			while (files.Count > 5)
854
				files.TryTake(out popped);
855
            var entry = new FileEntry { FullPath = filePath };
856
			files.TryAdd(entry);
857
		}
858

    
859
		public void NotifyAccount(AccountInfo account)
860
		{
861
			if (account== null)
862
				return;
863
			//TODO: What happens to an existing account whose Token has changed?
864
			account.SiteUri= String.Format("{0}/ui/?token={1}&user={2}",
865
				account.SiteUri, Uri.EscapeDataString(account.Token),
866
				Uri.EscapeDataString(account.UserName));
867

    
868
			if (!Accounts.Any(item => item.UserName == account.UserName && item.SiteUri == account.SiteUri))
869
				Accounts.TryAdd(account);
870

    
871
		}
872

    
873
		public void NotifyConflicts(IEnumerable<FileSystemInfo> conflictFiles, string message)
874
		{
875
			if (conflictFiles == null)
876
				return;
877
		    //Convert to list to avoid multiple iterations
878
            var files = conflictFiles.ToList();
879
			if (files.Count==0)
880
				return;
881

    
882
			UpdateStatus();
883
			//TODO: Create a more specific message. For now, just show a warning
884
			NotifyForFiles(files,message,TraceLevel.Warning);
885

    
886
		}
887

    
888
		public void NotifyForFiles(IEnumerable<FileSystemInfo> files, string message,TraceLevel level=TraceLevel.Info)
889
		{
890
			if (files == null)
891
				return;
892
			if (!files.Any())
893
				return;
894

    
895
			StatusMessage = message;
896

    
897
			_events.Publish(new Notification { Title = "Pithos+", Message = message, Level = level});
898
		}
899

    
900
		public void Notify(Notification notification)
901
		{
902
			_events.Publish(notification);
903
		}
904

    
905

    
906
		public void RemoveMonitor(string serverUrl,string accountName)
907
		{
908
			if (String.IsNullOrWhiteSpace(accountName))
909
				return;
910

    
911
			var accountInfo=_accounts.FirstOrDefault(account => account.UserName == accountName && account.StorageUri.ToString().StartsWith(serverUrl));
912
            if (accountInfo != null)
913
            {
914
                _accounts.TryRemove(accountInfo);
915
                _pollAgent.RemoveAccount(accountInfo);
916
            }
917

    
918
            var accountKey = new Uri(new Uri(serverUrl),accountName);
919
		    PithosMonitor monitor;
920
			if (Monitors.TryRemove(accountKey, out monitor))
921
			{
922
				monitor.Stop();
923
                //TODO: Also remove any pending actions for this account
924
                //from the network queue                
925
			}
926
		}
927

    
928
		public void RefreshOverlays()
929
		{
930
			foreach (var pair in Monitors)
931
			{
932
				var monitor = pair.Value;
933

    
934
				var path = monitor.RootPath;
935

    
936
				if (String.IsNullOrWhiteSpace(path))
937
					continue;
938

    
939
				if (!Directory.Exists(path) && !File.Exists(path))
940
					continue;
941

    
942
				IntPtr pathPointer = Marshal.StringToCoTaskMemAuto(path);
943

    
944
				try
945
				{
946
					NativeMethods.SHChangeNotify(HChangeNotifyEventID.SHCNE_UPDATEITEM,
947
												 HChangeNotifyFlags.SHCNF_PATHW | HChangeNotifyFlags.SHCNF_FLUSHNOWAIT,
948
												 pathPointer, IntPtr.Zero);
949
				}
950
				finally
951
				{
952
					Marshal.FreeHGlobal(pathPointer);
953
				}
954
			}
955
		}
956

    
957
		#region Event Handlers
958
		
959
		public void Handle(SelectiveSynchChanges message)
960
        {
961
            PithosMonitor monitor;
962
            if (Monitors.TryGetValue(message.Account.AccountKey, out monitor))
963
            {
964
                monitor.SetSelectivePaths(message.Uris, message.Added, message.Removed);
965

    
966
            }
967

    
968
            var account = Accounts.FirstOrDefault(acc => acc.AccountKey == message.Account.AccountKey);
969
            if (account!=null)
970
            {
971
                this._pollAgent.SetSelectivePaths(account, message.Added, message.Removed);
972
            }
973

    
974

    
975
        }
976

    
977

    
978
		private bool _pollStarted;
979
	    private Sparkle _sparkle;
980
	    private bool _manualUpgradeCheck;
981

    
982
	    //SMELL: Doing so much work for notifications in the shell is wrong
983
		//The notifications should be moved to their own view/viewmodel pair
984
		//and different templates should be used for different message types
985
		//This will also allow the addition of extra functionality, eg. actions
986
		//
987
		public void Handle(Notification notification)
988
		{
989
			UpdateStatus();
990

    
991
			if (!Settings.ShowDesktopNotifications)
992
				return;
993

    
994
			if (notification is PollNotification)
995
			{
996
				_pollStarted = true;
997
				return;
998
			}
999
			if (notification is CloudNotification)
1000
			{
1001
				if (!_pollStarted) 
1002
					return;
1003
				_pollStarted= false;
1004
				notification.Title = "Pithos+";
1005
				notification.Message = "Start Synchronisation";
1006
			}
1007

    
1008
		    var deleteNotification = notification as CloudDeleteNotification;
1009
            if (deleteNotification != null)
1010
            {
1011
                StatusMessage = String.Format("Deleted {0}", deleteNotification.Data.Name);
1012
                return;
1013
            }
1014

    
1015
		    var progress = notification as ProgressNotification;
1016
		    
1017
		    
1018
            if (progress != null)
1019
		    {
1020
		        StatusMessage = String.Format("{0} {1:p2} of {2} - {3}",		                                      
1021
                                              progress.Action,
1022
		                                      progress.Block/(double)progress.TotalBlocks,
1023
		                                      progress.FileSize.ToByteSize(),
1024
		                                      progress.FileName);
1025
		        return;
1026
		    }
1027

    
1028
		    var info = notification as StatusNotification;
1029
            if (info != null)
1030
            {
1031
                StatusMessage = info.Title;
1032
                return;
1033
            }
1034
			if (String.IsNullOrWhiteSpace(notification.Message) && String.IsNullOrWhiteSpace(notification.Title))
1035
				return;
1036

    
1037
            if (notification.Level <= TraceLevel.Warning)
1038
			    ShowBalloonFor(notification);
1039
		}
1040

    
1041
	    private void ShowBalloonFor(Notification notification)
1042
	    {
1043
            Contract.Requires(notification!=null);
1044
            
1045
            if (!Settings.ShowDesktopNotifications) 
1046
                return;
1047
            
1048
            BalloonIcon icon;
1049
	        switch (notification.Level)
1050
	        {
1051
                case TraceLevel.Verbose:
1052
	                return;
1053
	            case TraceLevel.Info:	            
1054
	                icon = BalloonIcon.Info;
1055
	                break;
1056
                case TraceLevel.Error:
1057
                    icon = BalloonIcon.Error;
1058
                    break;
1059
                case TraceLevel.Warning:
1060
	                icon = BalloonIcon.Warning;
1061
	                break;
1062
	            default:
1063
	                return;
1064
	        }
1065

    
1066
	        var tv = (ShellView) GetView();
1067
	        System.Action clickAction = null;
1068
	        if (notification is ExpirationNotification)
1069
	        {
1070
	            clickAction = () => ShowPreferences("AccountTab");
1071
	        }
1072
	        var balloon = new PithosBalloon
1073
	                          {
1074
	                              Title = notification.Title,
1075
	                              Message = notification.Message,
1076
	                              Icon = icon,
1077
	                              ClickAction = clickAction
1078
	                          };
1079
	        tv.TaskbarView.ShowCustomBalloon(balloon, PopupAnimation.Fade, 4000);
1080
	    }
1081

    
1082
	    #endregion
1083

    
1084
		public void Handle(ShowFilePropertiesEvent message)
1085
		{
1086
			if (message == null)
1087
				throw new ArgumentNullException("message");
1088
			if (String.IsNullOrWhiteSpace(message.FileName) )
1089
				throw new ArgumentException("message");
1090
			Contract.EndContractBlock();
1091

    
1092
			var fileName = message.FileName;
1093
			//TODO: Display file properties for non-container folders
1094
			if (File.Exists(fileName))
1095
				//Retrieve the full name with exact casing. Pithos names are case sensitive				
1096
				ShowFileProperties(FileInfoExtensions.GetProperFilePathCapitalization(fileName));
1097
			else if (Directory.Exists(fileName))
1098
				//Retrieve the full name with exact casing. Pithos names are case sensitive
1099
			{
1100
				var path = FileInfoExtensions.GetProperDirectoryCapitalization(fileName);
1101
				if (IsContainer(path))
1102
					ShowContainerProperties(path);
1103
				else
1104
					ShowFileProperties(path);
1105
			}
1106
		}
1107

    
1108
		private bool IsContainer(string path)
1109
		{
1110
			var matchingFolders = from account in _accounts
1111
								  from rootFolder in Directory.GetDirectories(account.AccountPath)
1112
								  where rootFolder.Equals(path, StringComparison.InvariantCultureIgnoreCase)
1113
								  select rootFolder;
1114
			return matchingFolders.Any();
1115
		}
1116

    
1117
		public FileStatus GetFileStatus(string localFileName)
1118
		{
1119
			if (String.IsNullOrWhiteSpace(localFileName))
1120
				throw new ArgumentNullException("localFileName");
1121
			Contract.EndContractBlock();
1122
			
1123
			var statusKeeper = IoC.Get<IStatusKeeper>();
1124
			var status=statusKeeper.GetFileStatus(localFileName);
1125
			return status;
1126
		}
1127

    
1128
	    public void RemoveAccountFromDatabase(AccountSettings account)
1129
	    {
1130
            var statusKeeper = IoC.Get<IStatusKeeper>();
1131
            statusKeeper.ClearFolderStatus(account.RootPath);	        
1132
	    }
1133
	}
1134
}