Skip to content

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

FEATURE: React to user lifecycle and moderation changes

Régis Hanolf84081dc5830
diff --git a/app/controllers/admin/users_controller.rb b/app/controllers/admin/users_controller.rb
index 67306e9eef3..9282f7c6981 100644
--- a/app/controllers/admin/users_controller.rb
+++ b/app/controllers/admin/users_controller.rb
@@ -172,13 +172,7 @@ class Admin::UsersController < Admin::StaffController
def unsuspend
guardian.ensure_can_unsuspend!(@user)
- @user.suspended_till = nil
- @user.suspended_at = nil
- @user.save!
-
- StaffActionLogger.new(current_user).log_user_unsuspend(@user)
-
- DiscourseEvent.trigger(:user_unsuspended, user: @user)
+ UserSuspender.unsuspend(@user, by_user: current_user)
render_json_dump(suspension: { suspended_till: nil, suspended_at: nil })
end
diff --git a/app/jobs/regular/user_suspension_expired.rb b/app/jobs/regular/user_suspension_expired.rb
new file mode 100644
index 00000000000..bbdbe3ac1eb
--- /dev/null
+++ b/app/jobs/regular/user_suspension_expired.rb
@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Jobs
+ class UserSuspensionExpired < ::Jobs::Base
+ def execute(args)
+ user = User.find_by(id: args[:user_id])
+ return if user.nil?
+
+ UserSuspender.expire(
+ user,
+ suspended_at: Time.iso8601(args[:suspended_at]),
+ suspended_till: Time.iso8601(args[:suspended_till]),
+ )
+ end
+ end
+end
diff --git a/app/services/user_suspender.rb b/app/services/user_suspender.rb
index b93ee03daf7..ea7160104b5 100644
--- a/app/services/user_suspender.rb
+++ b/app/services/user_suspender.rb
@@ -1,8 +1,41 @@
# frozen_string_literal: true
class UserSuspender
+ SUSPENSION_EXPIRY_CONTEXT = "suspension_expired"
+ TIMESTAMP_PRECISION = 6
+
attr_reader :user_history
+ def self.expire(user, suspended_at:, suspended_till:)
+ actor = Discourse.system_user
+
+ user.with_lock(requires_new: true) do
+ return if user.suspended_at != suspended_at || user.suspended_till != suspended_till
+ return if user.suspended?
+
+ context = [
+ SUSPENSION_EXPIRY_CONTEXT,
+ suspended_at.utc.iso8601(TIMESTAMP_PRECISION),
+ suspended_till.utc.iso8601(TIMESTAMP_PRECISION),
+ ].join(":")
+ return if user.user_histories.where(context: context).exists?
+
+ StaffActionLogger.new(actor).log_user_unsuspend(user, context: context)
+ DiscourseEvent.trigger(:user_unsuspended, user: user, by_user: actor)
+ end
+ end
+
+ def self.unsuspend(user, by_user:)
+ user.with_lock(requires_new: true) do
+ return if user.suspended_till.nil?
+
+ user.update!(suspended_at: nil, suspended_till: nil)
+ StaffActionLogger.new(by_user).log_user_unsuspend(user)
+
+ DiscourseEvent.trigger(:user_unsuspended, user: user, by_user: by_user)
+ end
+ end
+
def initialize(
user,
suspended_till:,
@@ -41,6 +74,14 @@ class UserSuspender
end
@user.log_out!
+ Jobs.enqueue_at(
+ @user.suspended_till,
+ :user_suspension_expired,
+ user_id: @user.id,
+ suspended_at: @user.suspended_at.iso8601(TIMESTAMP_PRECISION),
+ suspended_till: @user.suspended_till.iso8601(TIMESTAMP_PRECISION),
+ )
+
if @message.present?
Jobs.enqueue(
Jobs::CriticalUserEmail,
@@ -53,6 +94,7 @@ class UserSuspender
DiscourseEvent.trigger(
:user_suspended,
user: @user,
+ by_user: @by_user,
reason: @reason,
message: @message,
user_history: @user_history,
diff --git a/plugins/discourse-workflows/USE_CASES.md b/plugins/discourse-workflows/USE_CASES.md
index 984acd32b7c..16e3434a8a4 100644
--- a/plugins/discourse-workflows/USE_CASES.md
+++ b/plugins/discourse-workflows/USE_CASES.md
@@ -64,6 +64,8 @@ For each run, record:
- Topic status triggers are separate nodes: `topic_closed`, `topic_reopened`, `topic_archived`, `topic_unarchived`, `topic_listed`, `topic_unlisted`, `topic_pinned`, `topic_unpinned`, `topic_pinned_globally`, and `topic_unpinned_globally` (all prefixed with `trigger:`). They share category and tag filters. Closing includes automatic closes; unpin events use the previous pin scope. Workflow and AI actions use the same status updater.
- Review outcome triggers are `trigger:reviewable_approved`, `trigger:reviewable_rejected`, `trigger:reviewable_ignored`, `trigger:reviewable_deleted`, and `trigger:reviewable_pending`. They share the reviewable-type filter. Pending handles an existing item returning to review; use `trigger:reviewable_created` for new items.
- Connect multiple event triggers to the same downstream node to handle several events. Existing `trigger:topic_status_changed` and `trigger:reviewable_status_changed` nodes remain editable and executable, but are hidden from the picker and AI discovery. Fixed-event nodes have no status selector and ignore any supplied `statuses` configuration.
+- `trigger:user_trust_level_changed` exposes old and new levels, including demotions. `trigger:user_first_logged_in` follows the first-login event, whose first-visit check uses `last_seen_at`.
+- `trigger:user_moderation_changed` exposes `change`, the affected `user`, optional `actor` and `reason`, and `expires_at`. Automatic suspension expiry is announced for suspensions scheduled after this functionality is deployed; existing suspensions are not backfilled.
- Topic-only triggers that need author/post fields should use `action:topic` get before filtering or messaging.
- Generic prompts like "when someone posts" should use `trigger:post_created` for all regular posts; do not ask whether to include replies unless the prompt explicitly narrows the scope.
- Actions that replace item JSON require downstream nodes to use the action output schema, not the original trigger schema.
@@ -77,3 +79,11 @@ For each run, record:
- `trigger:post_destroyed` and `trigger:post_recovered` expose `$json.user` as the acting moderator, not the post author; use `$json.post.username` for the author.
- DM/personal-message notifications should use `action:send_personal_message` instead of chat or topic reply nodes.
- Forum `search`/`read` should not be used for node/schema discovery; use `workflow_node_catalog` and `workflow_validate_patch`.
+
+## Moderation entrypoints
+
+Live suspensions from admin actions (single and bulk), AI tools, and automation use `UserSuspender`. Manual unsuspension and scheduled expiry use the same class. Expiry preserves historical suspension dates and deduplicates its event through staff history; clearing those dates would change badge eligibility.
+
+`UserSilencer` already handles admin, review queue, spam, chat, AI, and workflow silence actions, manual unsilencing, and scheduled unsilencing. No additional silence service is needed.
+
+Direct field writes intentionally remain in historical imports, anonymous shadow-account synchronization, and AI bot self-repair. These restore or copy state rather than perform independent human moderation actions, so they must not send moderation messages or create duplicate workflow events.
diff --git a/plugins/discourse-workflows/config/locales/client.en.yml b/plugins/discourse-workflows/config/locales/client.en.yml
index 3478fc63136..8625ed634a0 100644
--- a/plugins/discourse-workflows/config/locales/client.en.yml
+++ b/plugins/discourse-workflows/config/locales/client.en.yml
@@ -218,6 +218,9 @@ en:
"trigger:topic_timer_changed": "Topic timer changed"
"trigger:topic_status_changed": "Topic status changed"
"trigger:reviewable_status_changed": "Review outcome changed"
+ "trigger:user_trust_level_changed": "Trust level changed"
+ "trigger:user_first_logged_in": "User first logged in"
+ "trigger:user_moderation_changed": "User moderation changed"
"trigger:topic_closed": "Topic closed"
"trigger:topic_reopened": "Topic reopened"
"trigger:topic_archived": "Topic archived"
@@ -298,6 +301,9 @@ en:
"trigger:topic_timer_changed": "Fires when a topic timer is created, updated, cancelled, or completed"
"trigger:topic_status_changed": "Fires when a topic is closed, reopened, archived, listed, or pinned, or those changes are reversed"
"trigger:reviewable_status_changed": "Fires when an item's status changes in the review queue"
+ "trigger:user_trust_level_changed": "Fires when a user's trust level increases or decreases"
+ "trigger:user_first_logged_in": "Fires when a user logs in for the first time"
+ "trigger:user_moderation_changed": "Fires when a user is suspended, unsuspended, silenced, or unsilenced"
"trigger:topic_closed": "Fires when a topic is closed by a user or auto-close timer"
"trigger:topic_reopened": "Fires when a topic is reopened"
"trigger:topic_archived": "Fires when a topic is archived"
@@ -939,6 +945,21 @@ en:
statuses_rejected: "Rejected"
statuses_ignored: "Ignored"
statuses_deleted: "Deleted"
+ user_trust_level_changed:
+ old_trust_levels: "Previous trust levels"
+ old_trust_levels_description: "Leave empty to match any previous trust level."
+ old_trust_levels_placeholder: "Any trust level"
+ new_trust_levels: "New trust levels"
+ new_trust_levels_description: "Leave empty to match any new trust level."
+ new_trust_levels_placeholder: "Any trust level"
+ user_moderation_changed:
+ changes: "Changes"
+ changes_description: "Leave empty to match any change."
+ changes_placeholder: "Any change"
+ changes_suspended: "Suspended"
+ changes_unsuspended: "Unsuspended"
+ changes_silenced: "Silenced"
+ changes_unsilenced: "Unsilenced"
post_created:
topic_type: "Topic type"
topic_type_description: "Choose whether topics, personal messages, or both should trigger the workflow"
diff --git a/plugins/discourse-workflows/lib/discourse_workflows/event_listener.rb b/plugins/discourse-workflows/lib/discourse_workflows/event_listener.rb
index d703ce0223d..d3f6f314e9e 100644
--- a/plugins/discourse-workflows/lib/discourse_workflows/event_listener.rb
+++ b/plugins/discourse-workflows/lib/discourse_workflows/event_listener.rb
@@ -2,11 +2,11 @@
module DiscourseWorkflows
class EventListener
- def self.handle(trigger_class, *args)
+ def self.handle(trigger_class, *args, event_name: nil)
return unless SiteSetting.enable_discourse_workflows
return if WorkflowDependency.active_node_types.exclude?(trigger_class.identifier)
- trigger = trigger_class.new(*args)
+ trigger = trigger_class.from_event(event_name, *args)
return unless trigger.valid?
trigger_data = nil
diff --git a/plugins/discourse-workflows/lib/discourse_workflows/node_type.rb b/plugins/discourse-workflows/lib/discourse_workflows/node_type.rb
index cde504959fc..30915882b0f 100644
--- a/plugins/discourse-workflows/lib/discourse_workflows/node_type.rb
+++ b/plugins/discourse-workflows/lib/discourse_workflows/node_type.rb
@@ -246,8 +246,12 @@ module DiscourseWorkflows
end
private_class_method :unknown_contract?
- def self.event_name
- description[:event]&.to_sym
+ def self.event_names
+ Array.wrap(description[:event]).map(&:to_sym)
+ end
+
+ def self.from_event(_event_name, *args)
+ new(*args)
end
def self.manually_triggerable?
diff --git a/plugins/discourse-workflows/lib/discourse_workflows/nodes/user_first_logged_in/v1.rb b/plugins/discourse-workflows/lib/discourse_workflows/nodes/user_first_logged_in/v1.rb
new file mode 100644
index 00000000000..4d3f916b171
--- /dev/null
+++ b/plugins/discourse-workflows/lib/discourse_workflows/nodes/user_first_logged_in/v1.rb
@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module DiscourseWorkflows
+ module Nodes
+ module UserFirstLoggedIn
+ class V1 < NodeType
+ description(
+ name: "trigger:user_first_logged_in",
+ version: "1.0",
+ defaults: {
+ icon: "right-to-bracket",
+ color: "teal",
+ },
+ group: "discourse_triggers",
+ event: :user_first_logged_in,
+ output_contracts: [{ schema: Schema::USER_SCHEMA }],
+ capabilities: {
+ provides_current_user: true,
+ },
+ )
+
+ def initialize(user)
+ super(parameters: {})
+ @user = user
+ end
+
+ def valid?
+ @user.present? && @user.human?
+ end
+
+ def user_id
+ @user.id
+ end
+
+ def output
+ { user: serialize_user(@user) }
+ end
+ end
+ end
+ end
+end
diff --git a/plugins/discourse-workflows/lib/discourse_workflows/nodes/user_moderation_changed/v1.rb b/plugins/discourse-workflows/lib/discourse_workflows/nodes/user_moderation_changed/v1.rb
new file mode 100644
index 00000000000..9322d74dc19
--- /dev/null
+++ b/plugins/discourse-workflows/lib/discourse_workflows/nodes/user_moderation_changed/v1.rb
@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module DiscourseWorkflows
+ module Nodes
+ module UserModerationChanged
+ class V1 < NodeType
+ CHANGES = {
+ user_suspended: "suspended",
+ user_unsuspended: "unsuspended",
+ user_silenced: "silenced",
+ user_unsilenced: "unsilenced",
+ }.freeze
+
+ OUTPUT_SCHEMA =
+ Schema.merge(
+ Schema::USER_SCHEMA,
+ Schema.document(
+ "change" => {
+ "type" => "string",
+ "enum" => CHANGES.values,
+ },
+ "actor" => {
+ "type" => %w[object null],
+ "properties" => Schema::BASIC_USER_PROPERTIES,
+ },
+ "reason" => {
+ "type" => %w[string null],
+ },
+ "expires_at" => {
+ "type" => %w[string null],
+ "format" => "date-time",
+ },
+ ),
+ ).freeze
+
+ description(
+ name: "trigger:user_moderation_changed",
+ version: "1.0",
+ defaults: {
+ icon: "user-xmark",
+ color: "red",
+ },
+ group: "discourse_triggers",
+ event: CHANGES.keys,
+ output_contracts: [{ schema: OUTPUT_SCHEMA }],
+ properties: {
+ changes: {
+ type: :multi_options,
+ required: false,
+ default: [],
+ options: CHANGES.values,
+ },
+ },
+ capabilities: {
+ provides_current_user: true,
+ },
+ )
+
+ def self.from_event(event_name, *args)
+ new(event_name, *args)
+ end
+
+ def initialize(event_name, payload = {})
+ super(parameters: {})
+ @change = CHANGES[event_name]
+ @user = payload[:user]
+ @actor = payload[:by_user] || payload[:silenced_by]
+ @reason = payload[:reason]
+ end
+
+ def valid?
+ @change.present? && @user.present? && @user.human?
+ end
+
+ def user_id
+ @user.id
+ end
+
+ def output
+ expiry =
+ case @change
+ when "suspended"
+ @user.suspended_till
+ when "silenced"
+ @user.silenced_till
+ end
+
+ {
+ user: serialize_user(@user),
+ change: @change,
+ actor: @actor && serialize_record(@actor, BasicUserSerializer),
+ reason: @reason,
+ expires_at: expiry&.iso8601,
+ }
+ end
+
+ def matches?(trigger_ctx)
+ changes =
+ Array.wrap(trigger_ctx.get_node_parameter("changes", [])).compact_blank.map(&:to_s)
+ changes.empty? || changes.include?(@change)
+ end
+ end
+ end
+ end
+end
diff --git a/plugins/discourse-workflows/lib/discourse_workflows/nodes/user_trust_level_changed/v1.rb b/plugins/discourse-workflows/lib/discourse_workflows/nodes/user_trust_level_changed/v1.rb
new file mode 100644
index 00000000000..f62a1fdcb9c
--- /dev/null
+++ b/plugins/discourse-workflows/lib/discourse_workflows/nodes/user_trust_level_changed/v1.rb
@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module DiscourseWorkflows
+ module Nodes
+ module UserTrustLevelChanged
+ class V1 < NodeType
+ OUTPUT_SCHEMA =
+ Schema.merge(
+ Schema::USER_SCHEMA,
+ Schema.document(
+ "old_trust_level" => {
+ "type" => "integer",
+ },
+ "new_trust_level" => {
+ "type" => "integer",
+ },
+ ),
+ ).freeze
+
+ description(
+ name: "trigger:user_trust_level_changed",
+ version: "1.0",
+ defaults: {
+ icon: "user-shield",
+ color: "teal",
+ },
+ group: "discourse_triggers",
+ event: :user_promoted,
+ output_contracts: [{ schema: OUTPUT_SCHEMA }],
+ properties: {
+ old_trust_levels: {
+ type: :multi_options,
+ default: [],
+ options: trust_level_options,
+ },
+ new_trust_levels: {
+ type: :multi_options,
+ default: [],
+ options: trust_level_options,
+ },
+ },
+ capabilities: {
+ provides_current_user: true,
+ },
+ )
+
+ def initialize(data)
+ super(parameters: {})
+ @user = ::User.find_by(id: data[:user_id])
+ @old_trust_level = data[:old_trust_level]
+ @new_trust_level = data[:new_trust_level]
+ end
+
+ def valid?
+ @user.present? && @user.human? && @old_trust_level != @new_trust_level
+ end
+
+ def user_id
+ @user.id
+ end
+
+ def output
+ {
+ user: serialize_user(@user),
+ old_trust_level: @old_trust_level,
+ new_trust_level: @new_trust_level,
+ }
+ end
+
+ def matches?(trigger_ctx)
+ matches_level?(trigger_ctx, "old_trust_levels", @old_trust_level) &&
+ matches_level?(trigger_ctx, "new_trust_levels", @new_trust_level)
+ end
+
+ private
+
+ def matches_level?(trigger_ctx, parameter, level)
+ levels =
+ Array.wrap(trigger_ctx.get_node_parameter(parameter, [])).compact_blank.map(&:to_s)
+
+ levels.empty? || levels.include?(level.to_s)
+ end
+ end
+ end
+ end
+end
diff --git a/plugins/discourse-workflows/lib/discourse_workflows/plugin_node_registration.rb b/plugins/discourse-workflows/lib/discourse_workflows/plugin_node_registration.rb
index 6f85a644491..b0c4e572eab 100644
--- a/plugins/discourse-workflows/lib/discourse_workflows/plugin_node_registration.rb
+++ b/plugins/discourse-workflows/lib/discourse_workflows/plugin_node_registration.rb
@@ -55,14 +55,16 @@ module DiscourseWorkflows
# `Plugin::Instance#on` gates the handler on the owning plugin being enabled,
# so a node stops listening as soon as its plugin is turned off.
def subscribe_node_event(node_class, plugin)
- event_name = node_class.event_name if node_class.respond_to?(:event_name)
- return if event_name.blank?
+ event_names = node_class.event_names if node_class.respond_to?(:event_names)
+ return if event_names.blank?
# Event handlers outlive Zeitwerk reloads, so resolve named classes at dispatch.
node_reference = node_class.name || node_class
- plugin.on(event_name) do |*args|
- current_class = node_reference.is_a?(String) ? node_reference.constantize : node_reference
- EventListener.handle(current_class, *args)
+ event_names.each do |event_name|
+ plugin.on(event_name) do |*args|
+ current_class = node_reference.is_a?(String) ? node_reference.constantize : node_reference
+ EventListener.handle(current_class, *args, event_name:)
+ end
end
end
end
diff --git a/plugins/discourse-workflows/spec/integration/status_event_triggers_spec.rb b/plugins/discourse-workflows/spec/integration/status_event_triggers_spec.rb
index 11e70fddd44..6e95c1d7a84 100644
--- a/plugins/discourse-workflows/spec/integration/status_event_triggers_spec.rb
+++ b/plugins/discourse-workflows/spec/integration/status_event_triggers_spec.rb
@@ -2,6 +2,7 @@
RSpec.describe "Workflow status event triggers" do
fab!(:admin)
+ fab!(:user)
fab!(:topic, :topic_with_op)
before { DiscourseWorkflows::WorkflowDependency.clear_cache! }
@@ -72,6 +73,44 @@ RSpec.describe "Workflow status event triggers" do
end
end
+ it "dispatches promotions with both trust levels and the execution user" do
+ user.update!(trust_level: TrustLevel.levels[:basic])
+ create_workflow(
+ "promoted",
+ "trigger:user_trust_level_changed",
+ "old_trust_levels" => [TrustLevel.levels[:basic].to_s],
+ "new_trust_levels" => [TrustLevel.levels[:member].to_s],
+ )
+
+ Promotion.new(user).change_trust_level!(TrustLevel.levels[:member])
+
+ expect(enqueued_jobs.size).to eq(1)
+ expect(enqueued_jobs.first["user_id"]).to eq(user.id)
+ expect(enqueued_jobs.first["trigger_data"]).to include(
+ "old_trust_level" => TrustLevel.levels[:basic],
+ "new_trust_level" => TrustLevel.levels[:member],
+ )
+ expect(enqueued_jobs.first["trigger_data"]).to match_node_output_schema(
+ DiscourseWorkflows::Nodes::UserTrustLevelChanged::V1,
+ )
+ end
+
+ it "dispatches first login without dispatching later logins" do
+ user.update!(last_seen_at: nil)
+ create_workflow("first-login", "trigger:user_first_logged_in")
+
+ user.logged_in
+ user.update!(last_seen_at: Time.current)
+ user.logged_in
+
+ expect(enqueued_jobs.size).to eq(1)
+ expect(enqueued_jobs.first["user_id"]).to eq(user.id)
+ expect(enqueued_jobs.first.dig("trigger_data", "user", "id")).to eq(user.id)
+ expect(enqueued_jobs.first["trigger_data"]).to match_node_output_schema(
+ DiscourseWorkflows::Nodes::UserFirstLoggedIn::V1,
+ )
+ end
+
def create_workflow(trigger_id, trigger_type, configuration = {})
graph =
build_workflow_graph do |graph_builder|
diff --git a/plugins/discourse-workflows/spec/lib/discourse_workflows/nodes/user_first_logged_in_spec.rb b/plugins/discourse-workflows/spec/lib/discourse_workflows/nodes/user_first_logged_in_spec.rb
new file mode 100644
index 00000000000..386d38408f6
--- /dev/null
+++ b/plugins/discourse-workflows/spec/lib/discourse_workflows/nodes/user_first_logged_in_spec.rb
@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+RSpec.describe DiscourseWorkflows::Nodes::UserFirstLoggedIn::V1 do
+ fab!(:user)
+
+ describe "#valid?" do
+ it "accepts human users" do
+ expect(described_class.new(user)).to be_valid
+ expect(described_class.new(nil)).not_to be_valid
+ expect(described_class.new(Discourse.system_user)).not_to be_valid
+ end
+ end
+end
diff --git a/plugins/discourse-workflows/spec/lib/discourse_workflows/nodes/user_moderation_changed_spec.rb b/plugins/discourse-workflows/spec/lib/discourse_workflows/nodes/user_moderation_changed_spec.rb
new file mode 100644
index 00000000000..ccf8f035236
--- /dev/null
+++ b/plugins/discourse-workflows/spec/lib/discourse_workflows/nodes/user_moderation_changed_spec.rb
@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+RSpec.describe DiscourseWorkflows::Nodes::UserModerationChanged::V1 do
+ fab!(:user)
+ fab!(:admin)
+
+ it "dispatches moderation changes with safe actor data and filters selected changes" do
+ freeze_time
+ expiry = 1.day.from_now
+ graph =
+ build_workflow_graph do |builder|
+ builder.node "moderation", described_class.identifier
+ builder.node "suspended",
+ described_class.identifier,
+ configuration: {
+ changes: ["suspended"],
+ }
+ end
+ Fabricate(:discourse_workflows_workflow, created_by: admin, published: true, **graph)
+
+ UserSuspender.new(user, by_user: admin, reason: "Spam", suspended_till: expiry).suspend
+ UserSuspender.unsuspend(user, by_user: admin)
+ UserSilencer.silence(user, admin, reason: "Spam", silenced_till: expiry, keep_posts: true)
+ UserSilencer.unsilence(user, admin)
+
+ jobs = Jobs::DiscourseWorkflows::ExecuteWorkflow.jobs.map { |job| job["args"].first }
+ data = jobs.filter_map { |job| job["trigger_data"] if job["trigger_node_id"] == "moderation" }
+ expect(data.pluck("change")).to eq(%w[suspended unsuspended silenced unsilenced])
+ expect(data.pluck("reason")).to eq(["Spam", nil, "Spam", nil])
+ expect(data.pluck("expires_at")).to eq([expiry.iso8601, nil, expiry.iso8601, nil])
+ expect(
+ jobs.filter_map do |job|
+ job["trigger_data"]["change"] if job["trigger_node_id"] == "suspended"
+ end,
+ ).to eq(["suspended"])
+ data.each do |output|
+ expect(output["user"]).to include("id" => user.id, "username" => user.username)
+ expect(output["actor"]).to include("id" => admin.id, "username" => admin.username)
+ expect(output["actor"]).not_to have_key("email")
+ expect(output).to match_node_output_schema(described_class)
+ end
+ end
+
+ it "preserves an unknown actor and reason" do
+ user.update!(silenced_till: 1.day.from_now)
+
+ output = described_class.from_event(:user_silenced, user: user).output
+
+ expect(output).to include(actor: nil, reason: nil, expires_at: user.silenced_till.iso8601)
+ expect(output).to match_node_output_schema(described_class)
+ end
+
+ it "rejects missing users, bots, and unsupported events" do
+ expect(described_class.from_event(:user_suspended, {})).not_to be_valid
+ expect(described_class.from_event(:user_suspended, user: Discourse.system_user)).not_to be_valid
+ expect(described_class.from_event(:user_updated, user: user)).not_to be_valid
+ end
+end
diff --git a/plugins/discourse-workflows/spec/lib/discourse_workflows/nodes/user_trust_level_changed_spec.rb b/plugins/discourse-workflows/spec/lib/discourse_workflows/nodes/user_trust_level_changed_spec.rb
new file mode 100644
index 00000000000..161b9643dac
--- /dev/null
+++ b/plugins/discourse-workflows/spec/lib/discourse_workflows/nodes/user_trust_level_changed_spec.rb
@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+RSpec.describe DiscourseWorkflows::Nodes::UserTrustLevelChanged::V1 do
+ fab!(:user)
+
+ let(:old_level) { TrustLevel.levels[:basic] }
+ let(:new_level) { TrustLevel.levels[:member] }
+ let(:event_data) { { user_id: user.id, old_trust_level: old_level, new_trust_level: new_level } }
+
+ describe "#valid?" do
+ it "requires changed trust levels and a human user" do
+ expect(described_class.new(event_data)).to be_valid
+ expect(
+ described_class.new(
+ event_data.merge(old_trust_level: new_level, new_trust_level: old_level),
+ ),
+ ).to be_valid
+
+ expect(described_class.new(event_data.merge(new_trust_level: old_level))).not_to be_valid
+ expect(described_class.new(event_data.merge(user_id: nil))).not_to be_valid
+ expect(
+ described_class.new(event_data.merge(user_id: Discourse::SYSTEM_USER_ID)),
+ ).not_to be_valid
+ end
+ end
+
+ describe "#matches?" do
+ it "filters both the previous and new trust levels" do
+ trigger = described_class.new(event_data)
+
+ expect(trigger.matches?(trigger_context({}))).to eq(true)
+ expect(
+ trigger.matches?(
+ trigger_context(
+ "old_trust_levels" => [old_level.to_s],
+ "new_trust_levels" => [new_level.to_s],
+ ),
+ ),
+ ).to eq(true)
+ expect(trigger.matches?(trigger_context("old_trust_levels" => [new_level]))).to eq(false)
+ expect(trigger.matches?(trigger_context("new_trust_levels" => [old_level]))).to eq(false)
+ end
+ end
+
+ def trigger_context(parameters)
+ DiscourseWorkflows::TriggerNodeContext.new({ "parameters" => parameters })
+ end
+end
diff --git a/plugins/discourse-workflows/spec/lib/discourse_workflows/plugin_node_registration_spec.rb b/plugins/discourse-workflows/spec/lib/discourse_workflows/plugin_node_registration_spec.rb
index db70c7b09a9..e6df3dbcd5b 100644
--- a/plugins/discourse-workflows/spec/lib/discourse_workflows/plugin_node_registration_spec.rb
+++ b/plugins/discourse-workflows/spec/lib/discourse_workflows/plugin_node_registration_spec.rb
@@ -27,7 +27,7 @@ RSpec.describe DiscourseWorkflows do
before do
DiscourseWorkflows.node_registration_ready = true
- allow(DiscourseWorkflows::EventListener).to receive(:handle) do |klass, *args|
+ allow(DiscourseWorkflows::EventListener).to receive(:handle) do |klass, *args, **|
handled << [klass, args]
end
end
diff --git a/plugins/discourse-workflows/spec/lib/discourse_workflows/registry_reload_spec.rb b/plugins/discourse-workflows/spec/lib/discourse_workflows/registry_reload_spec.rb
index b11bf0b408e..1650024223c 100644
--- a/plugins/discourse-workflows/spec/lib/discourse_workflows/registry_reload_spec.rb
+++ b/plugins/discourse-workflows/spec/lib/discourse_workflows/registry_reload_spec.rb
@@ -59,8 +59,8 @@ RSpec.describe DiscourseWorkflows::Registry do
plugin,
)
described_class.reset_indexes!
- allow(DiscourseWorkflows::EventListener).to receive(:handle) do |klass, *args|
- handled << [klass, args]
+ allow(DiscourseWorkflows::EventListener).to receive(:handle) do |klass, *args, event_name:|
+ handled << [klass, args, event_name]
end
end
@@ -111,7 +111,7 @@ RSpec.describe DiscourseWorkflows::Registry do
expect(serialized[:metadata]).to eq("channels" => [{ id: 1, name: color }])
DiscourseEvent.trigger(:workflow_reload_test, color)
- expect(handled.last).to eq([current, [color]])
+ expect(handled.last).to eq([current, [color], :workflow_reload_test])
previous = current
end
diff --git a/spec/jobs/user_suspension_expired_spec.rb b/spec/jobs/user_suspension_expired_spec.rb
new file mode 100644
index 00000000000..3b8d12677ea
--- /dev/null
+++ b/spec/jobs/user_suspension_expired_spec.rb
@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+RSpec.describe Jobs::UserSuspensionExpired do
+ fab!(:user)
+
+ describe "#execute" do
+ it "announces an expired suspension once and preserves its history" do
+ freeze_time(Time.zone.now.round)
+ started_at = 1.day.ago
+ expiry = 1.hour.ago
+ user.update!(suspended_at: started_at, suspended_till: expiry)
+ args = {
+ user_id: user.id,
+ suspended_at: started_at.iso8601(UserSuspender::TIMESTAMP_PRECISION),
+ suspended_till: expiry.iso8601(UserSuspender::TIMESTAMP_PRECISION),
+ }
+
+ events =
+ DiscourseEvent.track_events(:user_unsuspended) do
+ described_class.new.execute(args)
+ described_class.new.execute(args)
+ user
+ .user_histories
+ .where(action: UserHistory.actions[:unsuspend_user])
+ .update_all(action: UserHistory.actions[:removed_unsuspend_user])
+ described_class.new.execute(args)
+ end
+
+ expect(user.reload).to have_attributes(suspended_at: started_at, suspended_till: expiry)
+ expect(events.map { |event| event[:params].first }).to contain_exactly(
+ user: user,
+ by_user: Discourse.system_user,
+ )
+ end
+
+ it "ignores replaced suspensions and early jobs" do
+ freeze_time(Time.zone.now.round)
+ expiry = 1.day.from_now
+ user.update!(suspended_at: 1.day.ago, suspended_till: 1.hour.ago)
+
+ events =
+ DiscourseEvent.track_events(:user_unsuspended) do
+ described_class.new.execute(
+ user_id: user.id,
+ suspended_at: user.suspended_at.iso8601(UserSuspender::TIMESTAMP_PRECISION),
+ suspended_till: 2.hours.ago.iso8601(UserSuspender::TIMESTAMP_PRECISION),
+ )
+ user.update!(suspended_till: expiry)
+ described_class.new.execute(
+ user_id: user.id,
+ suspended_at: user.suspended_at.iso8601(UserSuspender::TIMESTAMP_PRECISION),
+ suspended_till: expiry.iso8601(UserSuspender::TIMESTAMP_PRECISION),
+ )
+ end
+
+ expect(user.reload.suspended_till).to eq(expiry)
+ expect(events).to be_empty
+ end
+
+ it "distinguishes separate suspensions with the same expiry" do
+ freeze_time(Time.zone.now.round)
+ expiry = 1.hour.ago
+ user.update!(suspended_at: 2.days.ago, suspended_till: expiry)
+ args = {
+ user_id: user.id,
+ suspended_at: user.suspended_at.iso8601(UserSuspender::TIMESTAMP_PRECISION),
+ suspended_till: expiry.iso8601(UserSuspender::TIMESTAMP_PRECISION),
+ }
+
+ events =
+ DiscourseEvent.track_events(:user_unsuspended) do
+ described_class.new.execute(args)
+ user.update!(suspended_at: 1.day.ago)
+ described_class.new.execute(args)
+ described_class.new.execute(
+ args.merge(suspended_at: user.suspended_at.iso8601(UserSuspender::TIMESTAMP_PRECISION)),
+ )
+ end
+
+ expect(events.size).to eq(2)
+ expect(user.reload).to have_attributes(suspended_at: 1.day.ago, suspended_till: expiry)
+ end
+
+ it "retries notification when an event listener fails" do
+ user.update!(suspended_at: 1.day.ago, suspended_till: 1.hour.ago)
+ args = {
+ user_id: user.id,
+ suspended_at: user.suspended_at.iso8601(UserSuspender::TIMESTAMP_PRECISION),
+ suspended_till: user.suspended_till.iso8601(UserSuspender::TIMESTAMP_PRECISION),
+ }
+ handler = proc { raise "Listener unavailable" }
+ DiscourseEvent.on(:user_unsuspended, &handler)
+
+ expect { described_class.new.execute(args) }.to raise_error("Listener unavailable")
+ DiscourseEvent.off(:user_unsuspended, &handler)
+ events = DiscourseEvent.track_events(:user_unsuspended) { described_class.new.execute(args) }
+
+ expect(events.size).to eq(1)
+ ensure
+ DiscourseEvent.off(:user_unsuspended, &handler) if handler
+ end
+ end
+end
diff --git a/spec/services/user_suspender_spec.rb b/spec/services/user_suspender_spec.rb
index bb99866068f..e5ef4afe188 100644
--- a/spec/services/user_suspender_spec.rb
+++ b/spec/services/user_suspender_spec.rb
@@ -19,12 +19,22 @@ RSpec.describe UserSuspender do
)
end
- it "suspends the user correctly" do
- freeze_time
+ it "suspends the user and schedules automatic expiry" do
+ freeze_time(Time.zone.now.round)
+
suspend_user
+
expect(user.reload).to be_suspended
expect(user.suspended_till).to be_within_one_second_of(5.hours.from_now)
expect(user.suspended_at).to be_within_one_second_of(Time.zone.now)
+
+ job = Jobs::UserSuspensionExpired.jobs.last
+ expect(job["at"]).to eq(user.suspended_till.to_f)
+ expect(job["args"].first).to include(
+ "user_id" => user.id,
+ "suspended_at" => user.suspended_at.iso8601(UserSuspender::TIMESTAMP_PRECISION),
+ "suspended_till" => user.suspended_till.iso8601(UserSuspender::TIMESTAMP_PRECISION),
+ )
end
it "creates a staff action log" do
@@ -66,12 +76,13 @@ RSpec.describe UserSuspender do
end
it "fires a user_suspended event" do
- freeze_time
+ freeze_time(Time.zone.now.round)
events = DiscourseEvent.track_events(:user_suspended) { suspend_user }
expect(events.size).to eq(1)
params = events[0][:params].first
expect(params[:user].id).to eq(user.id)
+ expect(params[:by_user]).to eq(admin)
expect(params[:reason]).to eq("because")
expect(params[:message]).to eq("you have been suspended")
expect(params[:suspended_till]).to be_within_one_second_of(5.hours.from_now)
@@ -105,4 +116,31 @@ RSpec.describe UserSuspender do
end
end
end
+
+ describe ".unsuspend" do
+ it "preserves the suspension on listener failure and identifies the moderator on retry" do
+ user.update!(suspended_at: 1.hour.ago, suspended_till: 1.day.from_now)
+ handler = proc { raise "Listener unavailable" }
+ DiscourseEvent.on(:user_unsuspended, &handler)
+
+ expect do described_class.unsuspend(user, by_user: admin) end.to raise_error(
+ "Listener unavailable",
+ )
+ expect(user.reload).to be_suspended
+
+ DiscourseEvent.off(:user_unsuspended, &handler)
+ events =
+ DiscourseEvent.track_events(:user_unsuspended) do
+ described_class.unsuspend(user, by_user: admin)
+ end
+
+ expect(user.reload).to have_attributes(suspended_at: nil, suspended_till: nil)
+ expect(events.map { |event| event[:params].first }).to contain_exactly(
+ user: user,
+ by_user: admin,
+ )
+ ensure
+ DiscourseEvent.off(:user_unsuspended, &handler) if handler
+ end
+ end
end