Implement pull request creation and branch data

Author: shana

src/GitHub.App/Api/ApiClient.cs

@@ -237,9 +237,20 @@ public IObservable<PullRequest> GetPullRequestsForRepository(string owner, strin
                     SortDirection = SortDirection.Descending
                 });
         }
+
+        public IObservable<PullRequest> CreatePullRequest(NewPullRequest pullRequest, string owner, string repo)
+        {
+            return gitHubClient.PullRequest.Create(owner, repo, pullRequest);
+        }
+
         public IObservable<Repository> GetRepositories()
         {
             return gitHubClient.Repository.GetAllForCurrent();
         }
+
+        public IObservable<Branch> GetBranches(string owner, string repo)
+        {
+            return gitHubClient.Repository.GetAllBranches(owner, repo);
+        }
     }
 }

src/GitHub.App/Extensions/AkavacheExtensions.cs

@@ -241,6 +241,37 @@ static IObservable<T> GetAndFetchLatestFromIndex<T>(this IBlobCache This,
                 .Replay().RefCount();
         }
 
+        /// <summary>
+        /// This method adds a new object to the database and updates the
+        /// corresponding index.
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="blobCache">The cache to retrieve the object from.</param>
+        /// <param name="key">The key to look up the cache value with.</param>
+        /// <param name="item">The item to add to the database</param>
+        /// <param name="maxCacheDuration">
+        /// The maximum age of a cache object before the object is treated as
+        /// expired and unusable. Cache objects older than this will be treated
+        /// as a cache miss.
+        /// <returns></returns>
+        public static IObservable<T> PutAndUpdateIndex<T>(this IBlobCache blobCache,
+            string key,
+            Func<IObservable<T>> fetchFunc,
+            TimeSpan maxCacheDuration)
+            where T : CacheItem
+        {
+            return Observable.Defer(() =>
+            {
+                var absoluteExpiration = blobCache.Scheduler.Now + maxCacheDuration;
+                return blobCache.GetOrCreateObject(key, () => CacheIndex.Create(key))
+                    .SelectMany(index => fetchFunc()
+                            .Catch<T, Exception>(Observable.Throw<T>)
+                            .SelectMany(x => x.Save<T>(blobCache, key, absoluteExpiration))
+                            .Do(x => index.AddAndSave(blobCache, key, x, absoluteExpiration))
+                    );
+            });
+        }
+
         static bool IsExpired(IBlobCache blobCache, DateTimeOffset itemCreatedAt, TimeSpan cacheDuration)
         {
             var elapsed = blobCache.Scheduler.Now - itemCreatedAt.ToUniversalTime();

src/GitHub.App/GitHub.App.csproj

@@ -127,6 +127,7 @@
     <Compile Include="Factories\UIFactory.cs" />
     <Compile Include="GlobalSuppressions.cs" />
     <Compile Include="Infrastructure\LoggingConfiguration.cs" />
+    <Compile Include="Models\BranchModel.cs" />
     <Compile Include="Models\PullRequestModel.cs" />
     <Compile Include="Resources.Designer.cs">
       <AutoGen>True</AutoGen>
@@ -144,6 +145,7 @@
     <Compile Include="Services\ImageDownloader.cs" />
     <Compile Include="Services\GitClient.cs" />
     <Compile Include="Services\ModelService.cs" />
+    <Compile Include="Services\PullRequestService.cs" />
     <Compile Include="Services\RepositoryCloneService.cs" />
     <Compile Include="Extensions\FileExtensions.cs" />
     <Compile Include="Caches\CredentialCache.cs" />

src/GitHub.App/Models/BranchModel.cs

@@ -0,0 +1,20 @@
+namespace GitHub.Models
+{
+    public class BranchModel : IBranch
+    {
+        public BranchModel()
+        { }
+
+        public BranchModel(Octokit.Branch branch)
+        {
+            Name = branch.Name;
+        }
+
+        public BranchModel(LibGit2Sharp.Branch branch)
+        {
+            Name = branch.FriendlyName;
+        }
+
+        public string Name { get; set; }
+    }
+}

src/GitHub.App/Models/PullRequestModel.cs

@@ -141,6 +141,9 @@ public IAccount Assignee
             set { assignee = value; this.RaisePropertyChange(); }
         }
 
