Pull Request conversation view

src/GitHub.App/Models/PullRequestModel.cs

@@ -110,8 +110,8 @@ public string Title
             }
         }
 
-        PullRequestStateEnum status;
-        public PullRequestStateEnum State
+        PullRequestState status;
+        public PullRequestState State
         {
             get { return status; }
             set
@@ -126,8 +126,8 @@ public PullRequestStateEnum State
         }
 
         // TODO: Remove these property once maintainer workflow has been merged to master.
-        public bool IsOpen => State == PullRequestStateEnum.Open;
-        public bool Merged => State == PullRequestStateEnum.Merged;
+        public bool IsOpen => State == PullRequestState.Open;
+        public bool Merged => State == PullRequestState.Merged;
 
         int commentCount;
         public int CommentCount

src/GitHub.App/Properties/AssemblyInfo.cs

@@ -2,7 +2,9 @@
 
 [assembly: XmlnsDefinition("https://github.com/github/VisualStudio", "GitHub.SampleData")]
 [assembly: XmlnsDefinition("https://github.com/github/VisualStudio", "GitHub.SampleData.Dialog.Clone")]
+[assembly: XmlnsDefinition("https://github.com/github/VisualStudio", "GitHub.SampleData.Documents")]
 [assembly: XmlnsDefinition("https://github.com/github/VisualStudio", "GitHub.ViewModels")]
 [assembly: XmlnsDefinition("https://github.com/github/VisualStudio", "GitHub.ViewModels.Dialog")]
 [assembly: XmlnsDefinition("https://github.com/github/VisualStudio", "GitHub.ViewModels.Dialog.Clone")]
+[assembly: XmlnsDefinition("https://github.com/github/VisualStudio", "GitHub.ViewModels.Documents")]
 [assembly: XmlnsDefinition("https://github.com/github/VisualStudio", "GitHub.ViewModels.GitHubPane")]

src/GitHub.App/SampleData/CommentViewModelDesigner.cs

@@ -1,6 +1,8 @@
 using System;
 using System.Diagnostics.CodeAnalysis;
 using System.Reactive;
+using System.Threading.Tasks;
+using GitHub.Models;
 using GitHub.ViewModels;
 using ReactiveUI;
 
@@ -22,7 +24,9 @@ public CommentViewModelDesigner()
         public CommentEditState EditState { get; set; }
         public bool IsReadOnly { get; set; }
         public bool IsSubmitting { get; set; }
+        public bool CanCancel { get; } = true;
         public bool CanDelete { get; } = true;
+        public string CommitCaption { get; set; } = "Comment";
         public ICommentThreadViewModel Thread { get; }
         public DateTimeOffset CreatedAt => DateTime.Now.Subtract(TimeSpan.FromDays(3));
         public IActorViewModel Author { get; set; }
@@ -31,7 +35,12 @@ public CommentViewModelDesigner()
         public ReactiveCommand<Unit, Unit> BeginEdit { get; }
         public ReactiveCommand<Unit, Unit> CancelEdit { get; }
         public ReactiveCommand<Unit, Unit> CommitEdit { get; }
-        public ReactiveCommand<Unit, Unit> OpenOnGitHub { get; }
+        public ReactiveCommand<Unit, Unit> OpenOnGitHub { get; } = ReactiveCommand.Create(() => { });
         public ReactiveCommand<Unit, Unit> Delete { get; }
+
+        public Task InitializeAsync(ICommentThreadViewModel thread, ActorModel currentUser, CommentModel comment, CommentEditState state)
+        {
+            return Task.CompletedTask;
+        }
     }
 }

src/GitHub.App/SampleData/Documents/IssueishCommentThreadViewModelDesigner.cs

