Rebase of MVVM refactor.

The MVVM refactor (#1346) was originally based on the SSO feature branch and had a _lot_ of WIP etc commits. Rebased it off of #1353 and squashed into a single commit.

Author: grokys

docs/developer/dialog-views-with-connections.md

@@ -0,0 +1,24 @@
+# Dialog Views with Connections
+
+Some dialog views need a connection to operate - if there is no connection, a login dialog should be shown: for example, clicking Create Gist without a connection will first prompt the user to log in.
+
+Achieving this is simple, first make your view model interface implement `IConnectionInitializedViewModel` and do any initialization that requires a connection in the `InitializeAsync` method in your view model:
+
+```csharp
+public Task InitializeAsync(IConnection connection)
+{
+    // .. at this point, you're guaranteed to have a connection.
+}
+```
+
+To show the dialog, call `IShowDialogService.ShowWithFirstConnection` instead of `Show`:
+
+```csharp
+public async Task ShowExampleDialog()
+{
+	var viewModel = serviceProvider.ExportProvider.GetExportedValue<IExampleDialogViewModel>();
+	await showDialog.ShowWithFirstConnection(viewModel);
+}
+```
+
+`ShowFirstConnection` first checks if there are any logged in connections. If there are, the first logged in connection will be passed to `InitializeAsync` and the view shown immediately. If there are no logged in connections, the login view will first be shown. Once the user has successfully logged in, the new connection will be passed to `InitalizeAsync` and the view shown.

docs/developer/implementing-a-dialog-view.md

@@ -0,0 +1,117 @@
+# Implementing a Dialog View
+
+GitHub for Visual Studio has a common dialog which is used to show the login, clone, create repository etc. operations. To add a new view to the dialog and show the dialog with this view, you need to do the following:
+
+## Create a View Model and Interface
+
+> TODO: `NewViewModelBase` will become simply `ViewModelBase` once the MVVM refactor is completed.
+
+- Create an interface for the view model that implements `IDialogContentViewModel` in `GitHub.Exports.Reactive\ViewModels\Dialog`
+- Create a view model that inherits from `NewViewModelBase` and implements the interface in `GitHub.App\ViewModels\Dialog`
+- Export the view model with the interface as the contract and add a `[PartCreationPolicy(CreationPolicy.NonShared)]` attribute
+
+A minimal example that just exposes a command that will dismiss the dialog:
+
+```csharp
+using System;
+using ReactiveUI;
+
+namespace GitHub.ViewModels.Dialog
+{
+    public interface IExampleDialogViewModel : IDialogContentViewModel
+    {
+        ReactiveCommand<object> Dismiss { get; }
+    }
+}
+```
+
+```csharp
+using System;
+using System.ComponentModel.Composition;
+using ReactiveUI;
+
+namespace GitHub.ViewModels.Dialog
+{
+    [Export(typeof(IExampleDialogViewModel))]
+    [PartCreationPolicy(CreationPolicy.NonShared)]
+    public class ExampleDialogViewModel : NewViewModelBase, IExampleDialogViewModel
+    {
+        [ImportingConstructor]
+        public ExampleDialogViewModel()
+        {
+            Dismiss = ReactiveCommand.Create();
+        }
+
+        public string Title => "Example Dialog";
+
+        public ReactiveCommand<object> Dismiss { get; }
+
+        public IObservable<object> Done => Dismiss;
+    }
+}
+```
+
+## Create a View
+
+> TODO: Decide if `GitHub.VisualStudio\Views` is the best place for views
+
+- Create a WPF `UserControl` under `GitHub.VisualStudio\Views\Dialog` 
+- Add an `ExportViewFor` attribute with the type of the view model interface
+- Add a `PartCreationPolicy(CreationPolicy.NonShared)]` attribute
+
+Continuing the example above:
+
+```xml
+<UserControl x:Class="GitHub.VisualStudio.Views.Dialog.ExampleDialogView"
+             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
+  <Button Command="{Binding Dismiss}" HorizontalAlignment="Center" VerticalAlignment="Center">
+    Dismiss
+  </Button>
+</UserControl>
+```
+
+```csharp
+using System.ComponentModel.Composition;
+using System.Windows.Controls;
+using GitHub.Exports;
+using GitHub.ViewModels.Dialog;
+
+namespace GitHub.VisualStudio.Views.Dialog
+{
+    [ExportViewFor(typeof(IExampleDialogViewModel))]
+    [PartCreationPolicy(CreationPolicy.NonShared)]
+    public partial class ExampleDialogView : UserControl
+    {
+        public ExampleDialogView()
+        {
+            InitializeComponent();
+        }
+    }
+}
+```
+
+## Show the Dialog!
+
+To show the dialog you will need an instance of the `IShowDialog` service. Once you have that, simply call the `Show` method with an instance of your view model.
+
+```csharp
+var viewModel = new ExampleDialogViewModel();
+showDialog.Show(viewModel)
+```
+
+## Optional: Add a method to `DialogService`
+
+Creating a view model like this may be the right thing to do, but it's not very reusable or testable. If you want your dialog to be easy reusable, add a method to `DialogService`:
+
+```csharp
+public async Task ShowExampleDialog()
+{
+    var viewModel = factory.CreateViewModel<IExampleDialogViewModel>();
+    await showDialog.Show(viewModel);
+}
+```
+
+Obviously, add this method to `IDialogService` too.
+
+Note that these methods are `async` - this means that if you need to do asynchronous initialization of your view model, you can do it here before calling `showDialog`.

docs/developer/multi-paged-dialogs.md

@@ -0,0 +1,76 @@
+# Multi-paged Dialogs
+
+Some dialogs will be multi-paged - for example the login dialog has a credentials page and a 2Fa page that is shown if two-factor authorization is required.
+
+## The View Model
+
+To help implement view models for a multi-page dialog there is a useful base class called `PagedDialogViewModelBase`. The typical way of implementing this is as follows:
+
+- Define each page of the dialog as you would [implement a single dialog view model](implementing-a-dialog-view.md)
+- Implement a "container" view model for the dialog that inherits from `PagedDialogViewModel`
+- Import each page into the container view model
+- Add logic to switch between pages by setting the `PagedDialogViewModelBase.Content` property
+- Add a `Done` observable
+
+Here's a simple example of a container dialog that has two pages. The pages are switched using `ReactiveCommand`s:
+
+```csharp
+using System;
+using System.ComponentModel.Composition;
+
+namespace GitHub.ViewModels.Dialog
+{
+    [Export(typeof(IExamplePagedDialogViewModel))]
+    [PartCreationPolicy(CreationPolicy.NonShared)]
+    public class ExamplePagedDialogViewModel : PagedDialogViewModelBase,
+                                               IExamplePagedDialogViewModel
+    {
+        [ImportingConstructor]
+        public ExamplePagedDialogViewModel(
+            IPage1ViewModel page1,
+            IPage2ViewModel page2)
+        {
+            Content = page1;
+            page1.Next.Subscribe(_ => Content = page2);
+            page2.Previous.Subscribe(_ => Content = page1);
+            Done = Observable.Merge(page2.Done, page2.Done);
+        }
+
+        public override IObservable<object> Done { get; }
+    }
+}
+```
+
+## The View
+
+The view in this case is very simple: it just needs to display the `Content` property of the container view model:
+
+```xml
+<UserControl x:Class="GitHub.VisualStudio.Views.Dialog.ExamplePagedDialogView"
+             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+             Content="{Binding Content}">
+</UserControl>
+```
+
+```csharp
+using System;
+using System.ComponentModel.Composition;
+using System.Windows.Controls;
+using GitHub.Exports;
+using GitHub.ViewModels.Dialog;
+
+namespace GitHub.VisualStudio.Views.Dialog
+{
+    [ExportViewFor(typeof(IExamplePagedDialogViewModel))]
+    [PartCreationPolicy(CreationPolicy.NonShared)]
+    public partial class ExamplePagedDialogView : UserControl
+    {
+        public NewLoginView()
+        {
+            InitializeComponent();
+        }
+    }
+}
+```
+

documentation/UIController.md

@@ -8,6 +8,7 @@
 using GitHub.Api;
 using GitHub.Helpers;
 using GitHub.Extensions;
+using GitHub.ViewModels.Dialog;
 
 namespace GitHub.Authentication
 {
@@ -16,11 +17,11 @@ namespace GitHub.Authentication
     [PartCreationPolicy(CreationPolicy.Shared)]
     public class TwoFactorChallengeHandler : ReactiveObject, IDelegatingTwoFactorChallengeHandler
     {
-        ITwoFactorDialogViewModel twoFactorDialog;
+        ILogin2FaViewModel twoFactorDialog;
         public IViewModel CurrentViewModel
         {
             get { return twoFactorDialog; }
-            private set { this.RaiseAndSetIfChanged(ref twoFactorDialog, (ITwoFactorDialogViewModel)value); }
+            private set { this.RaiseAndSetIfChanged(ref twoFactorDialog, (ILogin2FaViewModel)value); }
         }
 
         public void SetViewModel(IViewModel vm)
@@ -50,7 +51,7 @@ public async Task<TwoFactorChallengeResult> HandleTwoFactorException(TwoFactorAu
         public async Task ChallengeFailed(Exception exception)
         {
             await ThreadingHelper.SwitchToMainThreadAsync();
-            await twoFactorDialog.Cancel.ExecuteAsync(null);
+            twoFactorDialog.Cancel();
         }
     }
 }

src/GitHub.App/Authentication/TwoFactorChallengeHandler.cs

@@ -8,11 +8,18 @@ namespace GitHub.Authentication
     public class TwoFactorRequiredUserError : UserError
     {
         public TwoFactorRequiredUserError(TwoFactorAuthorizationException exception)
+            : this(exception, exception.TwoFactorType)
+        {
+        }
+
+        public TwoFactorRequiredUserError(
+            TwoFactorAuthorizationException exception,
+            TwoFactorType twoFactorType)
             : base(exception.Message, innerException: exception)
         {
             Guard.ArgumentNotNull(exception, nameof(exception));
 
-            TwoFactorType = exception.TwoFactorType;
+            TwoFactorType = twoFactorType;
             RetryFailed = exception is TwoFactorChallengeFailedException;
         }