+        public ISimpleRepositoryModel Repository { get; }
+        public IBranch Head { get; }
+        public IBranch Base { get; }
 
         [return: AllowNull] // nullguard thinks a string.Format can return null. sigh.
         public override string ToString()

src/GitHub.App/SampleData/PullRequestCreationViewModelDesigner.cs

@@ -1,6 +1,7 @@
 using System.Diagnostics.CodeAnalysis;
 using GitHub.ViewModels;
 using System.Collections.Generic;
+using GitHub.Models;
 
 namespace GitHub.SampleData
 {
@@ -9,27 +10,30 @@ public class PullRequestCreationViewModelDesigner : BaseViewModel, IPullRequestC
     {
         public PullRequestCreationViewModelDesigner()
         {
-            Branches = new List<string>()
+            Branches = new List<IBranch>
             {
-                "don/stub-ui",
-                "feature/pr/views",
-                "release-1.0.17.0"
-            };
+                new BranchModel { Name = "master" },
+                new BranchModel { Name = "don/stub-ui" },
+                new BranchModel { Name = "feature/pr/views" },
+                new BranchModel { Name = "release-1.0.17.0" }
+            }.AsReadOnly();
+
+            TargetBranch = new BranchModel { Name = "master" };
+            SourceBranch = Branches[2];
 
-            CurrentBranchName = "fix-everything";
             SelectedAssignee = "Haacked (Phil Haack)";
-            TargetBranchName = "master";
             Users = new List<string>()
             {
                 "Haacked (Phil Haack)",
                 "shana (Andreia Gaita)"
             };
         }
 
-        public string CurrentBranchName { get; set; }
+        public IBranch SourceBranch { get; set; }
+        public IBranch TargetBranch { get; set; }
+        public IReadOnlyList<IBranch> Branches { get; set; }
+
         public string SelectedAssignee { get; set; }
-        public string TargetBranchName { get; set; }
-        public List<string> Branches { get; set; }
         public List<string> Users { get; set; }
     }
 }

src/GitHub.App/Services/ModelService.cs

@@ -199,6 +199,24 @@ public ITrackingCollection<IRepositoryModel> GetRepositories(ITrackingCollection
             return collection;
         }
 
+        public IObservable<IPullRequestModel> CreatePullRequest(IPullRequestModel pr, ISimpleRepositoryModel repository)
+        {
+            var keyobs = GetUserFromCache()
+                .Select(user => string.Format(CultureInfo.InvariantCulture, "{0}|{1}:{2}", CacheIndex.PRPrefix, user.Login, repository.Name));
+
+            return Observable.Defer(() => keyobs
+                .SelectMany(key =>
+                    hostCache.PutAndUpdateIndex(key, () =>
+                        apiClient.CreatePullRequest(new NewPullRequest(pr.Title, pr.Head.Name, pr.Base.Name),
+                                    repository.CloneUrl.Owner,
+                                    repository.CloneUrl.RepositoryName)
+                                 .Select(PullRequestCacheItem.Create),
+                    TimeSpan.FromMinutes(30))
+                )
+                .Select(Create)
+            );
+        }
+
         public IObservable<Unit> InvalidateAll()
         {
             return hostCache.InvalidateAll().ContinueAfter(() => hostCache.Vacuum());
@@ -262,6 +280,16 @@ IObservable<IReadOnlyList<IRepositoryModel>> GetOrganizationRepositories(string
                     });
         }
 
+        public IObservable<IBranch> GetBranches(ISimpleRepositoryModel repo)
+        {
+            var keyobs = GetUserFromCache()
+                .Select(user => string.Format(CultureInfo.InvariantCulture, "{0}|{1}|branch", user.Login, repo.Name));
+
+            return Observable.Defer(() => keyobs
+                    .SelectMany(key => apiClient.GetBranches(repo.CloneUrl.Owner, repo.CloneUrl.RepositoryName)))
+                .Select(Create);
+        }
+
         static GitIgnoreItem Create(GitIgnoreCacheItem item)
         {
             return GitIgnoreItem.Create(item.Name);
@@ -272,7 +300,7 @@ static LicenseItem Create(LicenseCacheItem licenseCacheItem)
             return new LicenseItem(licenseCacheItem.Key, licenseCacheItem.Name);
         }
 