@@ -0,0 +1,19 @@
+using System;
+using System.Threading.Tasks;
+using GitHub.Models;
+using GitHub.ViewModels;
+using GitHub.ViewModels.Documents;
+using ReactiveUI;
+
+namespace GitHub.SampleData.Documents
+{
+    public class IssueishCommentThreadViewModelDesigner : ViewModelBase, IIssueishCommentThreadViewModel
+    {
+        public IActorViewModel CurrentUser { get; } = new ActorViewModelDesigner("grokys");
+        public Task InitializeAsync(ActorModel currentUser, IssueishDetailModel model, bool addPlaceholder) => Task.CompletedTask;
+        public Task DeleteComment(ICommentViewModel comment) => Task.CompletedTask;
+        public Task EditComment(ICommentViewModel comment) => Task.CompletedTask;
+        public Task PostComment(ICommentViewModel comment) => Task.CompletedTask;
+        public Task CloseOrReopen(ICommentViewModel comment) => Task.CompletedTask;
+    }
+}

src/GitHub.App/SampleData/Documents/PullRequestPageViewModelDesigner.cs

@@ -0,0 +1,109 @@
+using System;
+using System.Collections.Generic;
+using System.Reactive;
+using System.Threading.Tasks;
+using GitHub.Models;
+using GitHub.ViewModels;
+using GitHub.ViewModels.Documents;
+using ReactiveUI;
+
+namespace GitHub.SampleData.Documents
+{
+    public class PullRequestPageViewModelDesigner : ViewModelBase, IPullRequestPageViewModel
+    {
+        public PullRequestPageViewModelDesigner()
+        {
+            Body = @"Save drafts of inline comments, PR reviews and PRs.
+
+> Note: This feature required a refactoring of the comment view models because they now need async initialization and to be available from GitHub.App. This part of the PR has been submitted separately as #1993 to ease review. The two PRs can alternatively be reviewed as one if that's more convenient.
+
+As described in #1905, it is easy to lose a comment that you're working on if you close the diff view accidentally. This PR saves drafts of comments as they are being written to an SQLite database.
+
+In addition to saving drafts of inline comments, it also saves comments to PR reviews and PRs themselves.
+
+The comments are written to an SQLite database directly instead of going through Akavache because in the case of inline reviews, there can be many drafts in progress on a separate file. When a diff is opened we need to look for any comments present on that file and show the most recent. That use-case didn't fit well with Akavache (being a pure key/value store).
+
+## Testing
+
+### Inline Comments
+
+- Open a PR
+- Open the diff of a file
+- Start adding a comment
+- Close the comment by closing the peek view, or the document tab
+- Reopen the diff
+- You should see the comment displayed in edit mode with the draft of the comment you were previously writing
+
+### PR reviews
+
+- Open a PR
+- Click ""Add your review""
+- Start adding a review
+- Click the ""Back"" button and navigate to a different PR
+- Click the ""Back"" button and navigate to the original PR
+- Click ""Add your review""
+- You should see the the draft of the review you were previously writing
+
+### PRs
+
+-Click ""Create new"" at the top of the PR list
+- Start adding a PR title/ description
+- Close VS
+- Restart VS and click ""Create new"" again
+- You should see the the draft of the PR you were previously writing
+
+Depends on #1993 
+Fixes #1905";
+            Timeline = new IViewModel[]
+            {
+                new CommitListViewModel(
+                    new CommitSummaryViewModel(new CommitModel
+                    {
+                        Author = new ActorModel { Login = "grokys" },
+                        AbbreviatedOid = "c7c7d25",
+                        MessageHeadline = "Refactor comment view models."
+                    }),
+                    new CommitSummaryViewModel(new CommitModel
+                    {
+                        Author = new ActorModel { Login = "shana" },
+                        AbbreviatedOid = "04e6a90",
+                        MessageHeadline = "Refactor comment view models.",
+                    })),
+                new CommentViewModelDesigner
+                {
+                    Author = new ActorViewModelDesigner("meaghanlewis"),
+                    Body = @"This is looking great! Really enjoying using this feature so far.
+
+When leaving an inline comment, the comment posts successfully and then a new comment is drafted with the same text.",
+                },
+                new CommentViewModelDesigner
+                {
+                    Author = new ActorViewModelDesigner("grokys"),
+                    Body = @"Oops, sorry about that @meaghanlewis - I was sure I tested those things, but must have got messed up again at some point. Should be fixed now.",
+                },
+            };
+        }
+
+        public string Id { get; set; }
+        public PullRequestState State { get; set; } = PullRequestState.Open;
+        public IReadOnlyList<IViewModel> Timeline { get; }
+        public string SourceBranchDisplayName { get; set; } = "feature/save-drafts";
+        public string TargetBranchDisplayName { get; set; } = "master";
+        public IActorViewModel Author { get; set; } = new ActorViewModelDesigner("grokys");
+        public int CommitCount { get; set; } = 2;
+        public string Body { get; set; }
+        public int Number { get; set; } = 1994;
+        public LocalRepositoryModel LocalRepository { get; }
+        public RemoteRepositoryModel Repository { get; set; }
+        public string Title { get; set; } = "Save drafts of comments";
+        public Uri WebUrl { get; set; }
+        public ReactiveCommand<Unit, Unit> OpenOnGitHub { get; }
+        public ReactiveCommand<string, Unit> ShowCommit { get; }
+
+
+        public Task InitializeAsync(RemoteRepositoryModel repository, LocalRepositoryModel localRepository, ActorModel currentUser, PullRequestDetailModel model)
+        {
+            throw new NotImplementedException();
+        }
+    }
+}

