700 lines
25 KiB
Ruby
700 lines
25 KiB
Ruby
class CommentsController < ApplicationController
|
|
skip_before_action :store_location, except: [:show, :index, :new]
|
|
before_action :load_commentable,
|
|
only: [:index, :new, :create, :edit, :update, :show_comments,
|
|
:hide_comments, :add_comment_reply,
|
|
:cancel_comment_reply, :delete_comment,
|
|
:cancel_comment_delete, :unreviewed, :review_all]
|
|
before_action :check_user_status, only: [:new, :create, :edit, :update, :destroy]
|
|
before_action :load_comment, only: [:show, :edit, :update, :delete_comment, :destroy, :cancel_comment_edit, :cancel_comment_delete, :review, :approve, :reject, :freeze, :unfreeze, :hide, :unhide]
|
|
before_action :check_visibility, only: [:show]
|
|
before_action :check_if_restricted
|
|
before_action :check_tag_wrangler_access
|
|
before_action :check_parent_visible
|
|
before_action :check_modify_parent,
|
|
only: [:new, :create, :edit, :update, :add_comment_reply,
|
|
:cancel_comment_reply, :cancel_comment_edit]
|
|
before_action :check_pseud_ownership, only: [:create, :update]
|
|
before_action :check_ownership, only: [:edit, :update, :cancel_comment_edit]
|
|
before_action :check_permission_to_edit, only: [:edit, :update ]
|
|
before_action :check_permission_to_delete, only: [:delete_comment, :destroy]
|
|
before_action :check_guest_comment_admin_setting, only: [:new, :create, :add_comment_reply]
|
|
before_action :check_parent_comment_permissions, only: [:new, :create, :add_comment_reply]
|
|
before_action :check_unreviewed, only: [:add_comment_reply]
|
|
before_action :check_frozen, only: [:new, :create, :add_comment_reply]
|
|
before_action :check_hidden_by_admin, only: [:new, :create, :add_comment_reply]
|
|
before_action :check_not_replying_to_spam, only: [:new, :create, :add_comment_reply]
|
|
before_action :check_guest_replies_preference, only: [:new, :create, :add_comment_reply]
|
|
before_action :check_permission_to_review, only: [:unreviewed]
|
|
before_action :check_permission_to_access_single_unreviewed, only: [:show]
|
|
before_action :check_permission_to_moderate, only: [:approve, :reject]
|
|
before_action :check_permission_to_modify_frozen_status, only: [:freeze, :unfreeze]
|
|
before_action :check_permission_to_modify_hidden_status, only: [:hide, :unhide]
|
|
before_action :admin_logout_required, only: [:new, :create, :add_comment_reply]
|
|
|
|
include BlockHelper
|
|
|
|
before_action :check_blocked, only: [:new, :create, :add_comment_reply, :edit, :update]
|
|
def check_blocked
|
|
parent = find_parent
|
|
|
|
if blocked_by?(parent)
|
|
flash[:comment_error] = t("comments.check_blocked.parent")
|
|
redirect_to_all_comments(parent, show_comments: true)
|
|
elsif @comment && blocked_by_comment?(@comment.commentable)
|
|
# edit and update set @comment to the comment being edited
|
|
flash[:comment_error] = t("comments.check_blocked.reply")
|
|
redirect_to_all_comments(parent, show_comments: true)
|
|
elsif @comment.nil? && blocked_by_comment?(@commentable)
|
|
# new, create, and add_comment_reply don't set @comment, but do set @commentable
|
|
flash[:comment_error] = t("comments.check_blocked.reply")
|
|
redirect_to_all_comments(parent, show_comments: true)
|
|
end
|
|
end
|
|
|
|
def check_pseud_ownership
|
|
return unless params[:comment][:pseud_id]
|
|
pseud = Pseud.find(params[:comment][:pseud_id])
|
|
return if pseud && current_user && current_user.pseuds.include?(pseud)
|
|
flash[:error] = ts("You can't comment with that pseud.")
|
|
redirect_to root_path
|
|
end
|
|
|
|
def load_comment
|
|
@comment = Comment.find(params[:id])
|
|
@check_ownership_of = @comment
|
|
@check_visibility_of = @comment
|
|
end
|
|
|
|
def check_parent_visible
|
|
check_visibility_for(find_parent)
|
|
end
|
|
|
|
def check_modify_parent
|
|
parent = find_parent
|
|
# No one can create or update comments on something hidden by an admin.
|
|
if parent.respond_to?(:hidden_by_admin) && parent.hidden_by_admin
|
|
flash[:error] = ts("Sorry, you can't add or edit comments on a hidden work.")
|
|
redirect_to work_path(parent)
|
|
end
|
|
# No one can create or update comments on unrevealed works.
|
|
if parent.respond_to?(:in_unrevealed_collection) && parent.in_unrevealed_collection
|
|
flash[:error] = ts("Sorry, you can't add or edit comments on an unrevealed work.")
|
|
redirect_to work_path(parent)
|
|
end
|
|
end
|
|
|
|
def find_parent
|
|
if @comment.present?
|
|
@comment.ultimate_parent
|
|
elsif @commentable.is_a?(Comment)
|
|
@commentable.ultimate_parent
|
|
elsif @commentable.present? && @commentable.respond_to?(:work)
|
|
@commentable.work
|
|
else
|
|
@commentable
|
|
end
|
|
end
|
|
|
|
# Check to see if the ultimate_parent is a Work, and if so, if it's restricted
|
|
def check_if_restricted
|
|
parent = find_parent
|
|
|
|
return unless parent.respond_to?(:restricted) && parent.restricted? && !(logged_in? || logged_in_as_admin?)
|
|
redirect_to new_user_session_path(restricted_commenting: true)
|
|
end
|
|
|
|
# Check to see if the ultimate_parent is a Work or AdminPost, and if so, if it allows
|
|
# comments for the current user.
|
|
def check_parent_comment_permissions
|
|
parent = find_parent
|
|
if parent.is_a?(Work)
|
|
translation_key = "work"
|
|
elsif parent.is_a?(AdminPost)
|
|
translation_key = "admin_post"
|
|
else
|
|
return
|
|
end
|
|
|
|
if parent.disable_all_comments?
|
|
flash[:error] = t("comments.commentable.permissions.#{translation_key}.disable_all")
|
|
redirect_to parent
|
|
elsif parent.disable_anon_comments? && !logged_in?
|
|
flash[:error] = t("comments.commentable.permissions.#{translation_key}.disable_anon")
|
|
redirect_to parent
|
|
end
|
|
end
|
|
|
|
def check_guest_comment_admin_setting
|
|
admin_settings = AdminSetting.current
|
|
|
|
return unless admin_settings.guest_comments_off? && guest?
|
|
|
|
flash[:error] = t("comments.commentable.guest_comments_disabled")
|
|
redirect_back(fallback_location: root_path)
|
|
end
|
|
|
|
def check_guest_replies_preference
|
|
return unless guest? && @commentable.respond_to?(:guest_replies_disallowed?) && @commentable.guest_replies_disallowed?
|
|
|
|
flash[:error] = t("comments.check_guest_replies_preference.error")
|
|
redirect_back(fallback_location: root_path)
|
|
end
|
|
|
|
def check_unreviewed
|
|
return unless @commentable.respond_to?(:unreviewed?) && @commentable.unreviewed?
|
|
|
|
flash[:error] = ts("Sorry, you cannot reply to an unapproved comment.")
|
|
redirect_to logged_in? ? root_path : new_user_session_path
|
|
end
|
|
|
|
def check_frozen
|
|
return unless @commentable.respond_to?(:iced?) && @commentable.iced?
|
|
|
|
flash[:error] = t("comments.check_frozen.error")
|
|
redirect_back(fallback_location: root_path)
|
|
end
|
|
|
|
def check_hidden_by_admin
|
|
return unless @commentable.respond_to?(:hidden_by_admin?) && @commentable.hidden_by_admin?
|
|
|
|
flash[:error] = t("comments.check_hidden_by_admin.error")
|
|
redirect_back(fallback_location: root_path)
|
|
end
|
|
|
|
def check_not_replying_to_spam
|
|
return unless @commentable.respond_to?(:approved?) && !@commentable.approved?
|
|
|
|
flash[:error] = t("comments.check_not_replying_to_spam.error")
|
|
redirect_back(fallback_location: root_path)
|
|
end
|
|
|
|
def check_permission_to_review
|
|
parent = find_parent
|
|
return if logged_in_as_admin? || current_user_owns?(parent)
|
|
flash[:error] = ts("Sorry, you don't have permission to see those unreviewed comments.")
|
|
redirect_to logged_in? ? root_path : new_user_session_path
|
|
end
|
|
|
|
def check_permission_to_access_single_unreviewed
|
|
return unless @comment.unreviewed?
|
|
parent = find_parent
|
|
return if logged_in_as_admin? || current_user_owns?(parent) || current_user_owns?(@comment)
|
|
flash[:error] = ts("Sorry, that comment is currently in moderation.")
|
|
redirect_to logged_in? ? root_path : new_user_session_path
|
|
end
|
|
|
|
def check_permission_to_moderate
|
|
parent = find_parent
|
|
unless logged_in_as_admin? || current_user_owns?(parent)
|
|
flash[:error] = ts("Sorry, you don't have permission to moderate that comment.")
|
|
redirect_to(logged_in? ? root_path : new_user_session_path)
|
|
end
|
|
end
|
|
|
|
def check_tag_wrangler_access
|
|
if @commentable.is_a?(Tag) || (@comment&.parent&.is_a?(Tag))
|
|
logged_in_as_admin? || permit?("tag_wrangler") || access_denied
|
|
end
|
|
end
|
|
|
|
# Must be able to delete other people's comments on owned works, not just owned comments!
|
|
def check_permission_to_delete
|
|
access_denied(redirect: @comment) unless logged_in_as_admin? || current_user_owns?(@comment) || current_user_owns?(@comment.ultimate_parent)
|
|
end
|
|
|
|
# Comments cannot be edited after they've been replied to or if they are frozen.
|
|
def check_permission_to_edit
|
|
if @comment&.iced?
|
|
flash[:error] = t("comments.check_permission_to_edit.error.frozen")
|
|
redirect_back(fallback_location: root_path)
|
|
elsif !@comment&.count_all_comments&.zero?
|
|
flash[:error] = ts("Comments with replies cannot be edited")
|
|
redirect_back(fallback_location: root_path)
|
|
end
|
|
end
|
|
|
|
# Comments on works can be frozen or unfrozen by admins with proper
|
|
# authorization or the work creator.
|
|
# Comments on tags can be frozen or unfrozen by admins with proper
|
|
# authorization.
|
|
# Comments on admin posts can be frozen or unfrozen by any admin.
|
|
def check_permission_to_modify_frozen_status
|
|
return if permission_to_modify_frozen_status
|
|
|
|
# i18n-tasks-use t('comments.freeze.permission_denied')
|
|
# i18n-tasks-use t('comments.unfreeze.permission_denied')
|
|
flash[:error] = t("comments.#{action_name}.permission_denied")
|
|
redirect_back(fallback_location: root_path)
|
|
end
|
|
|
|
def check_permission_to_modify_hidden_status
|
|
return if policy(@comment).can_hide_comment?
|
|
|
|
# i18n-tasks-use t('comments.hide.permission_denied')
|
|
# i18n-tasks-use t('comments.unhide.permission_denied')
|
|
flash[:error] = t("comments.#{action_name}.permission_denied")
|
|
redirect_back(fallback_location: root_path)
|
|
end
|
|
|
|
# Get the thing the user is trying to comment on
|
|
def load_commentable
|
|
@thread_view = false
|
|
if params[:comment_id]
|
|
@thread_view = true
|
|
if params[:id]
|
|
@commentable = Comment.find(params[:id])
|
|
@thread_root = Comment.find(params[:comment_id])
|
|
else
|
|
@commentable = Comment.find(params[:comment_id])
|
|
@thread_root = @commentable
|
|
end
|
|
elsif params[:chapter_id]
|
|
@commentable = Chapter.find(params[:chapter_id])
|
|
elsif params[:work_id]
|
|
@commentable = Work.find(params[:work_id])
|
|
elsif params[:admin_post_id]
|
|
@commentable = AdminPost.find(params[:admin_post_id])
|
|
elsif params[:tag_id]
|
|
@commentable = Tag.find_by_name(params[:tag_id])
|
|
@page_subtitle = @commentable.try(:name)
|
|
end
|
|
end
|
|
|
|
def index
|
|
return raise_not_found if @commentable.blank?
|
|
|
|
return unless @commentable.class == Comment
|
|
|
|
# we link to the parent object at the top
|
|
@commentable = @commentable.ultimate_parent
|
|
end
|
|
|
|
def unreviewed
|
|
@comments = @commentable.find_all_comments
|
|
.unreviewed_only
|
|
.for_display
|
|
.page(params[:page])
|
|
end
|
|
|
|
# GET /comments/1
|
|
# GET /comments/1.xml
|
|
def show
|
|
@comments = CommentDecorator.wrap_comments([@comment])
|
|
@thread_view = true
|
|
@thread_root = @comment
|
|
params[:comment_id] = params[:id]
|
|
end
|
|
|
|
# GET /comments/new
|
|
def new
|
|
if @commentable.nil?
|
|
flash[:error] = ts("What did you want to comment on?")
|
|
redirect_back_or_default(root_path)
|
|
else
|
|
@comment = Comment.new
|
|
@controller_name = params[:controller_name] if params[:controller_name]
|
|
@name =
|
|
case @commentable.class.name
|
|
when /Work/
|
|
@commentable.title
|
|
when /Chapter/
|
|
@commentable.work.title
|
|
when /Tag/
|
|
@commentable.name
|
|
when /AdminPost/
|
|
@commentable.title
|
|
when /Comment/
|
|
ts("Previous Comment")
|
|
else
|
|
@commentable.class.name
|
|
end
|
|
end
|
|
end
|
|
|
|
# GET /comments/1/edit
|
|
def edit
|
|
respond_to do |format|
|
|
format.html
|
|
format.js
|
|
end
|
|
end
|
|
|
|
# POST /comments
|
|
# POST /comments.xml
|
|
def create
|
|
if @commentable.nil?
|
|
flash[:error] = ts("What did you want to comment on?")
|
|
redirect_back_or_default(root_path)
|
|
else
|
|
@comment = Comment.new(comment_params)
|
|
@comment.ip_address = request.remote_ip
|
|
@comment.user_agent = request.env["HTTP_USER_AGENT"]&.to(499)
|
|
@comment.commentable = Comment.commentable_object(@commentable)
|
|
@controller_name = params[:controller_name]
|
|
|
|
# First, try saving the comment
|
|
if @comment.save
|
|
flash[:comment_notice] = if @comment.unreviewed?
|
|
# i18n-tasks-use t("comments.create.success.moderated.admin_post")
|
|
# i18n-tasks-use t("comments.create.success.moderated.work")
|
|
t("comments.create.success.moderated.#{@comment.ultimate_parent.model_name.i18n_key}")
|
|
else
|
|
t("comments.create.success.not_moderated")
|
|
end
|
|
respond_to do |format|
|
|
format.html do
|
|
if request.referer&.match(/inbox/)
|
|
redirect_to user_inbox_path(current_user, filters: filter_params[:filters], page: params[:page])
|
|
elsif request.referer&.match(/new/) || (@comment.unreviewed? && current_user)
|
|
# If the referer is the new comment page, go to the comment's page
|
|
# instead of reloading the full work.
|
|
# If the comment is unreviewed and commenter is logged in, take
|
|
# them to the comment's page so they can access the edit and
|
|
# delete options for the comment, since unreviewed comments don't
|
|
# appear on the commentable.
|
|
redirect_to comment_path(@comment)
|
|
elsif request.referer == root_url
|
|
# replying on the homepage
|
|
redirect_to root_path
|
|
elsif @comment.unreviewed?
|
|
redirect_to_all_comments(@commentable)
|
|
else
|
|
redirect_to_comment(@comment, { view_full_work: (params[:view_full_work] == "true"), page: params[:page] })
|
|
end
|
|
end
|
|
end
|
|
else
|
|
flash[:error] = ts("Couldn't save comment!")
|
|
render action: "new"
|
|
end
|
|
end
|
|
end
|
|
|
|
# PUT /comments/1
|
|
# PUT /comments/1.xml
|
|
def update
|
|
updated_comment_params = comment_params.merge(edited_at: Time.current)
|
|
if @comment.update(updated_comment_params)
|
|
flash[:comment_notice] = ts('Comment was successfully updated.')
|
|
respond_to do |format|
|
|
format.html do
|
|
redirect_to comment_path(@comment) and return if @comment.unreviewed?
|
|
redirect_to_comment(@comment)
|
|
end
|
|
format.js # updating the comment in place
|
|
end
|
|
else
|
|
render action: "edit"
|
|
end
|
|
end
|
|
|
|
# DELETE /comments/1
|
|
# DELETE /comments/1.xml
|
|
def destroy
|
|
authorize @comment if logged_in_as_admin?
|
|
|
|
parent = @comment.ultimate_parent
|
|
parent_comment = @comment.reply_comment? ? @comment.commentable : nil
|
|
unreviewed = @comment.unreviewed?
|
|
|
|
if !@comment.destroy_or_mark_deleted
|
|
# something went wrong?
|
|
flash[:comment_error] = ts("We couldn't delete that comment.")
|
|
redirect_to_comment(@comment)
|
|
elsif unreviewed
|
|
# go back to the rest of the unreviewed comments
|
|
flash[:notice] = ts("Comment deleted.")
|
|
redirect_back(fallback_location: unreviewed_work_comments_path(@comment.commentable))
|
|
elsif parent_comment
|
|
flash[:comment_notice] = ts("Comment deleted.")
|
|
redirect_to_comment(parent_comment)
|
|
else
|
|
flash[:comment_notice] = ts("Comment deleted.")
|
|
redirect_to_all_comments(parent, {show_comments: true})
|
|
end
|
|
end
|
|
|
|
def review
|
|
if logged_in_as_admin?
|
|
authorize @comment
|
|
else
|
|
return unless current_user_owns?(@comment.ultimate_parent)
|
|
end
|
|
|
|
return unless @comment&.unreviewed?
|
|
|
|
@comment.toggle!(:unreviewed)
|
|
# mark associated inbox comments as read
|
|
InboxComment.where(user_id: current_user.id, feedback_comment_id: @comment.id).update_all(read: true) unless logged_in_as_admin?
|
|
flash[:notice] = ts("Comment approved.")
|
|
respond_to do |format|
|
|
format.html do
|
|
if params[:approved_from] == "inbox"
|
|
redirect_to user_inbox_path(current_user, page: params[:page], filters: filter_params[:filters])
|
|
elsif params[:approved_from] == "home"
|
|
redirect_to root_path
|
|
elsif @comment.ultimate_parent.is_a?(AdminPost)
|
|
redirect_to unreviewed_admin_post_comments_path(@comment.ultimate_parent)
|
|
else
|
|
redirect_to unreviewed_work_comments_path(@comment.ultimate_parent)
|
|
end
|
|
return
|
|
end
|
|
format.js
|
|
end
|
|
end
|
|
|
|
def review_all
|
|
authorize @commentable, policy_class: CommentPolicy if logged_in_as_admin?
|
|
unless (@commentable && current_user_owns?(@commentable)) || (@commentable && logged_in_as_admin? && @commentable.is_a?(AdminPost))
|
|
flash[:error] = ts("What did you want to review comments on?")
|
|
redirect_back_or_default(root_path)
|
|
return
|
|
end
|
|
|
|
@comments = @commentable.find_all_comments.unreviewed_only
|
|
@comments.each { |c| c.toggle!(:unreviewed) }
|
|
flash[:notice] = ts("All moderated comments approved.")
|
|
redirect_to @commentable
|
|
end
|
|
|
|
def approve
|
|
authorize @comment
|
|
@comment.mark_as_ham!
|
|
redirect_to_all_comments(@comment.ultimate_parent, show_comments: true)
|
|
end
|
|
|
|
def reject
|
|
authorize @comment if logged_in_as_admin?
|
|
@comment.mark_as_spam!
|
|
redirect_to_all_comments(@comment.ultimate_parent, show_comments: true)
|
|
end
|
|
|
|
# PUT /comments/1/freeze
|
|
def freeze
|
|
# TODO: When AO3-5939 is fixed, we can use
|
|
# comments = @comment.full_set
|
|
if @comment.iced?
|
|
flash[:comment_error] = t(".error")
|
|
else
|
|
comments = @comment.set_to_freeze_or_unfreeze
|
|
Comment.mark_all_frozen!(comments)
|
|
flash[:comment_notice] = t(".success")
|
|
end
|
|
|
|
redirect_to_all_comments(@comment.ultimate_parent, show_comments: true)
|
|
rescue StandardError
|
|
flash[:comment_error] = t(".error")
|
|
redirect_to_all_comments(@comment.ultimate_parent, show_comments: true)
|
|
end
|
|
|
|
# PUT /comments/1/unfreeze
|
|
def unfreeze
|
|
# TODO: When AO3-5939 is fixed, we can use
|
|
# comments = @comment.full_set
|
|
if @comment.iced?
|
|
comments = @comment.set_to_freeze_or_unfreeze
|
|
Comment.mark_all_unfrozen!(comments)
|
|
flash[:comment_notice] = t(".success")
|
|
else
|
|
flash[:comment_error] = t(".error")
|
|
end
|
|
|
|
redirect_to_all_comments(@comment.ultimate_parent, show_comments: true)
|
|
rescue StandardError
|
|
flash[:comment_error] = t(".error")
|
|
redirect_to_all_comments(@comment.ultimate_parent, show_comments: true)
|
|
end
|
|
|
|
# PUT /comments/1/hide
|
|
def hide
|
|
if !@comment.hidden_by_admin?
|
|
@comment.mark_hidden!
|
|
AdminActivity.log_action(current_admin, @comment, action: "hide comment")
|
|
flash[:comment_notice] = t(".success")
|
|
else
|
|
flash[:comment_error] = t(".error")
|
|
end
|
|
redirect_to_all_comments(@comment.ultimate_parent, show_comments: true)
|
|
end
|
|
|
|
# PUT /comments/1/unhide
|
|
def unhide
|
|
if @comment.hidden_by_admin?
|
|
@comment.mark_unhidden!
|
|
AdminActivity.log_action(current_admin, @comment, action: "unhide comment")
|
|
flash[:comment_notice] = t(".success")
|
|
else
|
|
flash[:comment_error] = t(".error")
|
|
end
|
|
redirect_to_all_comments(@comment.ultimate_parent, show_comments: true)
|
|
end
|
|
|
|
def show_comments
|
|
respond_to do |format|
|
|
format.html do
|
|
# if non-ajax it could mean sudden javascript failure OR being redirected from login
|
|
# so we're being extra-nice and preserving any intention to comment along with the show comments option
|
|
options = {show_comments: true}
|
|
options[:add_comment_reply_id] = params[:add_comment_reply_id] if params[:add_comment_reply_id]
|
|
options[:view_full_work] = params[:view_full_work] if params[:view_full_work]
|
|
options[:page] = params[:page]
|
|
redirect_to_all_comments(@commentable, options)
|
|
end
|
|
|
|
format.js do
|
|
@comments = CommentDecorator.for_commentable(@commentable, page: params[:page])
|
|
end
|
|
end
|
|
end
|
|
|
|
def hide_comments
|
|
respond_to do |format|
|
|
format.html do
|
|
redirect_to_all_comments(@commentable)
|
|
end
|
|
format.js
|
|
end
|
|
end
|
|
|
|
# If JavaScript is enabled, use add_comment_reply.js to load the reply form
|
|
# Otherwise, redirect to a comment view with the form already loaded
|
|
def add_comment_reply
|
|
@comment = Comment.new
|
|
respond_to do |format|
|
|
format.html do
|
|
options = {show_comments: true}
|
|
options[:controller] = @commentable.class.to_s.underscore.pluralize
|
|
options[:anchor] = "comment_#{params[:id]}"
|
|
options[:page] = params[:page]
|
|
options[:view_full_work] = params[:view_full_work]
|
|
if @thread_view
|
|
options[:id] = @thread_root
|
|
options[:add_comment_reply_id] = params[:id]
|
|
redirect_to_comment(@commentable, options)
|
|
else
|
|
options[:id] = @commentable.id # work, chapter or other stuff that is not a comment
|
|
options[:add_comment_reply_id] = params[:id]
|
|
redirect_to_all_comments(@commentable, options)
|
|
end
|
|
end
|
|
format.js { @commentable = Comment.find(params[:id]) }
|
|
end
|
|
end
|
|
|
|
def cancel_comment_reply
|
|
respond_to do |format|
|
|
format.html do
|
|
options = {}
|
|
options[:show_comments] = params[:show_comments] if params[:show_comments]
|
|
redirect_to_all_comments(@commentable, options)
|
|
end
|
|
format.js { @commentable = Comment.find(params[:id]) }
|
|
end
|
|
end
|
|
|
|
def cancel_comment_edit
|
|
respond_to do |format|
|
|
format.html { redirect_to_comment(@comment) }
|
|
format.js
|
|
end
|
|
end
|
|
|
|
def delete_comment
|
|
respond_to do |format|
|
|
format.html do
|
|
options = {}
|
|
options[:show_comments] = params[:show_comments] if params[:show_comments]
|
|
options[:delete_comment_id] = params[:id] if params[:id]
|
|
redirect_to_comment(@comment, options) # TO DO: deleting without javascript doesn't work and it never has!
|
|
end
|
|
format.js
|
|
end
|
|
end
|
|
|
|
def cancel_comment_delete
|
|
respond_to do |format|
|
|
format.html do
|
|
options = {}
|
|
options[:show_comments] = params[:show_comments] if params[:show_comments]
|
|
redirect_to_comment(@comment, options)
|
|
end
|
|
format.js
|
|
end
|
|
end
|
|
|
|
protected
|
|
|
|
# redirect to a particular comment in a thread, going into the thread
|
|
# if necessary to display it
|
|
def redirect_to_comment(comment, options = {})
|
|
if comment.depth > ArchiveConfig.COMMENT_THREAD_MAX_DEPTH
|
|
if comment.ultimate_parent.is_a?(Tag)
|
|
default_options = {
|
|
controller: :comments,
|
|
action: :show,
|
|
id: comment.commentable.id,
|
|
tag_id: comment.ultimate_parent.to_param,
|
|
anchor: "comment_#{comment.id}"
|
|
}
|
|
else
|
|
default_options = {
|
|
controller: comment.commentable.class.to_s.underscore.pluralize,
|
|
action: :show,
|
|
id: (comment.commentable.is_a?(Tag) ? comment.commentable.to_param : comment.commentable.id),
|
|
anchor: "comment_#{comment.id}"
|
|
}
|
|
end
|
|
# display the comment's direct parent (and its associated thread)
|
|
redirect_to(url_for(default_options.merge(options)))
|
|
else
|
|
# need to redirect to the specific chapter; redirect_to_all will then retrieve full work view if applicable
|
|
redirect_to_all_comments(comment.parent, options.merge({show_comments: true, anchor: "comment_#{comment.id}"}))
|
|
end
|
|
end
|
|
|
|
def redirect_to_all_comments(commentable, options = {})
|
|
default_options = {anchor: "comments"}
|
|
options = default_options.merge(options)
|
|
|
|
if commentable.is_a?(Tag)
|
|
redirect_to comments_path(tag_id: commentable.to_param,
|
|
add_comment_reply_id: options[:add_comment_reply_id],
|
|
delete_comment_id: options[:delete_comment_id],
|
|
page: options[:page],
|
|
anchor: options[:anchor])
|
|
else
|
|
if commentable.is_a?(Chapter) && (options[:view_full_work] || current_user.try(:preference).try(:view_full_works))
|
|
commentable = commentable.work
|
|
end
|
|
redirect_to polymorphic_path(commentable,
|
|
options.slice(:show_comments,
|
|
:add_comment_reply_id,
|
|
:delete_comment_id,
|
|
:view_full_work,
|
|
:anchor,
|
|
:page))
|
|
end
|
|
end
|
|
|
|
def permission_to_modify_frozen_status
|
|
parent = find_parent
|
|
return true if policy(@comment).can_freeze_comment?
|
|
return true if parent.is_a?(Work) && current_user_owns?(parent)
|
|
|
|
false
|
|
end
|
|
|
|
private
|
|
|
|
def comment_params
|
|
params.require(:comment).permit(
|
|
:pseud_id, :comment_content, :name, :email, :edited_at
|
|
)
|
|
end
|
|
|
|
def filter_params
|
|
params.permit!
|
|
end
|
|
end
|