Skip to content

A platform for community discussion. Free, open, simple.

FIX: Prevent authors from undoing moderation by deleting and undeleting a post

Régis Hanol7c47e8d7fd00
diff --git a/app/jobs/regular/open_topic.rb b/app/jobs/regular/open_topic.rb
index 1be6132aaf2..cc68fc3e555 100644
--- a/app/jobs/regular/open_topic.rb
+++ b/app/jobs/regular/open_topic.rb
@@ -17,7 +17,7 @@ module Jobs
# guards against reopening a topic too early if the topic has
# been auto closed because of reviewables/reports, this will
# just update the existing topic timer and push it down the line
- if topic.auto_close_threshold_reached?
+ if topic.auto_close_threshold_reached? || topic.first_post&.user_deleted?
topic.set_or_create_timer(
TopicTimer.types[:open],
SiteSetting.num_hours_to_close_topic,
diff --git a/lib/post_destroyer.rb b/lib/post_destroyer.rb
index 39553919f1b..fdbefc9166d 100644
--- a/lib/post_destroyer.rb
+++ b/lib/post_destroyer.rb
@@ -5,6 +5,8 @@
# this class contains the logic to delete it.
#
class PostDestroyer
+ TOPIC_CLOSED_BY_AUTHOR_DELETION = "topic_closed_by_author_deletion"
+
def self.destroy_old_hidden_posts
Post
.where(deleted_at: nil, hidden: true)
@@ -281,12 +283,17 @@ class PostDestroyer
force_new_version: true,
deleting_post: true,
skip_validations: true,
+ bypass_slow_mode: true,
)
Post.transaction do
@post.update_column(:user_deleted, true)
@post.topic_links.each(&:destroy)
- @post.topic.update_column(:closed, true) if @post.is_first_post?
+
+ if @post.is_first_post? && @post.topic.open?
+ @post.topic.update_column(:closed, true)
+ @post.upsert_custom_fields(TOPIC_CLOSED_BY_AUTHOR_DELETION => true)
+ end
end
end
end
@@ -297,16 +304,28 @@ class PostDestroyer
Post.transaction do
@post.update_column(:user_deleted, false)
@post.skip_unique_check = true
- @post.topic.update_column(:closed, false) if @post.is_first_post?
+
+ if @post.is_first_post? && @post.custom_fields.delete(TOPIC_CLOSED_BY_AUTHOR_DELETION)
+ @post.topic.update_column(:closed, false)
+ @post.save_custom_fields
+ end
end
# has internal transactions, if we nest then there are some very high risk deadlocks
- last_revision = @post.revisions.last
- if last_revision.present? && last_revision.modifications["raw"].present?
- @post.revise(@user, { raw: last_revision.modifications["raw"][0] }, force_new_version: true)
+ deletion_revision = @post.revisions.where(user_id: @post.user_id).last
+ if deletion_revision&.number == @post.version && deletion_revision.modifications["raw"].present?
+ @post.revise(
+ @user,
+ { raw: deletion_revision.modifications["raw"][0] },
+ force_new_version: true,
+ bypass_slow_mode: true,
+ recovering_post: true,
+ )
end
- restore_reviewables_for_author_recovery if @user.id == @post.user_id
+ if @user.id == @post.user_id
+ restore_reviewables_for_author_recovery(deletion_revision&.created_at)
+ end
end
private
@@ -602,17 +621,23 @@ class PostDestroyer
)
end
- def restore_reviewables_for_author_recovery
- # Only restore if it was reviewed by system user
- reviewables =
- Reviewable
- .where(target: @post, status: Reviewable.statuses[:ignored])
- .joins(
- "LEFT JOIN reviewable_scores ON reviewable_scores.reviewable_id = reviewables.id AND reviewable_scores.reviewed_by_id = #{Discourse::SYSTEM_USER_ID}",
- )
- .where("reviewable_scores.id IS NOT NULL")
+ def restore_reviewables_for_author_recovery(user_deleted_at)
+ reviewables = Reviewable.where(target: @post, status: Reviewable.statuses[:ignored])
reviewables.each do |reviewable|
+ restored_scores =
+ reviewable
+ .reviewable_scores
+ .ignored
+ .where(reviewed_by_id: Discourse::SYSTEM_USER_ID)
+ .where("reviewed_at >= ?", user_deleted_at || @post.created_at)
+ .update_all(
+ status: ReviewableScore.statuses[:pending],
+ reviewed_by_id: nil,
+ reviewed_at: nil,
+ )
+ next if restored_scores.zero?
+
reviewable.reviewable_notes.create!(
user: Discourse.system_user,
content: I18n.t("reviewables.post_restored_by_author"),
diff --git a/lib/post_revisor.rb b/lib/post_revisor.rb
index 9fe7a7210ba..ea4e38f4547 100644
--- a/lib/post_revisor.rb
+++ b/lib/post_revisor.rb
@@ -336,7 +336,7 @@ class PostRevisor
@last_version_at = @post.last_version_at || Time.now
if guardian.affected_by_slow_mode?(@topic) && !grace_period_edit? &&
- SiteSetting.slow_mode_prevents_editing
+ SiteSetting.slow_mode_prevents_editing && !@opts[:bypass_slow_mode]
@post.errors.add(:base, I18n.t("cannot_edit_on_slow_mode"))
return false
end
@@ -677,7 +677,7 @@ class PostRevisor
end
def remove_flags_and_unhide_post
- return if @opts[:deleting_post]
+ return if @opts[:deleting_post] || @opts[:recovering_post]
return unless editing_a_flagged_and_hidden_post?
flaggers = []
diff --git a/spec/jobs/open_topic_spec.rb b/spec/jobs/open_topic_spec.rb
index d49c5a6c21c..b146a13a1cd 100644
--- a/spec/jobs/open_topic_spec.rb
+++ b/spec/jobs/open_topic_spec.rb
@@ -28,6 +28,19 @@ RSpec.describe Jobs::OpenTopic do
end
end
+ it "keeps the topic closed while its author has deleted it" do
+ Fabricate(:post, topic:, user_deleted: true)
+
+ freeze_time(61.minutes.from_now) do
+ described_class.new.execute(topic_timer_id: topic.public_topic_timer.id)
+
+ expect(topic.reload).to be_closed
+ expect(topic.public_topic_timer.execute_at).to eq_time(
+ SiteSetting.num_hours_to_close_topic.hours.from_now,
+ )
+ end
+ end
+
describe "when category has auto close configured" do
fab!(:category) do
Fabricate(:category, auto_close_based_on_last_post: true, auto_close_hours: 5)
diff --git a/spec/lib/post_destroyer_spec.rb b/spec/lib/post_destroyer_spec.rb
index dfe09eaf19a..575a0bb3636 100644
--- a/spec/lib/post_destroyer_spec.rb
+++ b/spec/lib/post_destroyer_spec.rb
@@ -489,15 +489,54 @@ RSpec.describe PostDestroyer do
DiscourseEvent.off(:topic_recovered, &topic_recovered)
end
+ it "blanks and restores the post when the author deletes and undeletes it in a slow mode topic" do
+ reply = create_post(topic: post.topic)
+ original_raw = reply.raw
+ reply.topic.update!(slow_mode_seconds: 1.hour.to_i)
+ freeze_time 1.hour.from_now
+
+ PostDestroyer.new(reply.user, reply).destroy
+
+ expect(reply.reload.raw).to eq(I18n.t("js.post.deleted_by_author_simple"))
+
+ freeze_time 1.hour.from_now
+ PostDestroyer.new(reply.user, reply).recover
+
+ expect(reply.reload.raw).to eq(original_raw)
+ end
+
+ it "keeps a moderator's edit when the author undeletes a post without a deletion revision" do
+ reply = create_post(topic: post.topic)
+ reply.revise(moderator, { raw: "This post was cleaned up by a moderator" })
+ reply.update_column(:user_deleted, true)
+
+ PostDestroyer.new(reply.user, reply).recover
+
+ expect(reply.reload.raw).to eq("This post was cleaned up by a moderator")
+ end
+
it "maintains history when a user destroys a hidden post" do
post.hide!(PostActionType.types[:inappropriate])
PostDestroyer.new(post.user, post).destroy
expect(post.revisions[0].modifications["raw"]).to be_present
end
+ it "keeps a post hidden by flags hidden and flagged when the author deletes and undeletes it" do
+ flag = PostActionCreator.spam(coding_horror, post).post_action
+ post.hide!(PostActionType.types[:spam])
+
+ PostDestroyer.new(post.user, post).destroy
+ PostDestroyer.new(post.user, post).recover
+
+ expect(post.reload).to be_hidden
+ expect(post.flags).to contain_exactly(flag)
+ expect(post.topic).not_to be_visible
+ end
+
it "resolves reviewable when author deletes their flagged post and undeletes" do
reply = create_post(topic: post.topic)
result = PostActionCreator.spam(coding_horror, reply)
+ PostActionCreator.inappropriate(Fabricate(:user, refresh_auto_groups: true), reply)
reviewable = result.reviewable
expect(reviewable).to be_pending
@@ -516,10 +555,12 @@ RSpec.describe PostDestroyer do
PostDestroyer.new(reply.user, reply).recover
expect(reply.reload.user_deleted).to eq(false)
expect(reviewable.reload).to be_pending
-
- recovery_note = reviewable.reviewable_notes.last
- expect(recovery_note.user).to eq(Discourse.system_user)
- expect(recovery_note.content).to eq(I18n.t("reviewables.post_restored_by_author"))
+ expect(reviewable.reviewable_scores).to all(
+ have_attributes(status: "pending", reviewed_by_id: nil, reviewed_at: nil),
+ )
+ expect(reviewable.reviewable_notes.pluck(:user_id, :content)).to eq(
+ [[Discourse.system_user.id, I18n.t("reviewables.post_restored_by_author")]],
+ )
history = reviewable.reviewable_histories.last
expect(history.reviewable_history_type).to eq("transitioned")
@@ -566,6 +607,43 @@ RSpec.describe PostDestroyer do
expect(reviewable.reload).to be_ignored
end
+ it "restores the flags when a moderator edits the post after the author deletes it" do
+ reply = create_post(topic: post.topic)
+ reviewable = PostActionCreator.spam(coding_horror, reply).reviewable
+ PostDestroyer.new(reply.user, reply).destroy
+ freeze_time 1.hour.from_now
+ reply.revise(moderator, { raw: "This post was cleaned up by a moderator" })
+
+ PostDestroyer.new(reply.user, reply.reload).recover
+
+ expect(reviewable.reload).to be_pending
+ expect(reply.raw).to eq("This post was cleaned up by a moderator")
+ end
+
+ it "keeps a reviewable the system ignored before the deletion ignored when the author undeletes" do
+ reply = create_post(topic: post.topic)
+ reviewable = PostActionCreator.spam(coding_horror, reply).reviewable
+ reviewable.perform(Discourse.system_user, :ignore_and_do_nothing)
+
+ freeze_time 1.hour.from_now
+ PostDestroyer.new(reply.user, reply).destroy
+ PostDestroyer.new(reply.user, reply).recover
+
+ expect(reviewable.reload).to be_ignored
+ end
+
+ it "restores a reviewable when the author undeletes a post without revisions" do
+ reply = create_post(topic: post.topic)
+ reviewable = PostActionCreator.spam(coding_horror, reply).reviewable
+ PostDestroyer.new(reply.user, reply).destroy
+ reply.revisions.destroy_all
+
+ PostDestroyer.new(reply.user, reply).recover
+
+ expect(reviewable.reload).to be_pending
+ expect(reviewable.reviewable_scores).to all(be_pending)
+ end
+
it "resolves reviewable when author deletes their post via perform_delete (delete_removed_posts_after = 0)" do
SiteSetting.delete_removed_posts_after = 0
@@ -777,6 +855,20 @@ RSpec.describe PostDestroyer do
expect(post.topic.closed).to eq(true)
end
+ it "reopens only the topic closed by the author deletion when the author undeletes it" do
+ PostDestroyer.new(post.user, post).destroy
+ PostDestroyer.new(post.user, post.reload).recover
+
+ expect(post.topic.reload).to be_open
+
+ post.topic.update_status("closed", true, moderator)
+
+ PostDestroyer.new(post.user, post.reload).destroy
+ PostDestroyer.new(post.user, post.reload).recover
+
+ expect(post.topic.reload).to be_closed
+ end
+
context "as a moderator" do
it "deletes the post" do
author = post.user
diff --git a/spec/lib/post_revisor_spec.rb b/spec/lib/post_revisor_spec.rb
index f589f6d3616..f75b35a5b26 100644
--- a/spec/lib/post_revisor_spec.rb
+++ b/spec/lib/post_revisor_spec.rb
@@ -582,6 +582,17 @@ describe PostRevisor do
post.reload
expect(post.errors).to be_empty
end
+
+ it "edits bypassing slow mode are allowed" do
+ post_revisor.revise!(
+ post.user,
+ { raw: "updated body" },
+ revised_at: post.updated_at + 1000.minutes,
+ bypass_slow_mode: true,
+ )
+
+ expect(post.reload.raw).to eq("updated body")
+ end
end
describe "grace period editing" do