A platform for community discussion. Free, open, simple.
DEV: Apply review queue penalties before resolving reviewables (#44405)
Alan Guo Xiang Tanfe97c2951fdc
diff --git a/app/models/concerns/reviewable_action_builder.rb b/app/models/concerns/reviewable_action_builder.rbindex c61b339c512..71130db881a 100644--- a/app/models/concerns/reviewable_action_builder.rb+++ b/app/models/concerns/reviewable_action_builder.rb@@ -3,6 +3,20 @@module ReviewableActionBuilderextend ActiveSupport::Concern+ class << self+ def penalty_args(params)+ {+ reason: params[:reason],+ message: params[:message],+ suspend_until: params[:suspend_until],+ silenced_till: params[:silenced_till],+ post_action: params[:post_action],+ post_edit: params[:post_edit],+ other_user_ids: params[:other_user_ids],+ }+ end+ end+attr_accessor :actions, :guardian, :action_argsdef build_actions(actions, guardian, args)@@ -78,14 +92,6 @@ module ReviewableActionBuilderendend- def perform_silence_user(performed_by, args)- create_result(:success, :rejected)- end-- def perform_suspend_user(performed_by, args)- create_result(:success, :rejected)- end-def perform_delete_user(performed_by, args, &)delete_user(target_user, delete_opts, performed_by) if target_usercreate_result(:success, :rejected, [], false, &)@@ -125,8 +131,40 @@ module ReviewableActionBuildercreate_result(:success, :approved, [created_by_id], false)end+ def suspend_user(performed_by:, args:)+ perform_penalty(performed_by:, args:, penalty_type: "suspend")+ end++ def silence_user(performed_by:, args:)+ perform_penalty(performed_by:, args:, penalty_type: "silence")+ end+private+ def perform_penalty(performed_by:, args:, penalty_type:)+ guardian = args[:guardian] || Guardian.new(performed_by)+ service = penalty_type == "suspend" ? User::Suspend : User::Silence+ result = create_result(:failure)+ result.errors = ActiveModel::Errors.new(self)+ penalty_params =+ args.merge(+ user_id: target_user&.id,+ post_id: target_type == "Post" ? target_id : target.try(:post_id),+ reviewable_id: id,+ )++ service.call(guardian:, params: penalty_params, options: { raise_on_failure: true }) do+ on_success { result = create_result(:success) }+ on_failed_contract { |contract| result.errors = contract.errors }+ on_model_not_found(:user) { raise Discourse::NotFound }+ on_failed_policy(:can_suspend_all_users) { raise Discourse::InvalidAccess }+ on_failed_policy(:can_silence_all_users) { raise Discourse::InvalidAccess }+ on_failed_policy(:not_suspended_already) { |policy| result.errors.add(:base, policy.reason) }+ on_failed_policy(:not_silenced_already) { |policy| result.errors.add(:base, policy.reason) }+ end+ result+ end+# Options for deleting a user, used by perform_delete_user and perform_delete_and_block_user.def delete_opts{diff --git a/app/models/reviewable_flagged_post.rb b/app/models/reviewable_flagged_post.rbindex c4900f1c290..a3470292b42 100644--- a/app/models/reviewable_flagged_post.rb+++ b/app/models/reviewable_flagged_post.rb@@ -3,15 +3,16 @@class ReviewableFlaggedPost < Reviewableinclude ReviewableActionBuilder+ def self.additional_args(params)+ ReviewableActionBuilder.penalty_args(params)+ end+scope :pending_and_default_visible, -> { pending.default_visible }- # Penalties are handled by the modal after the action is performeddef self.action_aliases{agree_and_keep_hidden: :agree_and_keep,agree_and_keep_deleted: :agree_and_keep,- agree_and_silence: :agree_and_keep,- agree_and_suspend: :agree_and_keep,agree_and_edit: :agree_and_keep,disagree_and_restore: :disagree,disagree_and_keep_deleted: :disagree,@@ -250,6 +251,20 @@ class ReviewableFlaggedPost < Reviewablecreate_result(:success, :ignored, actions.map(&:user_id), false)end+ def perform_agree_and_suspend(performed_by, args)+ result = suspend_user(performed_by:, args:)+ return result unless result.success?++ perform_agree_and_keep(performed_by, args)+ end++ def perform_agree_and_silence(performed_by, args)+ result = silence_user(performed_by:, args:)+ return result unless result.success?++ perform_agree_and_keep(performed_by, args)+ end+def perform_agree_and_keep(performed_by, args)agree(performed_by, args)enddiff --git a/app/models/reviewable_post.rb b/app/models/reviewable_post.rbindex eb909efbc87..a6fdb7dabd3 100644--- a/app/models/reviewable_post.rb+++ b/app/models/reviewable_post.rb@@ -3,6 +3,10 @@class ReviewablePost < Reviewableinclude ReviewableActionBuilder+ def self.additional_args(params)+ ReviewableActionBuilder.penalty_args(params)+ end+def self.queue_for_review_if_possible(post, created_or_edited_by)return unless SiteSetting.review_every_postreturn if post.post_type != Post.types[:regular] || post.topic.private_message?@@ -106,11 +110,17 @@ class ReviewablePost < Reviewablecreate_result(:success, :rejected, [created_by_id], false)end- def perform_reject_and_suspend(performed_by, _args)+ def perform_reject_and_suspend(performed_by, args)+ result = suspend_user(performed_by:, args:)+ return result unless result.success?+create_result(:success, :rejected, [created_by_id], false)end- def perform_reject_and_silence(performed_by, _args)+ def perform_reject_and_silence(performed_by, args)+ result = silence_user(performed_by:, args:)+ return result unless result.success?+create_result(:success, :rejected, [created_by_id], false)enddiff --git a/app/models/reviewable_queued_post.rb b/app/models/reviewable_queued_post.rbindex 5b909eea44d..9abf39ee0c7 100644--- a/app/models/reviewable_queued_post.rb+++ b/app/models/reviewable_queued_post.rb@@ -4,12 +4,7 @@ class ReviewableQueuedPost < Reviewableinclude ReviewableActionBuilderdef self.action_aliases- {- discard_post: :reject_post,- reject_and_silence: :reject_post,- reject_and_suspend: :reject_post,- delete_user_block: :delete_and_block_user,- }+ { discard_post: :reject_post, delete_user_block: :delete_and_block_user }endafter_create do@@ -27,13 +22,14 @@ class ReviewableQueuedPost < Reviewableafter_commit :compute_user_stats, only: %i[create update]def self.additional_args(params)- return {} if params[:revise_reason].blank?+ args = ReviewableActionBuilder.penalty_args(params)+ return args if params[:revise_reason].blank?- {+ args.merge(revise_reason: params[:revise_reason],revise_feedback: params[:revise_feedback],revise_custom_reason: params[:revise_custom_reason],- }+ )enddef build_combined_actions(actions, guardian, args)@@ -155,6 +151,20 @@ class ReviewableQueuedPost < Reviewableperform_approve_post(performed_by, args)end+ def perform_reject_and_suspend(performed_by, args)+ result = suspend_user(performed_by:, args:)+ return result unless result.success?++ perform_reject_post(performed_by, args)+ end++ def perform_reject_and_silence(performed_by, args)+ result = silence_user(performed_by:, args:)+ return result unless result.success?++ perform_reject_post(performed_by, args)+ end+def perform_reject_post(performed_by, args)# Backwards compatibility, new code should listen for `reviewable_transitioned_to`DiscourseEvent.trigger(:rejected_post, self)diff --git a/app/models/reviewable_user.rb b/app/models/reviewable_user.rbindex 1bfcc3b3390..21851b9458d 100644--- a/app/models/reviewable_user.rb+++ b/app/models/reviewable_user.rb@@ -30,7 +30,10 @@ class ReviewableUser < Reviewableenddef self.additional_args(params)- { reject_reason: params[:reject_reason], send_email: params[:send_email] != "false" }+ ReviewableActionBuilder.penalty_args(params).merge(+ reject_reason: params[:reject_reason],+ send_email: params[:send_email] != "false",+ )enddef build_combined_actions(actions, guardian, args)@@ -89,6 +92,20 @@ class ReviewableUser < Reviewablecreate_result(:success)end+ def perform_silence_user(performed_by, args)+ result = silence_user(performed_by:, args:)+ return result unless result.success?++ create_result(:success, :rejected)+ end++ def perform_suspend_user(performed_by, args)+ result = suspend_user(performed_by:, args:)+ return result unless result.success?++ create_result(:success, :rejected)+ end+def perform_approve_user(performed_by, args)ReviewableUser.set_approved_fields!(target, performed_by)target.save!diff --git a/app/services/user/action/silence_all.rb b/app/services/user/action/silence_all.rbindex b619829001b..d493ed6cb4e 100644--- a/app/services/user/action/silence_all.rb+++ b/app/services/user/action/silence_all.rb@@ -4,6 +4,7 @@ class User::Action::SilenceAll < Service::ActionBaseoption :users, []option :actoroption :params+ option :raise_on_failure, default: -> { false }delegate :message, :post_id, :silenced_till, :reason, :reviewable_id, to: :params, private: true@@ -15,6 +16,8 @@ class User::Action::SilenceAll < Service::ActionBasedef silenced_usersusers.map do |user|+ next if raise_on_failure && user.silenced?+UserSilencer.new(user,@@ -27,7 +30,10 @@ class User::Action::SilenceAll < Service::ActionBasereviewable_id:,).tap do |silencer|- next unless silencer.silence+ unless silencer.silence+ raise ActiveRecord::RecordInvalid.new(user) if raise_on_failure+ next+ endJobs.enqueue(:critical_user_email,type: "account_silenced",@@ -36,6 +42,7 @@ class User::Action::SilenceAll < Service::ActionBase)endrescue => err+ raise if raise_on_failureDiscourse.warn_exception(err, message: "failed to silence user with ID #{user.id}")endenddiff --git a/app/services/user/action/suspend_all.rb b/app/services/user/action/suspend_all.rbindex 72da2717c8f..5addd6ffac0 100644--- a/app/services/user/action/suspend_all.rb+++ b/app/services/user/action/suspend_all.rb@@ -4,6 +4,7 @@ class User::Action::SuspendAll < Service::ActionBaseoption :users, []option :actoroption :params+ option :raise_on_failure, default: -> { false }delegate :message, :post_id, :suspend_until, :reason, :reviewable_id, to: :params, private: true@@ -25,6 +26,7 @@ class User::Action::SuspendAll < Service::ActionBasereviewable_id: reviewable_id,).tap(&:suspend)rescue => err+ raise if raise_on_failureDiscourse.warn_exception(err, message: "failed to suspend user with ID #{user.id}")endenddiff --git a/app/services/user/action/trigger_post_action.rb b/app/services/user/action/trigger_post_action.rbindex 934f26108ad..147334b7e51 100644--- a/app/services/user/action/trigger_post_action.rb+++ b/app/services/user/action/trigger_post_action.rb@@ -4,29 +4,35 @@ class User::Action::TriggerPostAction < Service::ActionBaseoption :guardianoption :postoption :params+ option :raise_on_failure, default: -> { false }delegate :post_action, :reviewable_id, to: :params, private: truedelegate :user, to: :guardian, private: truedef call- return if post.blank? || post_action.blank? || post_action == "none"+ return if post.blank? || post_action.blank? || %w[none delete_all].include?(post_action)send(post_action)rescue NoMethodError+ raise if raise_on_failureendprivatedef delete+ guardian.ensure_can_delete_post_or_topic!(post) if raise_on_failurereturn unless guardian.can_delete_post_or_topic?(post)PostDestroyer.new(user, post, reviewable_id: reviewable_id).destroy+ raise Discourse::InvalidParameters.new(:post_action) if raise_on_failure && !post.trashed?enddef delete_replies+ guardian.ensure_can_delete_post_or_topic!(post) if raise_on_failurereturn unless guardian.can_delete_post_or_topic?(post)PostDestroyer.delete_with_replies(user, post, reviewable_id)enddef edit+ guardian.ensure_can_edit_post!(post) if raise_on_failurereturn unless guardian.can_edit_post?(post)# Take what the moderator edited in as gospelPostRevisor.new(post).revise!(@@ -35,5 +41,9 @@ class User::Action::TriggerPostAction < Service::ActionBaseskip_validations: true,skip_revision: true,)+ if raise_on_failure+ raise ActiveRecord::RecordInvalid.new(post) if post.errors.present?+ raise ActiveRecord::RecordInvalid.new(post.topic) if post.topic.errors.present?+ endendenddiff --git a/app/services/user/silence.rb b/app/services/user/silence.rbindex 3658ce290dc..2b05bf092c1 100644--- a/app/services/user/silence.rb+++ b/app/services/user/silence.rb@@ -25,6 +25,8 @@ class User::Silenceallow_blank: trueend+ options { attribute :raise_on_failure, :boolean, default: false }+model :userpolicy :not_silenced_already, class_name: User::Policy::NotAlreadySilencedmodel :users@@ -47,15 +49,25 @@ class User::Silenceusers.all? { guardian.can_silence_user?(it) }end- def silence(guardian:, users:, params:)- context[:full_reason] = User::Action::SilenceAll.call(users:, actor: guardian.user, params:)+ def silence(guardian:, users:, params:, options:)+ context[:full_reason] = User::Action::SilenceAll.call(+ users:,+ actor: guardian.user,+ params:,+ raise_on_failure: options.raise_on_failure,+ )enddef fetch_post(params:)Post.find_by(id: params.post_id)end- def perform_post_action(guardian:, post:, params:)- User::Action::TriggerPostAction.call(guardian:, post:, params:)+ def perform_post_action(guardian:, post:, params:, options:)+ User::Action::TriggerPostAction.call(+ guardian:,+ post:,+ params:,+ raise_on_failure: options.raise_on_failure,+ )endenddiff --git a/app/services/user/suspend.rb b/app/services/user/suspend.rbindex 0bc69dd1757..719632e2cb5 100644--- a/app/services/user/suspend.rb+++ b/app/services/user/suspend.rb@@ -25,6 +25,8 @@ class User::Suspendallow_blank: trueend+ options { attribute :raise_on_failure, :boolean, default: false }+model :userpolicy :not_suspended_already, class_name: User::Policy::NotAlreadySuspendedmodel :users@@ -47,15 +49,25 @@ class User::Suspendusers.all? { guardian.can_suspend?(it) }end- def suspend(guardian:, users:, params:)- context[:full_reason] = User::Action::SuspendAll.call(users:, actor: guardian.user, params:)+ def suspend(guardian:, users:, params:, options:)+ context[:full_reason] = User::Action::SuspendAll.call(+ users:,+ actor: guardian.user,+ params:,+ raise_on_failure: options.raise_on_failure,+ )enddef fetch_post(params:)Post.find_by(id: params.post_id)end- def perform_post_action(guardian:, post:, params:)- User::Action::TriggerPostAction.call(guardian:, post:, params:)+ def perform_post_action(guardian:, post:, params:, options:)+ User::Action::TriggerPostAction.call(+ guardian:,+ post:,+ params:,+ raise_on_failure: options.raise_on_failure,+ )endenddiff --git a/app/services/user_silencer.rb b/app/services/user_silencer.rbindex 4b1d8f6053a..58c2f679d4e 100644--- a/app/services/user_silencer.rb+++ b/app/services/user_silencer.rb@@ -28,7 +28,7 @@ class UserSilencerdef silencereturn false if @user.staff?hide_posts unless @opts[:keep_posts]- return false if @user.silenced_till.present?+ return false if @user.silenced?@user.silenced_till = @opts[:silenced_till] || 1000.years.from_nowif @user.savemessage_type = @opts[:message] || :silenced_by_staffdiff --git a/frontend/discourse/admin/components/admin-penalty-reason.gjs b/frontend/discourse/admin/components/admin-penalty-reason.gjsindex abc5094de37..cbba62fefee 100644--- a/frontend/discourse/admin/components/admin-penalty-reason.gjs+++ b/frontend/discourse/admin/components/admin-penalty-reason.gjs@@ -75,7 +75,7 @@ export default class AdminPenaltyReason extends Component {{{#if this.isCustomReason}}<DTextFieldclass="suspend-reason"- @onChange={{this.setCustomReason}}+ @onChangeImmediate={{this.setCustomReason}}@value={{this.customReason}}/>{{/if}}@@ -93,7 +93,7 @@ export default class AdminPenaltyReason extends Component {{{#if this.isCustomReason}}<DTextFieldclass="silence-reason"- @onChange={{this.setCustomReason}}+ @onChangeImmediate={{this.setCustomReason}}@placeholderKey="admin.user.silence_reason_placeholder"@value={{this.customReason}}/>diff --git a/frontend/discourse/admin/components/modal/penalize-user.gjs b/frontend/discourse/admin/components/modal/penalize-user.gjsindex c608decdb73..3c40ad306dc 100644--- a/frontend/discourse/admin/components/modal/penalize-user.gjs+++ b/frontend/discourse/admin/components/modal/penalize-user.gjs@@ -109,10 +109,14 @@ export default class PenalizeUser extends Component {if (this.args.model.penaltyType === "suspend") {opts.suspend_until = this.penalizeUntil;- result = await this.args.model.user.suspend(opts);+ result = await (this.args.model.perform+ ? this.args.model.perform(opts)+ : this.args.model.user.suspend(opts));} else if (this.args.model.penaltyType === "silence") {opts.silenced_till = this.penalizeUntil;- result = await this.args.model.user.silence(opts);+ result = await (this.args.model.perform+ ? this.args.model.perform(opts)+ : this.args.model.user.silence(opts));} else {// eslint-disable-next-line no-consoleconsole.error("Unknown penalty type:", this.args.model.penaltyType);diff --git a/frontend/discourse/admin/services/admin-tools.js b/frontend/discourse/admin/services/admin-tools.jsindex 1750af337c8..25659363230 100644--- a/frontend/discourse/admin/services/admin-tools.js+++ b/frontend/discourse/admin/services/admin-tools.js@@ -118,6 +118,7 @@ export default class AdminToolsService extends Service {reviewableId: opts.reviewableId,user: loadedUser,before: opts.before,+ perform: opts.perform,successCallback: async (result) => {if (originalSuccessCallback) {await originalSuccessCallback(result);diff --git a/frontend/discourse/app/components/reviewable/item.gjs b/frontend/discourse/app/components/reviewable/item.gjsindex 36ae2ea928c..745ecc15fcc 100644--- a/frontend/discourse/app/components/reviewable/item.gjs+++ b/frontend/discourse/app/components/reviewable/item.gjs@@ -616,7 +616,7 @@ export default class ReviewableItem extends Component {async _performConfirmed(performableAction, additionalData = {}) {let reviewable = this.args.reviewable;- let performAction = async () => {+ let performAction = async (actionData = {}) => {this.disabled = true;let version = reviewable.version;@@ -626,6 +626,7 @@ export default class ReviewableItem extends Component {send_email: reviewable.sendEmail,reject_reason: reviewable.rejectReason,...additionalData,+ ...actionData,};(pluginReviewableParams[reviewable.type] || []).forEach((param) => {@@ -716,7 +717,7 @@ export default class ReviewableItem extends Component {postId: reviewable.post_id,postEdit: reviewable.raw ?? reviewable.payload?.raw,reviewableId: reviewable.id,- before: performAction,+ perform: performAction,});}diff --git a/plugins/chat/app/models/chat/reviewable_message.rb b/plugins/chat/app/models/chat/reviewable_message.rbindex 9e02edce09e..4138c116137 100644--- a/plugins/chat/app/models/chat/reviewable_message.rb+++ b/plugins/chat/app/models/chat/reviewable_message.rb@@ -4,6 +4,10 @@ module Chatclass ReviewableMessage < Reviewableinclude ReviewableActionBuilder+ def self.additional_args(params)+ ReviewableActionBuilder.penalty_args(params)+ end+validates :type, length: { maximum: 100 }validates :target_type, length: { maximum: 100 }@@ -17,12 +21,7 @@ module Chatenddef self.action_aliases- {- agree_and_keep_hidden: :agree_and_delete,- agree_and_silence: :agree_and_delete,- agree_and_suspend: :agree_and_delete,- delete_and_agree: :agree_and_delete,- }+ { agree_and_keep_hidden: :agree_and_delete, delete_and_agree: :agree_and_delete }enddef self.score_to_silence_user@@ -141,6 +140,20 @@ module Chatagree { chat_message.recover! }end+ def perform_agree_and_suspend(performed_by, args)+ result = suspend_user(performed_by:, args:)+ return result unless result.success?++ perform_agree_and_delete(performed_by, args)+ end++ def perform_agree_and_silence(performed_by, args)+ result = silence_user(performed_by:, args:)+ return result unless result.success?++ perform_agree_and_delete(performed_by, args)+ end+def perform_agree_and_delete(performed_by, args)agree { chat_message.trash!(performed_by) }enddiff --git a/plugins/chat/spec/models/chat/reviewable_chat_message_spec.rb b/plugins/chat/spec/models/chat/reviewable_chat_message_spec.rbindex 0701b322030..f81093e78d2 100644--- a/plugins/chat/spec/models/chat/reviewable_chat_message_spec.rb+++ b/plugins/chat/spec/models/chat/reviewable_chat_message_spec.rb@@ -29,6 +29,36 @@ RSpec.describe Chat::ReviewableMessage, type: :model doexpect(notification.url).to eq("/review/#{reviewable.id}")end+ describe "#perform" do+ it "suspends the author and deletes the flagged message" do+ reviewable.update!(target_created_by: user)++ result =+ reviewable.perform(+ moderator,+ :agree_and_suspend,+ reason: "spam",+ suspend_until: 2.days.from_now,+ )++ expect(result).to be_success+ expect(user.reload).to be_suspended+ expect(chat_message.reload.deleted_at).to be_present+ expect(reviewable.reload).to be_approved+ end++ it "keeps the content and reviewable unchanged when silence details are invalid" do+ reviewable.update!(target_created_by: user)++ result = reviewable.perform(moderator, :agree_and_silence, reason: "spam")++ expect(result).not_to be_success+ expect(user.reload).not_to be_silenced+ expect(chat_message.reload.deleted_at).to be_nil+ expect(reviewable.reload).to be_pending+ end+ end+it "agree_and_keep agrees with the flag and doesn't delete the message" doreviewable.perform(moderator, :agree_and_keep_message)diff --git a/plugins/discourse-ai/app/models/reviewable_ai_chat_message.rb b/plugins/discourse-ai/app/models/reviewable_ai_chat_message.rbindex d764be990e4..eae77e6f14d 100644--- a/plugins/discourse-ai/app/models/reviewable_ai_chat_message.rb+++ b/plugins/discourse-ai/app/models/reviewable_ai_chat_message.rb@@ -3,13 +3,14 @@require_dependency "reviewable"class ReviewableAiChatMessage < Reviewable+ include ReviewableActionBuilder++ def self.additional_args(params)+ ReviewableActionBuilder.penalty_args(params)+ end+def self.action_aliases- {- agree_and_keep_hidden: :agree_and_delete,- agree_and_silence: :agree_and_delete,- agree_and_suspend: :agree_and_delete,- delete_and_agree: :agree_and_delete,- }+ { agree_and_keep_hidden: :agree_and_delete, delete_and_agree: :agree_and_delete }enddef self.score_to_silence_user@@ -93,6 +94,20 @@ class ReviewableAiChatMessage < Reviewableagree { chat_message.recover! }end+ def perform_agree_and_suspend(performed_by, args)+ result = suspend_user(performed_by:, args:)+ return result unless result.success?++ perform_agree_and_delete(performed_by, args)+ end++ def perform_agree_and_silence(performed_by, args)+ result = silence_user(performed_by:, args:)+ return result unless result.success?++ perform_agree_and_delete(performed_by, args)+ end+def perform_agree_and_delete(performed_by, args)agree { chat_message.trash!(performed_by) }enddiff --git a/plugins/discourse-ai/app/models/reviewable_ai_post.rb b/plugins/discourse-ai/app/models/reviewable_ai_post.rbindex 1c00989e598..79dac04706e 100644--- a/plugins/discourse-ai/app/models/reviewable_ai_post.rb+++ b/plugins/discourse-ai/app/models/reviewable_ai_post.rb@@ -3,14 +3,14 @@require_dependency "reviewable"class ReviewableAiPost < Reviewable- # Penalties are handled by the modal after the action is performed+ include ReviewableActionBuilder++ def self.additional_args(params)+ ReviewableActionBuilder.penalty_args(params)+ end+def self.action_aliases- {- agree_and_keep_hidden: :agree_and_keep,- agree_and_silence: :agree_and_keep,- agree_and_suspend: :agree_and_keep,- disagree_and_restore: :disagree,- }+ { agree_and_keep_hidden: :agree_and_keep, disagree_and_restore: :disagree }enddef build_actions(actions, guardian, args)@@ -98,6 +98,20 @@ class ReviewableAiPost < Reviewableagreeend+ def perform_agree_and_suspend(performed_by, args)+ result = suspend_user(performed_by:, args:)+ return result unless result.success?++ perform_agree_and_keep(performed_by, args)+ end++ def perform_agree_and_silence(performed_by, args)+ result = silence_user(performed_by:, args:)+ return result unless result.success?++ perform_agree_and_keep(performed_by, args)+ end+def perform_agree_and_keep(_performed_by, _args)agreeenddiff --git a/plugins/discourse-ai/spec/models/reviewable_ai_chat_message_spec.rb b/plugins/discourse-ai/spec/models/reviewable_ai_chat_message_spec.rbindex 57e38f1e04e..b1c2da48d2b 100644--- a/plugins/discourse-ai/spec/models/reviewable_ai_chat_message_spec.rb+++ b/plugins/discourse-ai/spec/models/reviewable_ai_chat_message_spec.rb@@ -9,6 +9,36 @@ RSpec.describe ReviewableAiChatMessage, type: :model dobefore { enable_current_plugin }+ describe "#perform" do+ it "suspends the author and deletes the flagged message" do+ reviewable.update!(target_created_by: user)++ result =+ reviewable.perform(+ moderator,+ :agree_and_suspend,+ reason: "spam",+ suspend_until: 2.days.from_now,+ )++ expect(result).to be_success+ expect(user.reload).to be_suspended+ expect(chat_message.reload.deleted_at).to be_present+ expect(reviewable.reload).to be_approved+ end++ it "keeps the content and reviewable unchanged when silence details are invalid" do+ reviewable.update!(target_created_by: user)++ result = reviewable.perform(moderator, :agree_and_silence, reason: "spam")++ expect(result).not_to be_success+ expect(user.reload).not_to be_silenced+ expect(chat_message.reload.deleted_at).to be_nil+ expect(reviewable.reload).to be_pending+ end+ end+it "agree_and_keep agrees with the flag and doesn't delete the message" doreviewable.perform(moderator, :agree_and_keep_message)diff --git a/plugins/discourse-ai/spec/models/reviewable_ai_post_spec.rb b/plugins/discourse-ai/spec/models/reviewable_ai_post_spec.rbindex c8f31290a0f..aa89d1acc11 100644--- a/plugins/discourse-ai/spec/models/reviewable_ai_post_spec.rb+++ b/plugins/discourse-ai/spec/models/reviewable_ai_post_spec.rb@@ -136,6 +136,30 @@ describe ReviewableAiPost do)end+ it "suspends the author and approves the AI flag without hiding the post" do+ result =+ reviewable.perform(+ admin,+ :agree_and_suspend,+ reason: "spam",+ suspend_until: 2.days.from_now,+ )++ expect(result).to be_success+ expect(target.user.reload).to be_suspended+ expect(target.reload).not_to be_hidden+ expect(reviewable.reload).to be_approved+ end++ it "keeps the AI flag pending when suspension details are invalid" do+ result =+ reviewable.perform(admin, :agree_and_suspend, reason: "", suspend_until: 2.days.from_now)++ expect(result).not_to be_success+ expect(reviewable.reload).to be_pending+ expect(target.user.reload).not_to be_suspended+ end+describe "agree variations" doit "hides the topic when performing the agree_and_hide action" doresult = reviewable.perform(admin, :agree_and_hide)diff --git a/plugins/discourse-post-voting/app/models/reviewable_post_voting_comment.rb b/plugins/discourse-post-voting/app/models/reviewable_post_voting_comment.rbindex f2b1a2b86db..98f23ed2f32 100644--- a/plugins/discourse-post-voting/app/models/reviewable_post_voting_comment.rb+++ b/plugins/discourse-post-voting/app/models/reviewable_post_voting_comment.rb@@ -3,17 +3,16 @@class ReviewablePostVotingComment < Reviewableinclude ReviewableActionBuilder+ def self.additional_args(params)+ ReviewableActionBuilder.penalty_args(params)+ end+def serializerReviewablePostVotingCommentSerializerenddef self.action_aliases- {- agree_and_keep_hidden: :agree_and_delete,- agree_and_silence: :agree_and_delete,- agree_and_suspend: :agree_and_delete,- delete_and_agree: :agree_and_delete,- }+ { agree_and_keep_hidden: :agree_and_delete, delete_and_agree: :agree_and_delete }enddef flagged_by_user_ids@@ -92,6 +91,20 @@ class ReviewablePostVotingComment < Reviewableagree { comment.recover! }end+ def perform_agree_and_suspend(performed_by, args)+ result = suspend_user(performed_by:, args:)+ return result unless result.success?++ perform_agree_and_delete(performed_by, args)+ end++ def perform_agree_and_silence(performed_by, args)+ result = silence_user(performed_by:, args:)+ return result unless result.success?++ perform_agree_and_delete(performed_by, args)+ end+def perform_agree_and_delete(performed_by, args)agree { comment.trash!(performed_by) }enddiff --git a/plugins/discourse-post-voting/spec/models/reviewable_post_voting_comment_spec.rb b/plugins/discourse-post-voting/spec/models/reviewable_post_voting_comment_spec.rbindex 3ae5ecb9222..6dfc8f6c6e2 100644--- a/plugins/discourse-post-voting/spec/models/reviewable_post_voting_comment_spec.rb+++ b/plugins/discourse-post-voting/spec/models/reviewable_post_voting_comment_spec.rb@@ -23,6 +23,36 @@ RSpec.describe ReviewablePostVotingComment, type: :model doendend+ describe "#perform" do+ it "suspends the author and deletes the flagged comment" do+ reviewable.update!(target_created_by: comment_poster)++ result =+ reviewable.perform(+ moderator,+ :agree_and_suspend,+ reason: "spam",+ suspend_until: 2.days.from_now,+ )++ expect(result).to be_success+ expect(comment_poster.reload).to be_suspended+ expect(comment.reload.deleted_at).to be_present+ expect(reviewable.reload).to be_approved+ end++ it "keeps the content and reviewable unchanged when silence details are invalid" do+ reviewable.update!(target_created_by: comment_poster)++ result = reviewable.perform(moderator, :agree_and_silence, reason: "spam")++ expect(result).not_to be_success+ expect(comment_poster.reload).not_to be_silenced+ expect(comment.reload.deleted_at).to be_nil+ expect(reviewable.reload).to be_pending+ end+ end+it "agree_and_keep agrees with the flag and doesn't delete the comment" doreviewable.perform(moderator, :agree_and_keep_comment)diff --git a/plugins/voice/app/models/reviewable_voice_user.rb b/plugins/voice/app/models/reviewable_voice_user.rbindex 65c5b045169..f75adc8330b 100644--- a/plugins/voice/app/models/reviewable_voice_user.rb+++ b/plugins/voice/app/models/reviewable_voice_user.rb@@ -3,12 +3,12 @@class ReviewableVoiceUser < Reviewableinclude ReviewableActionBuilder- def serializer- ReviewableVoiceUserSerializer+ def self.additional_args(params)+ ReviewableActionBuilder.penalty_args(params)end- def self.action_aliases- { agree_and_suspend: :agree_and_keep, agree_and_silence: :agree_and_keep }+ def serializer+ ReviewableVoiceUserSerializerenddef session@@ -52,6 +52,20 @@ class ReviewableVoiceUser < Reviewablebuild_action(actions, :ignore, icon: "xmark")end+ def perform_agree_and_suspend(performed_by, args)+ result = suspend_user(performed_by:, args:)+ return result unless result.success?++ perform_agree_and_keep(performed_by, args)+ end++ def perform_agree_and_silence(performed_by, args)+ result = silence_user(performed_by:, args:)+ return result unless result.success?++ perform_agree_and_keep(performed_by, args)+ end+def perform_agree_and_keep(_performed_by, _args)create_result(:success, :approved) do |result|result.update_flag_stats = { status: :agreed, user_ids: flagged_by_user_ids }diff --git a/plugins/voice/spec/models/reviewable_voice_user_spec.rb b/plugins/voice/spec/models/reviewable_voice_user_spec.rbindex 44eef886df2..86b69df2509 100644--- a/plugins/voice/spec/models/reviewable_voice_user_spec.rb+++ b/plugins/voice/spec/models/reviewable_voice_user_spec.rb@@ -52,6 +52,45 @@ RSpec.describe ReviewableVoiceUser doenddescribe "#perform" do+ it "suspends the user and agrees with the flag" do+ result =+ reviewable.perform(+ moderator,+ :agree_and_suspend,+ reason: "Disruptive behavior",+ suspend_until: 2.days.from_now,+ )++ expect(result).to be_success+ expect(flagged_user.reload).to be_suspended+ expect(reviewable.reload).to be_approved+ expect(reviewable.reviewable_scores.first).to be_agreed+ end++ it "silences the user and agrees with the flag" do+ result =+ reviewable.perform(+ moderator,+ :agree_and_silence,+ reason: "Disruptive behavior",+ silenced_till: 2.days.from_now,+ )++ expect(result).to be_success+ expect(flagged_user.reload).to be_silenced+ expect(reviewable.reload).to be_approved+ expect(reviewable.reviewable_scores.first).to be_agreed+ end++ it "leaves the user and flag unchanged when suspension details are invalid" do+ result = reviewable.perform(moderator, :agree_and_suspend, reason: "Disruption")++ expect(result).not_to be_success+ expect(flagged_user.reload).not_to be_suspended+ expect(reviewable.reload).to be_pending+ expect(reviewable.reviewable_scores.first).to be_pending+ end+it "approves the reviewable and agrees with the flag on agree_and_keep" doreviewable.perform(moderator, :agree_and_keep)diff --git a/spec/models/reviewable_flagged_post_spec.rb b/spec/models/reviewable_flagged_post_spec.rbindex d4d87f73376..8016f067bfd 100644--- a/spec/models/reviewable_flagged_post_spec.rb+++ b/spec/models/reviewable_flagged_post_spec.rb@@ -29,6 +29,28 @@ RSpec.describe ReviewableFlaggedPost, type: :model dolet(:score) { result.reviewable_score }let(:guardian) { Guardian.new(moderator) }+ it "keeps the spam flag pending and the author unsuspended when post deletion is forbidden" do+ SiteSetting.tos_topic_id = post.topic_id++ expect do+ reviewable.perform(+ moderator,+ :agree_and_suspend,+ reason: "spam",+ suspend_until: 2.days.from_now,+ post_action: "delete",+ )+ end.to raise_error(Discourse::InvalidAccess)++ expect(reviewable.reload).to be_pending+ expect(score.reload).to be_pending+ expect(post.user.reload).not_to be_suspended+ expect(post.reload).not_to be_trashed+ expect(+ UserHistory.where(action: UserHistory.actions[:suspend_user], target_user_id: post.user_id),+ ).to be_empty+ end+it "disagrees with flags without restoring a soft-deleted post" dopost.update!(hidden: true)post.trash!@@ -295,17 +317,29 @@ RSpec.describe ReviewableFlaggedPost, type: :model doendit "agree_and_suspend agrees with the flags and keeps the post" do- reviewable.perform(moderator, :agree_and_suspend)+ reviewable.perform(+ moderator,+ :agree_and_suspend,+ reason: "spam",+ suspend_until: 2.days.from_now,+ )expect(reviewable).to be_approvedexpect(score.reload).to be_agreedexpect(post).not_to be_hidden+ expect(post.user.reload).to be_suspendedendit "agree_and_silence agrees with the flags and keeps the post" do- reviewable.perform(moderator, :agree_and_silence)+ reviewable.perform(+ moderator,+ :agree_and_silence,+ reason: "spam",+ silenced_till: 2.days.from_now,+ )expect(reviewable).to be_approvedexpect(score.reload).to be_agreedexpect(post).not_to be_hidden+ expect(post.user.reload).to be_silencedendit "agree_and_hide agrees with the flags and hides the post" dodiff --git a/spec/models/reviewable_post_spec.rb b/spec/models/reviewable_post_spec.rbindex 781db8367f3..830dbd3a68e 100644--- a/spec/models/reviewable_post_spec.rb+++ b/spec/models/reviewable_post_spec.rb@@ -95,10 +95,43 @@ RSpec.describe ReviewablePost doenddescribe "#perform_reject_and_suspend" do- it "transitions to the rejected state" do- result = reviewable.perform admin, :reject_and_suspend+ it "rejects the post and suspends its author" do+ result =+ reviewable.perform(+ admin,+ :reject_and_suspend,+ reason: "spam",+ suspend_until: 2.days.from_now,+ )++ expect(result).to be_success+ expect(reviewable.reload).to be_rejected+ expect(post.user.reload).to be_suspended+ end- expect(result.transition_to).to eq :rejected+ it "keeps the post pending when suspension details are invalid" do+ result =+ reviewable.perform(admin, :reject_and_suspend, reason: "", suspend_until: 2.days.from_now)++ expect(result).not_to be_success+ expect(reviewable.reload).to be_pending+ expect(post.user.reload).not_to be_suspended+ end+ end++ describe "#perform_reject_and_silence" do+ it "rejects the post and silences its author" do+ result =+ reviewable.perform(+ admin,+ :reject_and_silence,+ reason: "spam",+ silenced_till: 2.days.from_now,+ )++ expect(result).to be_success+ expect(reviewable.reload).to be_rejected+ expect(post.user.reload).to be_silencedendenddiff --git a/spec/models/reviewable_queued_post_spec.rb b/spec/models/reviewable_queued_post_spec.rbindex 7134c50af4f..79797f22173 100644--- a/spec/models/reviewable_queued_post_spec.rb+++ b/spec/models/reviewable_queued_post_spec.rb@@ -472,6 +472,72 @@ RSpec.describe ReviewableQueuedPost, type: :model dodescribe "penalty actions" dofab!(:reviewable, :reviewable_queued_post)+ it "keeps the queued post pending when suspension details are invalid" do+ result =+ reviewable.perform(+ moderator,+ :reject_and_suspend,+ reason: "",+ suspend_until: 2.days.from_now,+ )++ expect(result).not_to be_success+ expect(reviewable.reload).to be_pending+ expect(reviewable.target_created_by.reload).not_to be_suspended+ end++ it "keeps the queued post pending when silencing details are invalid" do+ result =+ reviewable.perform(+ moderator,+ :reject_and_silence,+ reason: "",+ silenced_till: 2.days.from_now,+ )++ expect(result).not_to be_success+ expect(reviewable.reload).to be_pending+ expect(reviewable.target_created_by.reload).not_to be_silenced+ end++ it "keeps the queued post pending when the moderator cannot silence a related user" do+ expect do+ reviewable.perform(+ moderator,+ :reject_and_silence,+ reason: "spam",+ silenced_till: 2.days.from_now,+ other_user_ids: [admin.id],+ )+ end.to raise_error(Discourse::InvalidAccess)++ expect(reviewable.reload).to be_pending+ expect(reviewable.target_created_by.reload).not_to be_silenced+ expect(admin.reload).not_to be_silenced+ end++ it "rejects a queued post and renews expired related silences without shortening active ones" do+ expired_user = Fabricate(:user, silenced_till: 1.day.ago)+ active_expiry = 3.days.from_now.change(usec: 0)+ active_user = Fabricate(:user, silenced_till: active_expiry)+ expiry = 2.days.from_now.change(usec: 0)++ result =+ reviewable.perform(+ moderator,+ :reject_and_silence,+ reason: "spam",+ silenced_till: expiry,+ other_user_ids: [expired_user.id, active_user.id],+ )++ expect(result).to be_success+ expect(reviewable.reload).to be_rejected+ expect(reviewable.target_created_by.reload.silenced_till).to eq(expiry)+ expect(expired_user.reload.silenced_till).to eq(expiry)+ expect(active_user.reload.silenced_till).to eq(active_expiry)+ end+it "offers silence and suspend between the reject and delete actions" doactions = reviewable.actions_for(Guardian.new(moderator))bundle = actions.bundles.find { |b| b.id == "#{reviewable.id}-reject-post" }@@ -515,28 +581,38 @@ RSpec.describe ReviewableQueuedPost, type: :model doexpect(actions.has?(:reject_and_suspend)).to eq(false)end- it "rejects the post and keeps the author, letting the client apply the suspension" do+ it "rejects the post and suspends the author" doresult = nil- expect { result = reviewable.perform(moderator, :reject_and_suspend) }.not_to change(- Post,- :count,- )+ expect {+ result =+ reviewable.perform(+ moderator,+ :reject_and_suspend,+ reason: "spam",+ suspend_until: 2.days.from_now,+ )+ }.not_to change { reviewable.topic.posts.count }expect(result.success?).to eq(true)expect(reviewable.rejected?).to eq(true)- expect(reviewable.target_created_by.suspended?).to eq(false)+ expect(reviewable.target_created_by.reload).to be_suspendedend- it "rejects the post and keeps the author, letting the client apply the silencing" do+ it "rejects the post and silences the author" doresult = nil- expect { result = reviewable.perform(moderator, :reject_and_silence) }.not_to change(- Post,- :count,- )+ expect {+ result =+ reviewable.perform(+ moderator,+ :reject_and_silence,+ reason: "spam",+ silenced_till: 2.days.from_now,+ )+ }.not_to change { reviewable.topic.posts.count }expect(result.success?).to eq(true)expect(reviewable.rejected?).to eq(true)- expect(reviewable.target_created_by.silenced?).to eq(false)+ expect(reviewable.target_created_by.reload).to be_silencedendendenddiff --git a/spec/models/reviewable_user_spec.rb b/spec/models/reviewable_user_spec.rbindex aa8b78fe59d..0d64d39d76f 100644--- a/spec/models/reviewable_user_spec.rb+++ b/spec/models/reviewable_user_spec.rb@@ -447,23 +447,44 @@ RSpec.describe ReviewableUser, type: :model docontext "when suspending or silencing" dofab!(:reviewable, :suspect_user_reviewable)- it "rejects the reviewable and keeps the user, letting the client apply the suspension" do- result = reviewable.perform(moderator, :suspend_user)+ it "rejects the reviewable and suspends the user" do+ result =+ reviewable.perform(+ moderator,+ :suspend_user,+ reason: "spam",+ suspend_until: 2.days.from_now,+ )expect(result.success?).to eq(true)expect(reviewable.rejected?).to eq(true)expect(reviewable.reload.target).to be_presentexpect(reviewable.target.approved).to eq(false)- expect(reviewable.target.suspended?).to eq(false)+ expect(reviewable.target).to be_suspended+ end++ it "keeps the suspect user pending when suspension details are invalid" do+ result =+ reviewable.perform(moderator, :suspend_user, reason: "", suspend_until: 2.days.from_now)++ expect(result).not_to be_success+ expect(reviewable.reload).to be_pending+ expect(reviewable.target.reload).not_to be_suspendedend- it "rejects the reviewable and keeps the user, letting the client apply the silencing" do- result = reviewable.perform(moderator, :silence_user)+ it "rejects the reviewable and silences the user" do+ result =+ reviewable.perform(+ moderator,+ :silence_user,+ reason: "spam",+ silenced_till: 2.days.from_now,+ )expect(result.success?).to eq(true)expect(reviewable.rejected?).to eq(true)expect(reviewable.reload.target).to be_present- expect(reviewable.target.silenced?).to eq(false)+ expect(reviewable.target).to be_silencedendendenddiff --git a/spec/requests/reviewables_controller_spec.rb b/spec/requests/reviewables_controller_spec.rbindex 1d270b67b72..f36138b3436 100644--- a/spec/requests/reviewables_controller_spec.rb+++ b/spec/requests/reviewables_controller_spec.rb@@ -885,6 +885,61 @@ RSpec.describe ReviewablesController dofab!(:reviewable)before { sign_in(Fabricate(:moderator)) }+ it "suspends a flagged post's author and deletes the post when the moderator selects both actions" do+ flagged_post = Fabricate(:post)+ flagged =+ Fabricate(+ :reviewable_flagged_post,+ target: flagged_post,+ target_created_by: flagged_post.user,+ )+ expiry = 2.days.from_now.change(usec: 0)++ put "/review/#{flagged.id}/perform/agree_and_suspend.json",+ params: {+ version: flagged.version,+ reason: "Repeated spam",+ suspend_until: expiry.iso8601,+ post_action: "delete",+ }++ expect(response).to have_http_status(:ok)+ expect(flagged.reload).to be_approved+ expect(flagged_post.user.reload.suspended_till).to eq(expiry)+ expect(flagged_post.reload).to be_trashed+ expect(response.parsed_body.dig("reviewable_perform_result", "success")).to eq(true)+ end++ it "silences the author and rejects a queued post" do+ queued = Fabricate(:reviewable_queued_post)+ expiry = 2.days.from_now.change(usec: 0)++ put "/review/#{queued.id}/perform/reject_and_silence.json",+ params: {+ version: queued.version,+ reason: "Repeated spam",+ silenced_till: expiry.iso8601,+ }++ expect(response).to have_http_status(:ok)+ expect(queued.reload).to be_rejected+ expect(queued.target_created_by.reload.silenced_till).to eq(expiry)+ end++ it "rejects missing penalty details without resolving the reviewable" do+ flagged = Fabricate(:reviewable_flagged_post)++ put "/review/#{flagged.id}/perform/agree_and_silence.json",+ params: {+ version: flagged.version,+ }++ expect(response).to have_http_status(:unprocessable_entity)+ expect(response.parsed_body["errors"]).to be_present+ expect(flagged.reload).to be_pending+ expect(flagged.target_created_by.reload).not_to be_silenced+ end+it "returns 404 to category moderators for an inaccessible whisper" doSiteSetting.enable_category_group_moderation = truegroup_user = Fabricate(:group_user)@@ -1019,7 +1074,7 @@ RSpec.describe ReviewablesController doexpect(like.reload).to be_trashedend- it "releases a deleted topic's claim when agreeing before a silence" do+ it "releases a deleted topic's claim when agreeing and silencing" doSiteSetting.reviewable_claiming = "optional"admin = Fabricate(:admin)flagger = Fabricate(:user, refresh_auto_groups: true)@@ -1032,6 +1087,8 @@ RSpec.describe ReviewablesController doput "/review/#{flagged_reviewable.id}/perform/agree_and_silence.json",params: {version: flagged_reviewable.reload.version,+ reason: "Repeated spam",+ silenced_till: 1.day.from_now,}expect(response).to have_http_status(:ok)diff --git a/spec/services/user/action/trigger_post_action_spec.rb b/spec/services/user/action/trigger_post_action_spec.rbindex be12e0f576f..a5e0156dc85 100644--- a/spec/services/user/action/trigger_post_action_spec.rb+++ b/spec/services/user/action/trigger_post_action_spec.rb@@ -2,7 +2,7 @@RSpec.describe User::Action::TriggerPostAction dodescribe ".call" do- subject(:action) { described_class.call(guardian:, post:, params:) }+ subject(:action) { described_class.call(guardian:, post:, params:, raise_on_failure:) }fab!(:post)fab!(:admin)@@ -11,6 +11,7 @@ RSpec.describe User::Action::TriggerPostAction dolet(:params) { User::Suspend::Contract.new(post_action:, post_edit:) }let(:post_action) { nil }let(:post_edit) { nil }+ let(:raise_on_failure) { false }context "when post is blank" dolet(:post) { nil }@@ -34,6 +35,37 @@ RSpec.describe User::Action::TriggerPostAction doendend+ context "when bulk deletion is selected during a review" do+ let(:post_action) { "delete_all" }+ let(:raise_on_failure) { true }++ it "leaves the post for the separate bulk deletion" do+ expect { action }.not_to change { post.reload.deleted_at }+ end+ end++ context "when a review selects a deletion the actor cannot perform" do+ let(:post_action) { "delete" }+ let(:guardian) { Guardian.new }+ let(:raise_on_failure) { true }++ it "rejects the deletion" do+ expect { action }.to raise_error(Discourse::InvalidAccess)+ expect(post.reload).not_to be_trashed+ end+ end++ context "when a review edit leaves the post unchanged" do+ let(:post_action) { "edit" }+ let(:post_edit) { "#{post.raw} " }+ let(:raise_on_failure) { true }++ it "accepts the edit without creating a revision" do+ expect { action }.not_to change { post.revisions.count }+ expect(post.reload.raw).to eq(post_edit.strip)+ end+ end+context "when post and post_action are defined" docontext "when post_action is 'delete'" dolet(:post_action) { "delete" }diff --git a/spec/services/user/silence_spec.rb b/spec/services/user/silence_spec.rbindex e7e67441f74..f87e1b89371 100644--- a/spec/services/user/silence_spec.rb+++ b/spec/services/user/silence_spec.rb@@ -61,8 +61,6 @@ RSpec.describe User::Silence doendcontext "when everything's ok" do- before { allow(User::Action::TriggerPostAction).to receive(:call) }-it "silences all provided users" doresultexpect([user, other_user].map(&:reload)).to all be_silenced@@ -76,13 +74,13 @@ RSpec.describe User::Silence doexpect(result[:full_reason]).to eq("spam\n\nit was spam")end- it "triggers a post action" do+ it "deletes the selected post" do+ post = Fabricate(:post, user:)+ params.merge!(post_id: post.id, post_action: "delete")+result- expect(User::Action::TriggerPostAction).to have_received(:call).with(- guardian:,- post: nil,- params: result[:params],- )++ expect(post.reload).to be_trashedendendenddiff --git a/spec/services/user/suspend_spec.rb b/spec/services/user/suspend_spec.rbindex 1fcfaca3d0f..13f265f1342 100644--- a/spec/services/user/suspend_spec.rb+++ b/spec/services/user/suspend_spec.rb@@ -63,20 +63,18 @@ RSpec.describe User::Suspend doendcontext "when everything's ok" do- before { allow(User::Action::TriggerPostAction).to receive(:call) }-it "suspends all provided users" doresultexpect([user, other_user].map(&:reload)).to all be_suspendedend- it "triggers a post action" do+ it "deletes the selected post" do+ post = Fabricate(:post, user:)+ params.merge!(post_id: post.id, post_action: "delete")+result- expect(User::Action::TriggerPostAction).to have_received(:call).with(- guardian:,- post: nil,- params: result[:params],- )++ expect(post.reload).to be_trashedendit "exposes the full reason in the result object" dodiff --git a/spec/system/page_objects/pages/admin_user.rb b/spec/system/page_objects/pages/admin_user.rbindex 0e66a35cbdb..d5b5c45af5f 100644--- a/spec/system/page_objects/pages/admin_user.rb+++ b/spec/system/page_objects/pages/admin_user.rb@@ -15,6 +15,10 @@ module PageObjectshas_css?(".btn-danger.suspend-user")end+ def has_unsuspend_button?+ has_css?(".btn-danger.unsuspend-user")+ end+def has_no_suspend_button?has_no_css?(".btn-danger.suspend-user")end@@ -23,6 +27,10 @@ module PageObjectshas_css?(".btn-danger.silence-user")end+ def has_unsilence_button?+ has_css?(".btn-danger.unsilence-user")+ end+def has_no_silence_button?has_no_css?(".btn-danger.silence-user")enddiff --git a/spec/system/reviewables_spec.rb b/spec/system/reviewables_spec.rbindex fb1adf4e646..5b31053ddf5 100644--- a/spec/system/reviewables_spec.rb+++ b/spec/system/reviewables_spec.rb@@ -88,6 +88,52 @@ describe "Reviewables" doendend+ context "when suspending a flagged post author" do+ fab!(:reviewable) do+ Fabricate(:reviewable_flagged_post, target: post, target_created_by: post.user)+ end++ let(:admin_user_page) { PageObjects::Pages::AdminUser.new }++ it "lets a moderator suspend the author and resolve the flagged post" do+ modal = PageObjects::Modals::PenalizeUser.new("suspend")+ review_page.visit_reviewable(reviewable)+ review_page.select_bundled_action(reviewable, "post-agree_and_suspend", bundle_index: 1)+ modal.fill_in_suspend_reason("Repeated spam")+ modal.set_future_date("tomorrow")+ modal.perform++ expect(modal).to be_closed+ review_page.visit_reviewable(reviewable)+ expect(review_page).to have_reviewable_with_approved_status(reviewable)+ admin_user_page.visit(post.user)+ expect(admin_user_page).to have_unsuspend_button+ end+ end++ context "when silencing a flagged post author" do+ fab!(:reviewable) do+ Fabricate(:reviewable_flagged_post, target: post, target_created_by: post.user)+ end++ let(:admin_user_page) { PageObjects::Pages::AdminUser.new }++ it "lets a moderator silence the author and resolve the flagged post" do+ modal = PageObjects::Modals::PenalizeUser.new("silence")+ review_page.visit_reviewable(reviewable)+ review_page.select_bundled_action(reviewable, "post-agree_and_silence", bundle_index: 1)+ modal.fill_in_silence_reason("Repeated spam")+ modal.set_future_date("tomorrow")+ modal.perform++ expect(modal).to be_closed+ review_page.visit_reviewable(reviewable)+ expect(review_page).to have_reviewable_with_approved_status(reviewable)+ admin_user_page.visit(post.user)+ expect(admin_user_page).to have_unsilence_button+ end+ end+describe "when there are several flagged posts in the queue" dofab!(:flagger) { Fabricate(:user, trust_level: TrustLevel[3]) }fab!(:spammer_one, :user)