-        Models.Account Create(AccountCacheItem accountCacheItem)
+        IAccount Create(AccountCacheItem accountCacheItem)
         {
             return new Models.Account(
                 accountCacheItem.Login,
@@ -313,6 +341,11 @@ IPullRequestModel Create(PullRequestCacheItem prCacheItem)
             };
         }
 
+        IBranch Create(Branch branch)
+        {
+            return new BranchModel(branch);
+        }
+
 
         public IObservable<Unit> InsertUser(AccountCacheItem user)
         {

src/GitHub.App/Services/PullRequestService.cs

@@ -0,0 +1,16 @@
+using System;
+using System.ComponentModel.Composition;
+using GitHub.Models;
+
+namespace GitHub.Services
+{
+    [Export(typeof(IPullRequestService))]
+    [PartCreationPolicy(CreationPolicy.Shared)]
+    public class PullRequestService : IPullRequestService
+    {
+        public IObservable<IPullRequestModel> CreatePullRequest(IRepositoryHost host, ISimpleRepositoryModel repository, IPullRequestModel pullRequest)
+        {
+            return host.ModelService.CreatePullRequest(pullRequest, repository);
+        }
+    }
+}

src/GitHub.App/ViewModels/PullRequestCreationViewModel.cs

@@ -1,11 +1,61 @@
-using System.ComponentModel.Composition;
+using System;
+using System.ComponentModel.Composition;
 using GitHub.Exports;
+using GitHub.Models;
+using System.Collections.Generic;
+using ReactiveUI;
+using GitHub.Services;
+using System.Reactive.Linq;
+using System.Collections.ObjectModel;
+using GitHub.Extensions.Reactive;
+using GitHub.UI;
+using System.Linq;
 
 namespace GitHub.ViewModels
 {
     [ExportViewModel(ViewType = UIViewType.PRCreation)]
     [PartCreationPolicy(CreationPolicy.NonShared)]
-    class PullRequestCreationViewModel : BaseViewModel, IPullRequestCreationViewModel
+    public class PullRequestCreationViewModel : BaseViewModel, IPullRequestCreationViewModel
     {
+        [ImportingConstructor]
+        PullRequestCreationViewModel(
+             IConnectionRepositoryHostMap connectionRepositoryHostMap, ITeamExplorerServiceHolder teservice)
+             : this(connectionRepositoryHostMap.CurrentRepositoryHost, teservice.ActiveRepo)
+         {}
+
+        public PullRequestCreationViewModel(IRepositoryHost repositoryHost, ISimpleRepositoryModel activeRepo)
+        {
+            repositoryHost.ModelService.GetBranches(activeRepo)
+                            .ToReadOnlyList()
+                            .ObserveOn(RxApp.MainThreadScheduler)
+                            .Subscribe(x => Branches = x);
+
+            var repo = GitService.GitServiceHelper.GetRepo(activeRepo.LocalPath);
+            SourceBranch = new BranchModel(repo.Head);
+
+            // what do we do if there's no master?
+            TargetBranch = new BranchModel { Name = "master" };
+        }
+
+        IBranch targetBranch;
+        public IBranch TargetBranch
+        {
+            get { return targetBranch; }
+            set { this.RaiseAndSetIfChanged(ref targetBranch, value); }
+        }
+
+        IBranch sourceBranch;
+        public IBranch SourceBranch
+        {
+            get { return sourceBranch; }
+            set { this.RaiseAndSetIfChanged(ref sourceBranch, value); }
+        }
+
+        IReadOnlyList<IBranch> branches;
+        public IReadOnlyList<IBranch> Branches
+        {
+            get { return branches; }
+            set { this.RaiseAndSetIfChanged(ref branches, value); }
+        }
     }
 }

src/GitHub.Exports.Reactive/Api/IApiClient.cs

@@ -33,6 +33,8 @@ IObservable<ApplicationAuthorization> GetOrCreateApplicationAuthenticationCode(
         IObservable<LicenseMetadata> GetLicenses();
         IObservable<Unit> DeleteApplicationAuthorization(int id, string twoFactorAuthorizationCode);
         IObservable<PullRequest> GetPullRequestsForRepository(string owner, string name);
+        IObservable<PullRequest> CreatePullRequest(NewPullRequest pullRequest, string owner, string repo);
+        IObservable<Branch> GetBranches(string owner, string repo);
         IObservable<Repository> GetRepositories();
     }
 }