src/GitHub.App/SampleData/PullRequestDetailViewModelDesigner.cs

@@ -124,6 +124,7 @@ public PullRequestDetailViewModelDesigner()
         public ReactiveCommand<Unit, Unit> Pull { get; }
         public ReactiveCommand<Unit, Unit> Push { get; }
         public ReactiveCommand<Unit, Unit> SyncSubmodules { get; }
+        public ReactiveCommand<Unit, Unit> OpenConversation { get; }
         public ReactiveCommand<Unit, Unit> OpenOnGitHub { get; }
         public ReactiveCommand<IPullRequestReviewSummaryViewModel, Unit> ShowReview { get; }
         public ReactiveCommand<IPullRequestCheckViewModel, Unit> ShowAnnotations { get; }

src/GitHub.App/SampleData/PullRequestListViewModelDesigner.cs

@@ -63,6 +63,7 @@ public PullRequestListViewModelDesigner()
         public IReadOnlyList<string> States { get; }
         public Uri WebUrl => null;
         public ReactiveCommand<Unit, Unit> CreatePullRequest { get; }
+        public ReactiveCommand<IPullRequestListItemViewModel, Unit> OpenConversation { get; }
         public ReactiveCommand<IIssueListItemViewModelBase, Unit> OpenItem { get; }
         public ReactiveCommand<IPullRequestListItemViewModel, IPullRequestListItemViewModel> OpenItemInBrowser { get; }
 

src/GitHub.App/Services/FromGraphQlExtensions.cs

@@ -34,16 +34,16 @@ public static class FromGraphQlExtensions
             }
         }
 
-        public static PullRequestStateEnum FromGraphQl(this PullRequestState value)
+        public static Models.PullRequestState FromGraphQl(this Octokit.GraphQL.Model.PullRequestState value)
         {
             switch (value)
             {
-                case PullRequestState.Open:
-                    return PullRequestStateEnum.Open;
-                case PullRequestState.Closed:
-                    return PullRequestStateEnum.Closed;
-                case PullRequestState.Merged:
-                    return PullRequestStateEnum.Merged;
+                case Octokit.GraphQL.Model.PullRequestState.Open:
+                    return Models.PullRequestState.Open;
+                case Octokit.GraphQL.Model.PullRequestState.Closed:
+                    return Models.PullRequestState.Closed;
+                case Octokit.GraphQL.Model.PullRequestState.Merged:
+                    return Models.PullRequestState.Merged;
                 default:
                     throw new ArgumentOutOfRangeException(nameof(value), value, null);
             }

src/GitHub.App/Services/GitClient.cs

@@ -181,6 +181,11 @@ public Task Checkout(IRepository repository, string branchName)
             });
         }
 
