Starting to add functionality to handle the edit/delete

Author: StanleyGoldman

src/GitHub.InlineReviews/SampleData/CommentThreadViewModelDesigner.cs

@@ -18,6 +18,8 @@ class CommentThreadViewModelDesigner : ICommentThreadViewModel
             = new AccountDesigner { Login = "shana", IsUser = true };
 
         public ReactiveCommand<ICommentModel> PostComment { get; }
+        public ReactiveCommand<ICommentModel> EditComment { get; }
+        public ReactiveCommand<ICommentModel> DeleteComment { get; }
 
         public Uri GetCommentUrl(int id)
         {

src/GitHub.InlineReviews/SampleData/CommentViewModelDesigner.cs

@@ -35,6 +35,6 @@ public CommentViewModelDesigner()
         public ReactiveCommand<object> CancelEdit { get; }
         public ReactiveCommand<Unit> CommitEdit { get; }
         public ReactiveCommand<object> OpenOnGitHub { get; }
-        public ReactiveCommand<object> Delete { get; }
+        public ReactiveCommand<Unit> Delete { get; }
     }
 }

src/GitHub.InlineReviews/ViewModels/CommentThreadViewModel.cs

@@ -12,12 +12,13 @@ namespace GitHub.InlineReviews.ViewModels
     public abstract class CommentThreadViewModel : ReactiveObject, ICommentThreadViewModel
     {
         ReactiveCommand<ICommentModel> postComment;
+        private ReactiveCommand<ICommentModel> editComment;
+        private ReactiveCommand<ICommentModel> deleteComment;
 
         /// <summary>
         /// Intializes a new instance of the <see cref="CommentThreadViewModel"/> class.
         /// </summary>
         /// <param name="currentUser">The current user.</param>
-        /// <param name="commentModels">The thread comments.</param>
         protected CommentThreadViewModel(IAccount currentUser)
         {
             Guard.ArgumentNotNull(currentUser, nameof(currentUser));
@@ -44,6 +45,30 @@ public ReactiveCommand<ICommentModel> PostComment
             }
         }
 
+        public ReactiveCommand<ICommentModel> EditComment
+        {
+            get { return editComment; }
+            set
+            {
+                Guard.ArgumentNotNull(value, nameof(value));
+                editComment = value;
+
+                value.ThrownExceptions.Subscribe(_ => { });
+            }
+        }
+
+        public ReactiveCommand<ICommentModel> DeleteComment
+        {
+            get { return deleteComment; }
+            set
+            {
+                Guard.ArgumentNotNull(value, nameof(value));
+                deleteComment = value;
+
+                value.ThrownExceptions.Subscribe(_ => { });
+            }
+        }
+
         /// <inheritdoc/>
         public IAccount CurrentUser { get; }
 

src/GitHub.InlineReviews/ViewModels/CommentViewModel.cs

@@ -64,14 +64,15 @@ protected CommentViewModel(
                 x => x.EditState,
                 x => x == CommentEditState.None && user.Login.Equals(currentUser.Login));
 
-            Delete = ReactiveCommand.Create(canDelete);
+            Delete = ReactiveCommand.CreateAsyncTask(canDelete, DoDelete);
 
             var canEdit = this.WhenAnyValue(
                 x => x.EditState,
                 x => x == CommentEditState.None && user.Login.Equals(currentUser.Login));
 
             BeginEdit = ReactiveCommand.Create(canEdit);
             BeginEdit.Subscribe(DoBeginEdit);
+            AddErrorHandler(BeginEdit);
 
             var canCreate = this.WhenAnyValue(
                 x => x.EditState,
@@ -91,10 +92,23 @@ protected CommentViewModel(
                 DoCommitCreate);
             AddErrorHandler(CommitCreate);
 
+            CommitEdit = ReactiveCommand.CreateAsyncTask(
+                Observable.CombineLatest(
+                    this.WhenAnyValue(x => x.IsReadOnly),
+                    this.WhenAnyValue(x => x.Body, x => !string.IsNullOrWhiteSpace(x)),
+                    this.WhenAnyObservable(x => x.Thread.EditComment.CanExecuteObservable),
+                    (readOnly, hasBody, canPost) => !readOnly && hasBody && canPost),
+                DoCommitEdit);
+            AddErrorHandler(CommitEdit);
+
             CancelCreate = ReactiveCommand.Create(CommitCreate.IsExecuting.Select(x => !x));
             CancelCreate.Subscribe(DoCancelCreate);
             AddErrorHandler(CancelCreate);
 
+            CancelEdit = ReactiveCommand.Create(CommitEdit.IsExecuting.Select(x => !x));
+            CancelEdit.Subscribe(DoCancelEdit);
+            AddErrorHandler(CancelEdit);
+
             OpenOnGitHub = ReactiveCommand.Create(this.WhenAnyValue(x => x.Id, x => x != 0));
         }
 
