finished splitting up thread_restrict action

Author: Oaphi

app/assets/javascripts/comments.js

@@ -197,28 +197,64 @@ $(() => {
     $modal.find('.js-follower-display').html(data);
   });
 
-  $(document).on('submit', '[class*=js--lock-thread] form', async (evt) => {
-    evt.preventDefault();
+  $(document).on('click', '.js-archive-thread', async (ev) => {
+    ev.preventDefault();
 
-    const $tgt = $(evt.target);
+    const $tgt = $(ev.target);
     const threadID = $tgt.data("thread");
 
-    const data = await QPixel.lockThread(threadID);
+    const data = await QPixel.archiveThread(threadID);
 
     QPixel.handleJSONResponse(data, () => {
-      window.location.reload();
+      const wrapper = getCommentThreadWrapper($tgt);
+      openThread(wrapper, threadID);
+    });
+  });
+
+  $(document).on('click', '.js-delete-thread', async (ev) => {
+    ev.preventDefault();
+
+    const $tgt = $(ev.target);
+    const threadID = $tgt.data("thread");
+
+    const data = await QPixel.deleteThread(threadID);
+
+    QPixel.handleJSONResponse(data, () => {
+      const wrapper = getCommentThreadWrapper($tgt);
+      openThread(wrapper, threadID);
     });
   });
 
-  $(document).on('click', '.js--restrict-thread, .js--unrestrict-thread', async (evt) => {
+  $(document).on('click', '.js-lock-thread', async (ev) => {
+    ev.preventDefault();
+
+    const $tgt = $(ev.target);
+    const threadID = $tgt.data("thread");
+    const form = $tgt.closest(`form[data-thread=${threadID}]`).get(0);
+
+    if (form instanceof HTMLFormElement) {
+      const { value: duration } = form.elements['duration'] ?? {};
+
+      const data = await QPixel.lockThread(threadID, duration ? Math.round(+duration) : void 0);
+
+      QPixel.handleJSONResponse(data, () => {
+        const wrapper = getCommentThreadWrapper($tgt);
+        openThread(wrapper, threadID);
+      });
+    } else {
+      QPixel.createNotification('danger', 'Failed to find thread to lock');
+    }
+  });
+
+  // TODO: split into individual handlers once unrestrict_thread is split
+  $(document).on('click', '.js--unrestrict-thread', async (evt) => {
     evt.preventDefault();
 
     const $tgt = $(evt.target);
     const threadID = $tgt.data("thread");
     const action = $tgt.data("action");
-    const route = $tgt.hasClass("js--restrict-thread") ? 'restrict' : 'unrestrict';
 
-    const resp = await QPixel.fetchJSON(`/comments/thread/${threadID}/${route}`, { type: action });
+    const resp = await QPixel.fetchJSON(`/comments/thread/${threadID}/unrestrict`, { type: action });
 
     const data = await resp.json();
 

app/assets/javascripts/qpixel_api.js

@@ -451,6 +451,30 @@ window.QPixel = {
     return QPixel.parseJSONResponse(resp, 'Failed to vote');
   },
 
+  archiveThread: async (id) => {
+    const resp = await QPixel.fetchJSON(`/comments/thread/${id}/archive`, {}, {
+      headers: { 'Accept': 'application/json' },
+    });
+
+    return QPixel.parseJSONResponse(resp, 'Failed to archive thread');
+  },
+
+  deleteThread: async (id) => {
+    const resp = await QPixel.fetchJSON(`/comments/thread/${id}/delete`, {}, {
+      headers: { 'Accept': 'application/json' },
+    });
+
+    return QPixel.parseJSONResponse(resp, 'Failed to delete thread');
+  },
+
+  lockThread: async (id, duration) => {
+    const resp = await QPixel.fetchJSON(`/comments/thread/${id}/lock`, {
+      duration,
+    });
+
+    return QPixel.parseJSONResponse(resp, 'Failed to lock thread');
+  },
+
   deleteComment: async (id) => {
     const resp = await QPixel.fetchJSON(`/comments/${id}/delete`, {}, {
       headers: { 'Accept': 'application/json' },
@@ -495,14 +519,6 @@ window.QPixel = {
     return QPixel.parseJSONResponse(resp, 'Failed to unfollow post comments');
   },
 
-  lockThread: async (id) => {
-    const resp = await QPixel.fetchJSON(`/comments/thread/${id}/restrict`, {
-      type: 'lock'
-    });
-
-    return QPixel.parseJSONResponse(resp, 'Failed to lock thread');
-  },
-
   renameTag: async (categoryId, tagId, name) => {
     const resp = await QPixel.fetchJSON(`/categories/${categoryId}/tags/${tagId}/rename`, { name }, {
       headers: { 'Accept': 'application/json' }

app/controllers/comments_controller.rb

@@ -5,15 +5,23 @@ class CommentsController < ApplicationController
 
   before_action :set_comment, only: [:update, :destroy, :undelete, :show]
   before_action :set_post, only: [:create_thread, :post_follow, :post_unfollow]
-  before_action :set_thread,
-                only: [:create, :thread, :thread_content, :thread_rename, :thread_restrict, :thread_unrestrict,
-                       :thread_followers]
-
+  before_action :set_thread, only: [:create,
+                                    :thread,
+                                    :thread_content,
+                                    :thread_rename,
+                                    :archive_thread,
+                                    :delete_thread,
+                                    :follow_thread,
+                                    :lock_thread,
+                                    :thread_unrestrict,
+                                    :thread_followers]
   before_action :check_post_access, only: [:create_thread, :create]
   before_action :check_privilege, only: [:update, :destroy, :undelete]
   before_action :check_create_access, only: [:create_thread, :create]
   before_action :check_reply_access, only: [:create]
-  before_action :check_restrict_access, only: [:thread_restrict]
+  before_action :check_archive_thread_access, only: [:archive_thread]
+  before_action :check_delete_thread_access, only: [:delete_thread]
+  before_action :check_lock_thread_access, only: [:lock_thread]
   before_action :check_thread_access, only: [:thread, :thread_content, :thread_followers]
   before_action :check_unrestrict_access, only: [:thread_unrestrict]
   before_action :check_if_target_post_locked, only: [:create, :post_follow]
@@ -268,22 +276,6 @@ def unlock_thread
     restrict_thread_response(@comment_thread, status)
   end
 
-  def thread_restrict
-    # TODO: remove this wrapper action entirely (callbacks need to be moved, routes assigned, etc)
-    case params[:type]
-    when 'lock'
-      lock_thread
-    when 'archive'
-      archive_thread
-    when 'delete'
-      delete_thread
-    when 'follow'
-      follow_thread
-    else
-      not_found!
-    end
-  end
-
   def thread_unrestrict
     # TODO: remove this wrapper action entirely (callbacks need to be moved, routes assigned, etc)
     case params[:type]
@@ -402,18 +394,20 @@ def check_reply_access
     end
   end
 
-  def check_restrict_access
-    case params[:type]
-    when 'lock'
-      not_found! unless current_user.can_lock?(@comment_thread)
-    when 'archive'
-      not_found! unless current_user.can_archive?(@comment_thread)
-    when 'delete'
-      not_found! unless current_user.can_delete?(@comment_thread)
-    end
+  def check_archive_thread_access
+    not_found! unless current_user.can_archive?(@comment_thread)
+  end
+
+  def check_delete_thread_access
+    not_found! unless current_user.can_delete?(@comment_thread)
+  end
+
+  def check_lock_thread_access
+    not_found! unless current_user.can_lock?(@comment_thread)
   end
 
   def check_unrestrict_access
+    # TODO: split into individual checks once unrestrict_thread is split
     case params[:type]
     when 'lock'
       not_found! unless current_user.can_unlock?(@comment_thread)

app/views/comments/_lock_thread_modal.html.erb

@@ -6,7 +6,7 @@
 "%>
 
 <div class="modal is-with-backdrop is-small js--lock-thread-<%= thread.id %>">
-  <%= form_tag restrict_comment_thread_path(thread.id),
+  <%= form_tag lock_comment_thread_path(thread.id),
                class: 'modal--container',
                data: { thread: thread.id } do %>
     <%= hidden_field_tag :type, 'lock' %>
@@ -25,7 +25,7 @@
       <%= number_field_tag :duration, nil, class: 'form-element' %>
     </div>
     <div class="modal--footer">
-      <%= submit_tag 'Lock thread', class: 'button is-muted is-filled',
+      <%= submit_tag 'Lock thread', class: 'button is-muted is-filled js-lock-thread',
                                     data: { thread: thread.id } %>
       <button type="button" class="button is-muted" data-modal=".js--lock-thread-<%= thread.id %>">Cancel</button>
     </div>

app/views/comments/_thread_actions_modal.html.erb

@@ -17,7 +17,7 @@
       </a>
     <% end %>
 
-    <% unless thread.archived || thread.deleted %>
+    <% unless thread.archived || thread.deleted? %>
       <% if thread.locked? %>
         <a href="javascript:void(0)" class="js--unrestrict-thread"
                                      data-action="lock"
@@ -35,7 +35,7 @@
       <% end %>
     <% end %>
 
-    <% unless thread.locked? || thread.deleted %>
+    <% unless thread.locked? || thread.deleted? %>
       <% if thread.archived %>
         <a href="javascript:void(0)" class="js--unrestrict-thread" 
                                      data-action="archive"
@@ -45,8 +45,7 @@
           <i class="fas fa-archive fa-fw"></i> restore
         </a>
       <% else %>
-        <a href="javascript:void(0)" class="js--restrict-thread"
-                                     data-action="archive"
+        <a href="javascript:void(0)" class="js-archive-thread"
                                      data-thread="<%= thread.id %>"
                                      role="button"
                                      aria-label="Archive thread">
@@ -55,7 +54,7 @@
       <% end %>
     <% end %>
 
-    <% unless thread.locked? || thread.archived %>
+    <% unless thread.locked? || thread.archived? %>
       <% if thread.deleted %>
         <a href="javascript:void(0)" class="js--unrestrict-thread"
                                      data-action="delete"
@@ -65,8 +64,7 @@
           <i class="fas fa-trash fa-fw"></i> undelete
         </a>
       <% else %>
-        <a href="javascript:void(0)" class="js--restrict-thread"
-                                     data-action="delete"
+        <a href="javascript:void(0)" class="js-delete-thread"
                                      data-thread="<%= thread.id %>"
                                      role="button"
                                      aria-label="Delete thread">

config/routes.rb

@@ -239,7 +239,12 @@
     get    'thread/:id/pingable',          to: 'comments#pingable', as: :thread_pingable
     post   'thread/:id/new',               to: 'comments#create', as: :create_comment
     post   'thread/:id/rename',            to: 'comments#thread_rename', as: :rename_comment_thread
-    post   'thread/:id/restrict',          to: 'comments#thread_restrict', as: :restrict_comment_thread
+
+    post   'thread/:id/archive',           to: 'comments#archive_thread', as: :archive_comment_thread
+    post   'thread/:id/delete',            to: 'comments#delete_thread', as: :delete_comment_thread
+    post   'thread/:id/follow',            to: 'comments#follow_thread', as: :follow_comment_thread
+    post   'thread/:id/lock',              to: 'comments#lock_thread', as: :lock_comment_thread
+
     post   'thread/:id/unrestrict',        to: 'comments#thread_unrestrict', as: :unrestrict_comment_thread
     get    'thread/:id/followers',         to: 'comments#thread_followers', as: :comment_thread_followers
     get    'post/:post_id',                to: 'comments#post', as: :post_comments

global.d.ts

@@ -540,13 +540,27 @@ interface QPixel {
                                                       onSuccess: (data: Extract<T, QPixelSuccessResponseJSON>) => void,
                                                       onFinally?: (data: T) => void) => boolean
 
+  /**
+   * Attempts to archive a comment thread
+   * @param id id of the thread to archive
+   * @returns result of the operation
+   */
+  archiveThread?: (id: string) => Promise<QPixelResponseJSON>
+
   /**
    * Attempts to delete a comment
    * @param id id of the comment to delete
    * @returns result of the operation
    */
   deleteComment?: (id: string) => Promise<QPixelResponseJSON>
 
+  /**
+   * Attempts to delete a comment thread
+   * @param id id of the thread to delete
+   * @returns result of the operation
+   */
+  deleteThread?: (id: string) => Promise<QPixelResponseJSON>
+
   /**
    * Attempts to start following comments on a given post
    * @param postId id of the post to follow comments on
@@ -584,9 +598,10 @@ interface QPixel {
   /**
    * Attempts to lock a comment thread
    * @param id id of the comment thread to lock
+   * @param duration how long should the thread be locked for, in days
    * @returns result of the operation
    */
-  lockThread?: (id: string) => Promise<QPixelResponseJSON>
+  lockThread?: (id: string, duration?: number) => Promise<QPixelResponseJSON>
 
   /**
    * Attempts to rename a tag

test/comments_test_helpers.rb

@@ -6,7 +6,7 @@ module CommentsControllerTestHelpers
   # Attempts to archive a given comment thread
   # @param thread [CommentThread] thread to archive
   def try_archive_thread(thread)
-    post :thread_restrict, params: { id: thread.id, type: 'archive' }
+    post :archive_thread, params: { id: thread.id }
   end
 
   # Attempts to create a comment thread on a given post
@@ -50,7 +50,7 @@ def try_create_comment(thread,
   # Attempts to delete a given comment thread
   # @param thread [CommentThread] thread to delete
   def try_delete_thread(thread)
-    post :thread_restrict, params: { id: thread.id, type: 'delete' }
+    post :delete_thread, params: { id: thread.id }
   end
 
   # Attempts to undelete a given comment thread
@@ -62,7 +62,7 @@ def try_undelete_thread(thread)
   # Attempts to follow a given comment thread
   # @param thread [CommentThread] thread to follow
   def try_follow_thread(thread)
-    post :thread_restrict, params: { id: thread.id, type: 'follow' }
+    post :follow_thread, params: { id: thread.id }
   end
 
   # Attempts to unfollow a given comment thread
@@ -87,7 +87,7 @@ def try_post_unfollow(test_post)
   # @param thread [CommentThread] thread to lock
   # @param duration [Integer] lock duration, in days
   def try_lock_thread(thread, duration: nil)
-    post :thread_restrict, params: { duration: duration, id: thread.id, type: 'lock' }
+    post :lock_thread, params: { duration: duration, id: thread.id }
   end
 
   # Attempts to unlock a given comment thread