Save/load drafts for new PR review theads.

Author: grokys

src/GitHub.App/Models/Drafts/CommentDraft.cs

@@ -0,0 +1,7 @@
+namespace GitHub.App.Models.Drafts
+{
+    public class CommentDraft
+    {
+        public string Body { get; set; }
+    }
+}

src/GitHub.App/ViewModels/CommentThreadViewModel.cs

@@ -1,7 +1,14 @@
-using System.ComponentModel.Composition;
+using System;
+using System.Collections.Generic;
+using System.ComponentModel.Composition;
+using System.Reactive.Concurrency;
+using System.Reactive.Linq;
+using System.Reactive.Subjects;
 using System.Threading.Tasks;
+using GitHub.App.Models.Drafts;
 using GitHub.Extensions;
 using GitHub.Models;
+using GitHub.Services;
 using ReactiveUI;
 
 namespace GitHub.ViewModels
@@ -12,24 +19,39 @@ namespace GitHub.ViewModels
     public abstract class CommentThreadViewModel : ReactiveObject, ICommentThreadViewModel
     {
         readonly ReactiveList<ICommentViewModel> comments = new ReactiveList<ICommentViewModel>();
+        readonly Dictionary<ICommentViewModel, IObserver<ICommentViewModel>> draftThrottles =
+            new Dictionary<ICommentViewModel, IObserver<ICommentViewModel>>();
+        readonly IScheduler timerScheduler;
 
         /// <summary>
         /// Initializes a new instance of the <see cref="CommentThreadViewModel"/> class.
         /// </summary>
+        /// <param name="draftStore">The message draft store.</param>
         [ImportingConstructor]
-        public CommentThreadViewModel()
+        public CommentThreadViewModel(IMessageDraftStore draftStore)
+            : this(draftStore, DefaultScheduler.Instance)
         {
         }
 
         /// <summary>
-        /// Intializes a new instance of the <see cref="CommentThreadViewModel"/> class.
+        /// Initializes a new instance of the <see cref="CommentThreadViewModel"/> class.
         /// </summary>
-        /// <param name="currentUser">The current user.</param>
-        protected Task InitializeAsync(ActorModel currentUser)
+        /// <param name="draftStore">The message draft store.</param>
+        /// <param name="timerScheduler">
+        /// The scheduler to use to apply a throttle to message drafts.
+        /// </param>
+        [ImportingConstructor]
+        public CommentThreadViewModel(
+            IMessageDraftStore draftStore,
+            IScheduler timerScheduler)
         {
-            Guard.ArgumentNotNull(currentUser, nameof(currentUser));
-            CurrentUser = new ActorViewModel(currentUser);
-            return Task.CompletedTask;
+            Guard.ArgumentNotNull(draftStore, nameof(draftStore));
+
+            this.DraftStore = draftStore;
+            this.timerScheduler = timerScheduler;
+
+            comments.ChangeTrackingEnabled = true;
+            comments.ItemChanged.Subscribe(ItemChanged);
         }
 
         /// <inheritdoc/>
@@ -38,6 +60,11 @@ protected Task InitializeAsync(ActorModel currentUser)
         /// <inheritdoc/>
         public IActorViewModel CurrentUser { get; private set; }
 
+        /// <inheritdoc/>
+        IReadOnlyReactiveList<ICommentViewModel> ICommentThreadViewModel.Comments => comments;
+
+        protected IMessageDraftStore DraftStore { get; }
+
         /// <inheritdoc/>
         public abstract Task PostComment(string body);
 
@@ -47,7 +74,65 @@ protected Task InitializeAsync(ActorModel currentUser)
         /// <inheritdoc/>
         public abstract Task DeleteComment(int pullRequestId, int commentId);
 
-        /// <inheritdoc/>
-        IReadOnlyReactiveList<ICommentViewModel> ICommentThreadViewModel.Comments => comments;
+        /// <summary>
+        /// Intializes a new instance of the <see cref="CommentThreadViewModel"/> class.
+        /// </summary>
+        /// <param name="currentUser">The current user.</param>
+        protected Task InitializeAsync(ActorModel currentUser)
+        {
+            Guard.ArgumentNotNull(currentUser, nameof(currentUser));
+            CurrentUser = new ActorViewModel(currentUser);
+            return Task.CompletedTask;
+        }
+
+        protected virtual CommentDraft BuildDraft(ICommentViewModel comment)
+        {
+            return !string.IsNullOrEmpty(comment.Body) ?
+                new CommentDraft { Body = comment.Body } :
+                null;
+        }
+
+        protected abstract (string key, string secondaryKey) GetDraftKeys(ICommentViewModel comment);
+
+        void ItemChanged(IReactivePropertyChangedEventArgs<ICommentViewModel> e)
+        {
+            if (e.PropertyName == nameof(ICommentViewModel.Body) &&
+                e.Sender.EditState == CommentEditState.Editing)
+            {
+                if (!draftThrottles.TryGetValue(e.Sender, out var throttle))
+                {
+                    var subject = new Subject<ICommentViewModel>();
+                    subject.Throttle(TimeSpan.FromSeconds(1), timerScheduler).Subscribe(UpdateDraft);
+                    draftThrottles.Add(e.Sender, subject);
+                    throttle = subject;
+                }
+
+                throttle.OnNext(e.Sender);
+            }
+            else if (e.PropertyName == nameof(ICommentViewModel.EditState) &&
+                e.Sender.EditState != CommentEditState.Editing)
+            {
+                if (draftThrottles.TryGetValue(e.Sender, out var throttle))
+                {
+                    throttle.OnCompleted();
+                    draftThrottles.Remove(e.Sender);
+                }
+            }
+        }
+
+        void UpdateDraft(ICommentViewModel comment)
+        {
+            var draft = BuildDraft(comment);
+            var (key, secondaryKey) = GetDraftKeys(comment);
+
+            if (draft != null)
+            {
+                DraftStore.UpdateDraft(key, secondaryKey, draft).Forget();
+            }
+            else
+            {
+                DraftStore.DeleteDraft(key, secondaryKey).Forget();
+            }
+        }
     }
 }