@@ -117,6 +131,27 @@ protected void AddErrorHandler<T>(ReactiveCommand<T> command)
             command.ThrownExceptions.Subscribe(x => ErrorMessage = x.Message);
         }
 
+        async Task DoDelete(object unused)
+        {
+            try
+            {
+                ErrorMessage = null;
+                IsSubmitting = true;
+
+                await Thread.DeleteComment.ExecuteAsyncTask(Body);
+            }
+            catch (Exception e)
+            {
+                var message = e.Message;
+                ErrorMessage = message;
+                log.Error(e, "Error Deleting comment");
+            }
+            finally
+            {
+                IsSubmitting = false;
+            }
+        }
+
         void DoBeginEdit(object unused)
         {
             if (state != CommentEditState.Editing)
@@ -135,6 +170,17 @@ void DoBeginCreate(object unused)
             }
         }
 
+        void DoCancelEdit(object unused)
+        {
+            if (EditState == CommentEditState.Editing)
+            {
+                EditState = string.IsNullOrWhiteSpace(undoBody) ? CommentEditState.Placeholder : CommentEditState.None;
+                Body = undoBody;
+                ErrorMessage = null;
+                undoBody = null;
+            }
+        }
+
         void DoCancelCreate(object unused)
         {
             if (EditState == CommentEditState.Creating)
@@ -171,6 +217,31 @@ async Task DoCommitCreate(object unused)
             }
         }
 
+        async Task DoCommitEdit(object unused)
+        {
+            try
+            {
+                ErrorMessage = null;
+                IsSubmitting = true;
+
+                var model = await Thread.EditComment.ExecuteAsyncTask(Body);
+                Id = model.Id;
+                NodeId = model.NodeId;
+                EditState = CommentEditState.None;
+                UpdatedAt = DateTimeOffset.Now;
+            }
+            catch (Exception e)
+            {
+                var message = e.Message;
+                ErrorMessage = message;
+                log.Error(e, "Error editing comment");
+            }
+            finally
+            {
+                IsSubmitting = false;
+            }
+        }
+
         /// <inheritdoc/>
         public int Id { get; private set; }
 
@@ -250,6 +321,6 @@ public DateTimeOffset UpdatedAt
         public ReactiveCommand<object> OpenOnGitHub { get; }
 
         /// <inheritdoc/>
-        public ReactiveCommand<object> Delete { get; }
+        public ReactiveCommand<Unit> Delete { get; }
     }
 }

src/GitHub.InlineReviews/ViewModels/ICommentThreadViewModel.cs

@@ -31,5 +31,15 @@ public interface ICommentThreadViewModel
         /// Called by a comment in the thread to post itself as a new comment to the API.
         /// </summary>
         ReactiveCommand<ICommentModel> PostComment { get; }
+
+        /// <summary>
+        /// Called by a comment in the thread to post itself as an edit to a comment to the API.
+        /// </summary>
+        ReactiveCommand<ICommentModel> EditComment { get; }
+
+        /// <summary>
+        /// Called by a comment in the thread to send a delete of the comment to the API.
+        /// </summary>
+        ReactiveCommand<ICommentModel> DeleteComment { get; }
     }
 }

src/GitHub.InlineReviews/ViewModels/ICommentViewModel.cs

@@ -108,6 +108,6 @@ public interface ICommentViewModel : IViewModel
         /// <summary>
         /// Deletes a comment.
         /// </summary>
-        ReactiveCommand<object> Delete { get; }
+        ReactiveCommand<Unit> Delete { get; }
     }
 }

src/GitHub.InlineReviews/ViewModels/InlineCommentThreadViewModel.cs

@@ -35,6 +35,14 @@ public InlineCommentThreadViewModel(
                 Observable.Return(true),
                 DoPostComment);
 
+            EditComment = ReactiveCommand.CreateAsyncTask(
+                Observable.Return(true),
+                DoEditComment);
+
+            DeleteComment = ReactiveCommand.CreateAsyncTask(
+                Observable.Return(true),
+                DoDeleteComment);
+
             foreach (var comment in comments)
             {
                 Comments.Add(new PullRequestReviewCommentViewModel(session, this, CurrentUser, comment));
@@ -68,5 +76,23 @@ async Task<ICommentModel> DoPostComment(object parameter)
             var nodeId = Comments[0].NodeId;
             return await Session.PostReviewComment(body, replyId, nodeId);
         }
