Merge pull request #194 from github/feature/gist-support

Feature: Gist support

Author: shana

.gitignore

@@ -238,4 +238,4 @@ WiX.Toolset.DummyFile.txt
 nunit-UnitTests.xml
 nunit-TrackingCollectionTests.xml
 GitHubVS.sln.DotSettings
-**/generated/*.cs
+**/generated/*.cs

src/GitHub.App/Api/ApiClient.cs

@@ -13,21 +13,27 @@
 using Octokit;
 using Octokit.Reactive;
 using ReactiveUI;
+using System.Threading.Tasks;
+using System.Reactive.Threading.Tasks;
+using Octokit.Internal;
+using System.Collections.Generic;
+using GitHub.Models;
 
 namespace GitHub.Api
 {
     public partial class ApiClient : IApiClient
     {
-        static readonly Logger log = LogManager.GetCurrentClassLogger();
-
+        const string ScopesHeader = "X-OAuth-Scopes";
         const string ProductName = Info.ApplicationInfo.ApplicationDescription;
+        static readonly Logger log = LogManager.GetCurrentClassLogger();
+        static readonly Uri userEndpoint = new Uri("user", UriKind.Relative);
 
         readonly IObservableGitHubClient gitHubClient;
         // There are two sets of authorization scopes, old and new:
         // The old scopes must be used by older versions of Enterprise that don't support the new scopes:
-        readonly string[] oldAuthorizationScopes = { "user", "repo" };
+        readonly string[] oldAuthorizationScopes = { "user", "repo", "gist" };
         // These new scopes include write:public_key, which allows us to add public SSH keys to an account:
-        readonly string[] newAuthorizationScopes = { "user", "repo", "write:public_key" };
+        readonly string[] newAuthorizationScopes = { "user", "repo", "gist", "write:public_key" };
         readonly static Lazy<string> lazyNote = new Lazy<string>(() => ProductName + " on " + GetMachineNameSafe());
         readonly static Lazy<string> lazyFingerprint = new Lazy<string>(GetFingerprint);
 
@@ -52,9 +58,35 @@ public IObservable<Repository> CreateRepository(NewRepository repository, string
             return (isUser ? client.Create(repository) : client.Create(login, repository));
         }
 
-        public IObservable<User> GetUser()
+        public IObservable<Gist> CreateGist(NewGist newGist)
+        {
+            return gitHubClient.Gist.Create(newGist);
+        }
+
+        public IObservable<UserAndScopes> GetUser()
         {
-            return gitHubClient.User.Current();
+            return GetUserInternal().ToObservable();
+        }
+
+        async Task<UserAndScopes> GetUserInternal()
+        {
+            var response = await gitHubClient.Connection.Get<User>(
+                userEndpoint, null, null).ConfigureAwait(false);
+            var scopes = default(string[]);
+
+            if (response.HttpResponse.Headers.ContainsKey(ScopesHeader))
+            {
+                scopes = response.HttpResponse.Headers[ScopesHeader]
+                    .Split(',')
+                    .Select(x => x.Trim())
+                    .ToArray();
+            }
+            else
+            {
+                log.Error($"Error reading scopes: /user succeeded but {ScopesHeader} was not present.");
+            }
+
+            return new UserAndScopes(response.Body, scopes);
         }
 
         public IObservable<ApplicationAuthorization> GetOrCreateApplicationAuthenticationCode(

src/GitHub.App/Controllers/UIController.cs

@@ -170,7 +170,9 @@ public UIController(IUIProvider uiProvider, IRepositoryHosts hosts, IUIFactory f
 
             uiStateMachine = new StateMachineType(UIViewType.None);
             triggers = new Dictionary<Trigger, StateMachineType.TriggerWithParameters<ViewWithData>>();
+
             ConfigureUIHandlingStates();
+
         }
 
         public IObservable<LoadData> SelectFlow(UIControllerFlow choice)
@@ -257,12 +259,12 @@ public void Start([AllowNull] IConnection conn)
 
         public void Jump(ViewWithData where)
         {
-            Debug.Assert(where.Flow == mainFlow, "Jump called for flow " + where.Flow + " but this is " + mainFlow);
-            if (where.Flow != mainFlow)
+            Debug.Assert(where.ActiveFlow == mainFlow, "Jump called for flow " + where.ActiveFlow + " but this is " + mainFlow);
+            if (where.ActiveFlow != mainFlow)
                 return;
 
             requestedTarget = where;
-            if (activeFlow == where.Flow)
+            if (activeFlow == where.ActiveFlow)
                 Fire(Trigger.Next, where);
         }
 
@@ -295,8 +297,7 @@ void ConfigureUIHandlingStates()
                 .OnEntry(tr => stopping = false)
                 .PermitDynamic(Trigger.Next, () =>
                     {
-                        var loggedIn = connection != null && hosts.LookupHost(connection.HostAddress).IsLoggedIn;
-                        activeFlow = loggedIn ? mainFlow : UIControllerFlow.Authentication;
+                        activeFlow = SelectActiveFlow();
                         return Go(Trigger.Next);
                     })
                 .PermitDynamic(Trigger.Finish, () => Go(Trigger.Finish));
@@ -352,6 +353,18 @@ void ConfigureUIHandlingStates()
                 .PermitDynamic(Trigger.Cancel, () => Go(Trigger.Cancel))
                 .PermitDynamic(Trigger.Finish, () => Go(Trigger.Finish));
 
+            uiStateMachine.Configure(UIViewType.Gist)
+                .OnEntry(tr => RunView(UIViewType.Gist, CalculateDirection(tr)))
+                .PermitDynamic(Trigger.Next, () => Go(Trigger.Next))
+                .PermitDynamic(Trigger.Cancel, () => Go(Trigger.Cancel))
+                .PermitDynamic(Trigger.Finish, () => Go(Trigger.Finish));
+
+            uiStateMachine.Configure(UIViewType.LogoutRequired)
+                .OnEntry(tr => RunView(UIViewType.LogoutRequired, CalculateDirection(tr)))
+                .PermitDynamic(Trigger.Next, () => Go(Trigger.Next))
+                .PermitDynamic(Trigger.Cancel, () => Go(Trigger.Cancel))
+                .PermitDynamic(Trigger.Finish, () => Go(Trigger.Finish));
+
             uiStateMachine.Configure(UIViewType.End)
                 .OnEntryFrom(Trigger.Cancel, () => End(false))
                 .OnEntryFrom(Trigger.Next, () => End(true))
@@ -518,6 +531,43 @@ void ConfigureLogicStates()
             logic.Configure(UIViewType.End)
                 .Permit(Trigger.Next, UIViewType.None);
             machines.Add(UIControllerFlow.PullRequests, logic);
+
+            // gist flow
+            logic = new StateMachine<UIViewType, Trigger>(UIViewType.None);
+            logic.Configure(UIViewType.None)
+                .Permit(Trigger.Next, UIViewType.Gist)
+                .Permit(Trigger.Finish, UIViewType.End);
+            logic.Configure(UIViewType.Gist)
+                .Permit(Trigger.Next, UIViewType.End)
+                .Permit(Trigger.Cancel, UIViewType.End)
+                .Permit(Trigger.Finish, UIViewType.End);
+            logic.Configure(UIViewType.End)
+                .Permit(Trigger.Next, UIViewType.None);
+            machines.Add(UIControllerFlow.Gist, logic);
+
+            // logout required flow
+            logic = new StateMachine<UIViewType, Trigger>(UIViewType.None);
+            logic.Configure(UIViewType.None)
+                .Permit(Trigger.Next, UIViewType.LogoutRequired)
+                .Permit(Trigger.Finish, UIViewType.End);
+            logic.Configure(UIViewType.LogoutRequired)
+                .Permit(Trigger.Next, UIViewType.End)
+                .Permit(Trigger.Cancel, UIViewType.End)
+                .Permit(Trigger.Finish, UIViewType.End);
+            logic.Configure(UIViewType.End)
+                .Permit(Trigger.Next, UIViewType.None);
+            machines.Add(UIControllerFlow.LogoutRequired, logic);
+        }
+
+        UIControllerFlow SelectActiveFlow()
+        {
+            var host = connection != null ? hosts.LookupHost(connection.HostAddress) : null;
+            var loggedIn = host?.IsLoggedIn ?? false;
+            if (!loggedIn || mainFlow != UIControllerFlow.Gist)
+                return loggedIn ? mainFlow : UIControllerFlow.Authentication;
+
+            var supportsGist = host?.SupportsGist ?? false;
+            return supportsGist ? mainFlow : UIControllerFlow.LogoutRequired;
         }
 
         static LoadDirection CalculateDirection(StateMachineType.Transition tr)
@@ -580,12 +630,14 @@ void RunView(UIViewType viewType, LoadDirection direction, ViewWithData arg = nu
                 requestedTarget = null;
             }
 
+            if (arg == null)
+                arg = new ViewWithData { ActiveFlow = activeFlow, MainFlow = mainFlow, ViewType = viewType };
             bool firstTime = CreateViewAndViewModel(viewType, arg);
             var view = GetObjectsForFlow(activeFlow)[viewType].View;
             transition.OnNext(new LoadData
             {
                 View = view,
-                Data = arg ?? new ViewWithData { Flow = activeFlow, ViewType = viewType },
+                Data = arg,
                 Direction = direction
             });
 
@@ -660,7 +712,7 @@ void SetupView(UIViewType viewType, IView view)
         /// </summary>
         /// <param name="viewType"></param>
         /// <returns>true if the View/ViewModel didn't exist and had to be created</returns>
-        bool CreateViewAndViewModel(UIViewType viewType, [AllowNull]ViewWithData data = null)
+        bool CreateViewAndViewModel(UIViewType viewType, ViewWithData data = null)
         {
             var list = GetObjectsForFlow(activeFlow);
             if (viewType == UIViewType.Login)

src/GitHub.App/GitHub.App.csproj

@@ -54,6 +54,7 @@
     <Reference Include="Microsoft.VisualStudio.ComponentModelHost, Version=14.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL" />
     <Reference Include="Microsoft.VisualStudio.Shell.14.0, Version=14.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL" />
     <Reference Include="Microsoft.VisualStudio.Shell.Immutable.10.0" />
+    <Reference Include="Microsoft.VisualStudio.TextManager.Interop, Version=7.1.40304.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" />
     <Reference Include="Newtonsoft.Json, Version=6.0.0.0, Culture=neutral, PublicKeyToken=30ad4fe6b2a6aeed, processorArchitecture=MSIL">
       <SpecificVersion>False</SpecificVersion>
       <HintPath>..\..\packages\Newtonsoft.Json.6.0.8\lib\net45\Newtonsoft.Json.dll</HintPath>
@@ -180,6 +181,7 @@
     <Compile Include="Services\IEnterpriseProbe.cs" />
     <Compile Include="Factories\RepositoryHostFactory.cs" />
     <Compile Include="Services\RepositoryCreationService.cs" />
+    <Compile Include="Services\GistPublishService.cs" />
     <Compile Include="Services\RepositoryPublishService.cs" />
     <Compile Include="Services\SerializedObjectProvider.cs" />
     <Compile Include="Services\StandardUserErrors.cs" />
@@ -190,6 +192,8 @@
     <Compile Include="UserErrors\PrivateRepositoryQuotaExceededUserError.cs" />
     <Compile Include="ViewModels\BaseViewModel.cs" />
     <Compile Include="Models\ConnectionRepositoryHostMap.cs" />
+    <Compile Include="ViewModels\GistCreationViewModel.cs" />
+    <Compile Include="ViewModels\LogoutRequiredViewModel.cs" />
     <Compile Include="ViewModels\PullRequestCreationViewModel.cs" />
     <Compile Include="ViewModels\PullRequestDetailViewModel.cs" />
     <Compile Include="ViewModels\PullRequestListViewModel.cs" />

src/GitHub.App/Models/ConnectionRepositoryHostMap.cs

@@ -1,6 +1,7 @@
 using System.ComponentModel.Composition;
 using GitHub.Models;
 using GitHub.Services;
+using GitHub.Extensions;
 
 namespace GitHub.ViewModels
 {

src/GitHub.App/Models/DisconnectedRepositoryHosts.cs

@@ -26,6 +26,7 @@ public DisconnectedRepositoryHost()
         [AllowNull]
         public bool IsLoggedIn { get; private set; }
         public bool IsLoggingIn { get; private set; }
+        public bool SupportsGist { get; private set; }
         public ReactiveList<IAccount> Organizations { get; private set; }
         public ReactiveList<IAccount> Accounts { get; private set; }
         public string Title { get; private set; }

src/GitHub.App/Models/RepositoryHost.cs

@@ -14,14 +14,17 @@
 using NLog;
 using Octokit;
 using ReactiveUI;
+using System.Linq;
+using System.Reactive.Threading.Tasks;
+using System.Collections.Generic;
 
 namespace GitHub.Models
 {
     [DebuggerDisplay("{DebuggerDisplay,nq}")]
     public class RepositoryHost : ReactiveObject, IRepositoryHost
     {
         static readonly Logger log = LogManager.GetCurrentClassLogger();
-        static readonly AccountCacheItem unverifiedUser = new AccountCacheItem();
+        static readonly UserAndScopes unverifiedUser = new UserAndScopes(null, null);
 
         readonly ITwoFactorChallengeHandler twoFactorChallengeHandler;
         readonly HostAddress hostAddress;
@@ -58,27 +61,22 @@ public bool IsLoggedIn
             private set { this.RaiseAndSetIfChanged(ref isLoggedIn, value); }
         }
 
+        public bool SupportsGist { get; private set; }
+
         public string Title { get; private set; }
 
         [SuppressMessage("Microsoft.Reliability", "CA2000:Dispose objects before losing scope")]
         public IObservable<AuthenticationResult> LogInFromCache()
         {
             return GetUserFromApi()
                 .ObserveOn(RxApp.MainThreadScheduler)
-                .Catch<AccountCacheItem, Exception>(ex =>
+                .Catch<UserAndScopes, Exception>(ex =>
                 {
                     if (ex is AuthorizationException)
                     {
                         log.Warn("Got an authorization exception", ex);
-                        return Observable.Return<AccountCacheItem>(null);
                     }
-                    return ModelService.GetUserFromCache()
-                        .Catch<AccountCacheItem, Exception>(e =>
-                        {
-                            log.Warn("User does not exist in cache", e);
-                            return Observable.Return<AccountCacheItem>(null);
-                        })
-                        .ObserveOn(RxApp.MainThreadScheduler);
+                    return Observable.Return<UserAndScopes>(null);
                 })
                 .SelectMany(LoginWithApiUser)
                 .PublishAsync();
@@ -121,14 +119,14 @@ public IObservable<AuthenticationResult> LogIn(string usernameOrEmail, string pa
                 .SelectMany(fingerprint => ApiClient.GetOrCreateApplicationAuthenticationCode(interceptingTwoFactorChallengeHandler))
                 .SelectMany(saveAuthorizationToken)
                 .SelectMany(_ => GetUserFromApi())
-                .Catch<AccountCacheItem, ApiException>(firstTryEx =>
+                .Catch<UserAndScopes, ApiException>(firstTryEx =>
                 {
                     var exception = firstTryEx as AuthorizationException;
                     if (isEnterprise
                         && exception != null
                         && exception.Message == "Bad credentials")
                     {
-                        return Observable.Throw<AccountCacheItem>(exception);
+                        return Observable.Throw<UserAndScopes>(exception);
                     }
 
                     // If the Enterprise host doesn't support the write:public_key scope, it'll return a 422.
@@ -164,9 +162,9 @@ public IObservable<AuthenticationResult> LogIn(string usernameOrEmail, string pa
                             .SelectMany(_ => GetUserFromApi());
                     }
 
-                    return Observable.Throw<AccountCacheItem>(firstTryEx);
+                    return Observable.Throw<UserAndScopes>(firstTryEx);
                 })
-                .Catch<AccountCacheItem, ApiException>(retryEx =>
+                .Catch<UserAndScopes, ApiException>(retryEx =>
                 {
                     // Older Enterprise hosts either don't have the API end-point to PUT an authorization, or they
                     // return 422 because they haven't white-listed our client ID. In that case, we just ignore
@@ -179,10 +177,10 @@ public IObservable<AuthenticationResult> LogIn(string usernameOrEmail, string pa
                         return GetUserFromApi();
 
                     // Other errors are "real" so we pass them along:
-                    return Observable.Throw<AccountCacheItem>(retryEx);
+                    return Observable.Throw<UserAndScopes>(retryEx);
                 })
                 .ObserveOn(RxApp.MainThreadScheduler)
-                .Catch<AccountCacheItem, Exception>(ex =>
+                .Catch<UserAndScopes, Exception>(ex =>
                 {
                     // If we get here, we have an actual login failure:
                     if (ex is TwoFactorChallengeFailedException)
@@ -191,9 +189,9 @@ public IObservable<AuthenticationResult> LogIn(string usernameOrEmail, string pa
                     }
                     if (ex is AuthorizationException)
                     {
-                        return Observable.Return(default(AccountCacheItem));
+                        return Observable.Return(default(UserAndScopes));
                     }
-                    return Observable.Throw<AccountCacheItem>(ex);
+                    return Observable.Throw<UserAndScopes>(ex);
                 })
                 .SelectMany(LoginWithApiUser)
                 .PublishAsync();
@@ -224,22 +222,23 @@ public IObservable<Unit> LogOut()
                 });
         }
 
-        static IObservable<AuthenticationResult> GetAuthenticationResultForUser(AccountCacheItem account)
+        static IObservable<AuthenticationResult> GetAuthenticationResultForUser(UserAndScopes account)
         {
             return Observable.Return(account == null ? AuthenticationResult.CredentialFailure
                 : account == unverifiedUser
                     ? AuthenticationResult.VerificationFailure
                     : AuthenticationResult.Success);
         }
 
-        IObservable<AuthenticationResult> LoginWithApiUser(AccountCacheItem user)
+        IObservable<AuthenticationResult> LoginWithApiUser(UserAndScopes userAndScopes)
         {
-            return GetAuthenticationResultForUser(user)
+            return GetAuthenticationResultForUser(userAndScopes)
                 .SelectMany(result =>
                 {
                     if (result.IsSuccess())
                     {
-                        return ModelService.InsertUser(user).Select(_ => result);
+                        var accountCacheItem = new AccountCacheItem(userAndScopes.User);
+                        return ModelService.InsertUser(accountCacheItem).Select(_ => result);
                     }
 
                     if (result == AuthenticationResult.VerificationFailure)
@@ -254,19 +253,19 @@ IObservable<AuthenticationResult> LoginWithApiUser(AccountCacheItem user)
                     if (result.IsSuccess())
                     {
                         IsLoggedIn = true;
+                        SupportsGist = userAndScopes.Scopes?.Contains("gist") ?? true;
                     }
 
                     log.Info("Log in from cache for login '{0}' to host '{1}' {2}",
-                        user != null ? user.Login : "(null)",
+                        userAndScopes?.User?.Login ?? "(null)",
                         hostAddress.ApiUri,
                         result.IsSuccess() ? "SUCCEEDED" : "FAILED");
                 });
         }
 
-        IObservable<AccountCacheItem> GetUserFromApi()
+        IObservable<UserAndScopes> GetUserFromApi()
         {
-            return Observable.Defer(() => ApiClient.GetUser().WhereNotNull()
-                .Select(user => new AccountCacheItem(user)));
+            return Observable.Defer(() => ApiClient.GetUser());
         }
 
         bool disposed;