src/GitHub.App/ViewModels/PullRequestReviewCommentThreadViewModel.cs

@@ -1,12 +1,16 @@
 using System;
 using System.ComponentModel.Composition;
+using System.Globalization;
 using System.Linq;
 using System.Threading.Tasks;
+using GitHub.App.Models.Drafts;
 using GitHub.Extensions;
 using GitHub.Factories;
 using GitHub.Models;
+using GitHub.Primitives;
 using GitHub.Services;
 using ReactiveUI;
+using static System.FormattableString;
 
 namespace GitHub.ViewModels
 {
@@ -25,9 +29,13 @@ public class PullRequestReviewCommentThreadViewModel : CommentThreadViewModel, I
         /// <summary>
         /// Initializes a new instance of the <see cref="PullRequestReviewCommentThreadViewModel"/> class.
         /// </summary>
+        /// <param name="draftStore">The message draft store.</param>
         /// <param name="factory">The view model factory.</param>
         [ImportingConstructor]
-        public PullRequestReviewCommentThreadViewModel(IViewViewModelFactory factory)
+        public PullRequestReviewCommentThreadViewModel(
+            IMessageDraftStore draftStore,
+            IViewViewModelFactory factory)
+            : base(draftStore)
         {
             Guard.ArgumentNotNull(factory, nameof(factory));
 
@@ -75,7 +83,7 @@ public async Task InitializeAsync(
         {
             Guard.ArgumentNotNull(session, nameof(session));
 
-            await base.InitializeAsync(session.User).ConfigureAwait(false);
+            await base.InitializeAsync(session.User).ConfigureAwait(true);
 
             Session = session;
             File = file;
@@ -97,7 +105,7 @@ await vm.InitializeAsync(
             if (addPlaceholder)
             {
                 var vm = factory.CreateViewModel<IPullRequestReviewCommentViewModel>();
-                await vm.InitializeAsPlaceholderAsync(session, this, false).ConfigureAwait(false);
+                await vm.InitializeAsPlaceholderAsync(session, this, false).ConfigureAwait(true);
                 Comments.Add(vm);
             }
         }
@@ -123,6 +131,14 @@ public async Task InitializeNewAsync(
             var vm = factory.CreateViewModel<IPullRequestReviewCommentViewModel>();
             await vm.InitializeAsPlaceholderAsync(session, this, isEditing).ConfigureAwait(false);
             Comments.Add(vm);
+
+            var (key, secondaryKey) = GetDraftKeys(vm);
+            var draft = await DraftStore.GetDraft<CommentDraft>(key, secondaryKey).ConfigureAwait(true);
+
+            if (draft != null)
+            {
+                vm.Body = draft.Body;
+            }
         }
 
         public override async Task PostComment(string body)
@@ -170,5 +186,29 @@ public override async Task DeleteComment(int pullRequestId, int commentId)
         {
             await Session.DeleteComment(pullRequestId, commentId).ConfigureAwait(false);
         }
+
+        public static (string key, string secondaryKey) GetDraftKeys(
+            UriString cloneUri,
+            int pullRequestNumber,
+            string relativePath,
+            int lineNumber)
+        {
+            var key = Invariant($"pr-review-comment|{cloneUri}|{pullRequestNumber}|{relativePath}");
+            return (key, lineNumber.ToString(CultureInfo.InvariantCulture));
+        }
+
+        protected override CommentDraft BuildDraft(ICommentViewModel comment)
+        {
+            return base.BuildDraft(comment);
+        }
+
+        protected override (string key, string secondaryKey) GetDraftKeys(ICommentViewModel comment)
+        {
+            return GetDraftKeys(
+                Session.LocalRepository.CloneUrl.WithOwner(Session.RepositoryOwner),
+                Session.PullRequest.Number,
+                File.RelativePath,
+                LineNumber);
+        }
     }
 }

test/GitHub.App.UnitTests/ViewModels/CommentThreadViewModelTests.cs

@@ -0,0 +1,107 @@
+using System;
+using System.Reactive.Concurrency;
+using System.Threading.Tasks;
+using GitHub.App.Models.Drafts;
+using GitHub.Models;
+using GitHub.Services;
+using GitHub.ViewModels;
+using NSubstitute;
+using NUnit.Framework;
+using ReactiveUI.Testing;
+
+namespace GitHub.App.UnitTests.ViewModels
+{
+    public class CommentThreadViewModelTests
+    {
+        [Test]
+        public async Task SavesDraftForEditingComment()
+        {
+            using (TestUtils.WithScheduler(Scheduler.CurrentThread))
+            {
+                var scheduler = new HistoricalScheduler();
+                var drafts = Substitute.For<IMessageDraftStore>();
+                var target = CreateTarget(drafts: drafts, scheduler: scheduler);
+
+                await target.AddPlaceholder(true);
+                target.Comments[0].Body = "Edited comment.";
+
+                await drafts.DidNotReceiveWithAnyArgs().UpdateDraft<CommentDraft>(null, null, null);
+
+                scheduler.AdvanceBy(TimeSpan.FromSeconds(1));
+
+                await drafts.Received().UpdateDraft(
+                    "file.cs",
+                    "10",
+                    Arg.Is<CommentDraft>(x => x.Body == "Edited comment."));
+            }
+        }
+
+        [Test]
+        public async Task DoesntSaveDraftForNonEditingComment()
+        {
+            using (TestUtils.WithScheduler(Scheduler.CurrentThread))
+            {
+                var scheduler = new HistoricalScheduler();
+                var drafts = Substitute.For<IMessageDraftStore>();
+                var target = CreateTarget(drafts: drafts, scheduler: scheduler);
+
+                await target.AddPlaceholder(false);
+                target.Comments[0].Body = "Edited comment.";
+
+                scheduler.AdvanceBy(TimeSpan.FromSeconds(1));
+
+                await drafts.DidNotReceiveWithAnyArgs().UpdateDraft<CommentDraft>(null, null, null);
+            }
+        }
+
+        static Target CreateTarget(
+            IMessageDraftStore drafts = null,
+            IScheduler scheduler = null)
+        {
+            drafts = drafts ?? Substitute.For<IMessageDraftStore>();
+            scheduler = scheduler ?? DefaultScheduler.Instance;
+
+            return new Target(drafts, scheduler);
+        }
+
+        class Target : CommentThreadViewModel
+        {
+            public Target(IMessageDraftStore drafts, IScheduler scheduler)
+                : base(drafts, scheduler)
+            {
+            }
+
+            public async Task AddPlaceholder(bool isEditing)
+            {
+                var c = new TestComment();
+                await c.InitializeAsPlaceholderAsync(this, isEditing);
+                Comments.Add(c);
+            }
+
+            public override Task DeleteComment(int pullRequestId, int commentId) => throw new NotImplementedException();
+            public override Task EditComment(string id, string body) => throw new NotImplementedException();
+            public override Task PostComment(string body) => throw new NotImplementedException();
+            protected override (string key, string secondaryKey) GetDraftKeys(ICommentViewModel comment) => ("file.cs", "10");
+        }
+
+        class TestComment : CommentViewModel
+        {
+            public TestComment()
+                : base(Substitute.For<ICommentService>())
+            {
+            }
+
+            /// <inheritdoc/>
+            public async Task InitializeAsPlaceholderAsync(
+                ICommentThreadViewModel thread,
+                bool isEditing)
+            {
+                await InitializeAsync(
+                    thread,
+                    new ActorModel(),
+                    null,
+                    isEditing ? CommentEditState.Editing : CommentEditState.Placeholder).ConfigureAwait(true);
+            }
+        }
+    }
+}