+        public async Task<bool> CommitExists(IRepository repository, string sha)
+        {
+            return await Task.Run(() => repository.Lookup<Commit>(sha) != null).ConfigureAwait(false);
+        }
+
         public Task CreateBranch(IRepository repository, string branchName)
         {
             Guard.ArgumentNotNull(repository, nameof(repository));

src/GitHub.App/Services/IssueishService.cs

@@ -0,0 +1,113 @@
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using GitHub.Api;
+using GitHub.Factories;
+using GitHub.Models;
+using GitHub.Primitives;
+using Octokit;
+using Octokit.GraphQL;
+using Octokit.GraphQL.Model;
+using static Octokit.GraphQL.Variable;
+
+namespace GitHub.Services
+{
+    /// <summary>
+    /// Base class for issue and pull request services.
+    /// </summary>
+    public abstract class IssueishService : IIssueishService
+    {
+        static ICompiledQuery<CommentModel> postComment;
+        readonly IApiClientFactory apiClientFactory;
+        readonly IGraphQLClientFactory graphqlFactory;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="IssueishService"/> class.
+        /// </summary>
+        /// <param name="apiClientFactory">The API client factory.</param>
+        /// <param name="graphqlFactory">The GraphQL client factory.</param>
+        public IssueishService(
+            IApiClientFactory apiClientFactory,
+            IGraphQLClientFactory graphqlFactory)
+        {
+            this.apiClientFactory = apiClientFactory;
+            this.graphqlFactory = graphqlFactory;
+        }
+
+        /// <inheritdoc/>
+        public async Task CloseIssueish(HostAddress address, string owner, string repository, int number)
+        {
+            var client = await apiClientFactory.CreateGitHubClient(address).ConfigureAwait(false);
+            var update = new IssueUpdate { State = ItemState.Closed };
+            await client.Issue.Update(owner, repository, number, update).ConfigureAwait(false);
+        }
+
+        /// <inheritdoc/>
+        public async Task ReopenIssueish(HostAddress address, string owner, string repository, int number)
+        {
+            var client = await apiClientFactory.CreateGitHubClient(address).ConfigureAwait(false);
+            var update = new IssueUpdate { State = ItemState.Open };
+            await client.Issue.Update(owner, repository, number, update).ConfigureAwait(false);
+        }
+
+        /// <inheritdoc/>
+        public async Task<CommentModel> PostComment(HostAddress address, string issueishId, string body)
+        {
+            var input = new AddCommentInput
+            {
+                Body = body,
+                SubjectId = new ID(issueishId),
+            };
+
+            if (postComment == null)
+            {
+                postComment = new Mutation()
+                    .AddComment(Var(nameof(input)))
+                    .CommentEdge
+                    .Node
+                    .Select(comment => new CommentModel
+                    {
+                        Author = new ActorModel
+                        {
+                            Login = comment.Author.Login,
+                            AvatarUrl = comment.Author.AvatarUrl(null),
+                        },
+                        Body = comment.Body,
+                        CreatedAt = comment.CreatedAt,
+                        DatabaseId = comment.DatabaseId.Value,
+                        Id = comment.Id.Value,
+                        Url = comment.Url,
+                    }).Compile();
+            }
+
+            var vars = new Dictionary<string, object>
+            {
+                { nameof(input), input },
+            };
+
+            var graphql = await graphqlFactory.CreateConnection(address).ConfigureAwait(false);
+            return await graphql.Run(postComment, vars).ConfigureAwait(false);
+        }
+
+        public async Task DeleteComment(
+            HostAddress address,
+            string owner,
+            string repository,
+            int commentId)
+        {
+            var client = await apiClientFactory.CreateGitHubClient(address).ConfigureAwait(false);
+            await client.Issue.Comment.Delete(owner, repository, commentId).ConfigureAwait(false);
+        }
+
+        public async Task EditComment(
+            HostAddress address,
+            string owner,
+            string repository,
+            int commentId,
+            string body)
+        {
+            var client = await apiClientFactory.CreateGitHubClient(address).ConfigureAwait(false);
+            await client.Issue.Comment.Update(owner, repository, commentId, body).ConfigureAwait(false);
+        }
+    }
+}