+
+        Task<ICommentModel> DoEditComment(object parameter)
+        {
+            Guard.ArgumentNotNull(parameter, nameof(parameter));
+
+            var body = (string)parameter;
+            var replyId = Comments[0].Id;
+            var nodeId = Comments[0].NodeId;
+
+            throw new NotImplementedException();
+        }
+
+        Task<ICommentModel> DoDeleteComment(object parameter)
+        {
+            Guard.ArgumentNotNull(parameter, nameof(parameter));
+
+            throw new NotImplementedException();
+        }
     }
 }

src/GitHub.InlineReviews/Views/CommentView.xaml

@@ -12,7 +12,7 @@
              xmlns:views="clr-namespace:GitHub.InlineReviews.Views"
              mc:Ignorable="d" d:DesignWidth="300">
     <d:DesignProperties.DataContext>
-        <sample:CommentViewModelDesigner EditState="Creating">
+        <sample:CommentViewModelDesigner EditState="Editing">
             <sample:CommentViewModelDesigner.Body>
                 You can use a `CompositeDisposable` type here, it's designed to handle disposables in an optimal way (you can just call `Dispose()` on it and it will handle disposing everything it holds).
             </sample:CommentViewModelDesigner.Body>
@@ -105,6 +105,9 @@
                         <DataTrigger Binding="{Binding EditState}" Value="Creating">
                             <Setter Property="Visibility" Value="Visible"/>
                         </DataTrigger>
+                        <DataTrigger Binding="{Binding EditState}" Value="Editing">
+                            <Setter Property="Visibility" Value="Visible"/>
+                        </DataTrigger>
                     </Style.Triggers>
                 </Style>
             </Grid.Style>
@@ -148,6 +151,10 @@
                                 <Setter Property="MinHeight" Value="100"/>
                                 <Setter Property="PromptText" Value="Leave a comment"/>
                             </DataTrigger>
+                            <DataTrigger Binding="{Binding EditState}" Value="Editing">
+                                <Setter Property="MinHeight" Value="100"/>
+                                <Setter Property="PromptText" Value="Leave a comment"/>
+                            </DataTrigger>
                         </Style.Triggers>
 
                         <Style.Resources>
@@ -176,7 +183,7 @@
                 <TextBlock Text="{Binding ErrorMessage}" TextWrapping="Wrap"/>
             </DockPanel>
 
-            <StackPanel Name="buttonPanel"
+            <StackPanel Name="creatingButtonPanel"
                         Grid.Column="1" Grid.Row="3" 
                         Margin="4 8" 
                         HorizontalAlignment="Left"
@@ -200,6 +207,26 @@
                 </Button>
                 <Button Margin="4 0 0 0" Command="{Binding CancelCreate}">Cancel</Button>
             </StackPanel>
+
+            <StackPanel Name="editingButtonPanel"
+                        Grid.Column="1" Grid.Row="3" 
+                        Margin="4 8" 
+                        HorizontalAlignment="Left"
+                        Orientation="Horizontal"
+                        IsVisibleChanged="buttonPanel_IsVisibleChanged">
+                <StackPanel.Style>
+                    <Style TargetType="FrameworkElement">
+                        <Setter Property="Visibility" Value="Collapsed"/>
+                        <Style.Triggers>
+                            <DataTrigger Binding="{Binding EditState}" Value="Editing">
+                                <Setter Property="Visibility" Value="Visible"/>
+                            </DataTrigger>
+                        </Style.Triggers>
+                    </Style>
+                </StackPanel.Style>
+                <Button Command="{Binding CommitEdit}">Edit</Button>
+                <Button Margin="4 0 0 0" Command="{Binding CancelEdit}">Cancel</Button>
+            </StackPanel>
         </Grid>
     </Grid>
 </views:GenericCommentView>

src/GitHub.InlineReviews/Views/CommentView.xaml.cs

@@ -36,7 +36,7 @@ void DoOpenOnGitHub()
 
         private void CommentView_Loaded(object sender, System.Windows.RoutedEventArgs e)
         {
-            if (buttonPanel.IsVisible)
+            if (creatingButtonPanel.IsVisible || editingButtonPanel.IsVisible)
             {
                 BringIntoView();
                 body.Focus();
@@ -55,7 +55,7 @@ private void ReplyPlaceholder_GotFocus(object sender, System.Windows.RoutedEvent
 
         private void buttonPanel_IsVisibleChanged(object sender, System.Windows.DependencyPropertyChangedEventArgs e)
         {
-            if (buttonPanel.IsVisible)
+            if (creatingButtonPanel.IsVisible || editingButtonPanel.IsVisible)
             {
                 BringIntoView();
             }