Skip to content

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

FEATURE: adds a flag user workflow action (#42404)

Joffrey JAFFEUXc8f9425949d3
diff --git a/plugins/discourse-workflows/config/locales/client.en.yml b/plugins/discourse-workflows/config/locales/client.en.yml
index 04baa0d8f4c..bdced5d422a 100644
--- a/plugins/discourse-workflows/config/locales/client.en.yml
+++ b/plugins/discourse-workflows/config/locales/client.en.yml
@@ -269,6 +269,7 @@ en:
"action:modal": "Modal"
"action:topic_category": "Topic category"
"action:topic_pin": "Topic pinning"
+ "action:flag_user": "Flag user"
node_descriptions:
"trigger:topic_closed": "Fires when a topic is closed by a user or auto-close timer"
"trigger:post_created": "Fires when a new post or reply is created"
@@ -326,6 +327,7 @@ en:
"action:modal": "Shows a modal to a user and waits for them to choose an option"
"action:topic_category": "Set or clear the category of a topic"
"action:topic_pin": "Pin or unpin a topic in its category, globally, or as a banner"
+ "action:flag_user": "Add a user to the review queue for a moderator to approve or reject. Best aimed at unapproved accounts, since approved ones can only be rejected by deletion"
topic_admin_button:
label: "Button label"
label_placeholder: "Run workflow"
@@ -576,7 +578,12 @@ en:
spam: "Flag as spam and hide post"
spam_silence: "Flag as spam, hide post and silence user"
reason: "Reason"
- reason_description: "Optional note shown to moderators alongside the flag in the review queue"
+ actor_username: "Performed by user"
+ flag_user:
+ username: "User"
+ reason: "Reason"
+ reopen_resolved: "Reopen resolved reviews"
+ reopen_resolved_description: "Send the user back to the queue even when their review item was already approved or rejected. Off by default so workflows don't reopen settled moderator decisions."
actor_username: "Performed by user"
topic:
operation: "Operation"
diff --git a/plugins/discourse-workflows/config/locales/server.en.yml b/plugins/discourse-workflows/config/locales/server.en.yml
index 1131bcd08c4..21f2f955a29 100644
--- a/plugins/discourse-workflows/config/locales/server.en.yml
+++ b/plugins/discourse-workflows/config/locales/server.en.yml
@@ -94,6 +94,9 @@ en:
actor_not_staff: "The acting user must be a staff member to flag posts."
cannot_flag: "This post cannot be flagged as spam. It may already be hidden or authored by a staff member."
flag_failed: "Failed to flag post: %{errors}"
+ flag_user:
+ actor_not_staff: "The acting user must be a staff member to flag users."
+ cannot_flag_staff: "'%{username}' cannot be flagged. Staff members and automated accounts cannot be added to the review queue."
user:
unknown_operation: "Unknown operation: %{operation}."
unknown_extensions: "Unknown user extensions: %{extensions}."
@@ -182,6 +185,8 @@ en:
flagged_by_workflow: "Flagged by the '%{workflow_name}' workflow."
user:
check_email_context: "Workflow user node"
+ flag_user:
+ flagged_by_workflow: "Flagged by the '%{workflow_name}' workflow."
pin_data:
errors:
unsupported_node: "Only nodes with a single output can have pinned data."
@@ -191,6 +196,8 @@ en:
hints:
split_out:
field_not_found: "The field '%{field}' wasn't found in any input item."
+ flag_user:
+ already_resolved: "'%{username}' already has a review item with status '%{status}'. Turn on \"Reopen resolved reviews\" if this workflow should send them back to the queue."
site_settings:
enable_discourse_workflows: "Enable the discourse-workflows plugin."
discourse_workflows_ai_authoring_enabled: "Enable AI-assisted workflow authoring."
@@ -238,3 +245,6 @@ en:
search_chat_integration_channels: "Searched external chat integration channels"
workflow_script_context: "Loaded script context"
workflow_validate_script: "Validated script"
+ reviewables:
+ reasons:
+ workflow_flagged_user: "A workflow added this user to the review queue."
diff --git a/plugins/discourse-workflows/lib/discourse_workflows/ai/tools/workflow_node_catalog.rb b/plugins/discourse-workflows/lib/discourse_workflows/ai/tools/workflow_node_catalog.rb
index d9d53f20fda..42d3e9dce51 100644
--- a/plugins/discourse-workflows/lib/discourse_workflows/ai/tools/workflow_node_catalog.rb
+++ b/plugins/discourse-workflows/lib/discourse_workflows/ai/tools/workflow_node_catalog.rb
@@ -215,6 +215,8 @@ module DiscourseWorkflows
"action:ai_agent" =>
"ai agent bot llm classify summarize generate sentiment triage runner run as permissions uploads attachments",
"action:group" => "group membership member belongs friend friends",
+ "action:flag_user" =>
+ "flag user report spammer spam suspect review queue moderation approve reject account signup",
"trigger:user_added_to_group" => "joined added to group membership member",
"trigger:user_removed_from_group" => "left removed from group membership member",
"trigger:user_created" => "signup sign up register registration new account joined site",
diff --git a/plugins/discourse-workflows/lib/discourse_workflows/nodes/flag_user/v1.rb b/plugins/discourse-workflows/lib/discourse_workflows/nodes/flag_user/v1.rb
new file mode 100644
index 00000000000..9b1c2fd622d
--- /dev/null
+++ b/plugins/discourse-workflows/lib/discourse_workflows/nodes/flag_user/v1.rb
@@ -0,0 +1,229 @@
+# frozen_string_literal: true
+
+module DiscourseWorkflows
+ module Nodes
+ module FlagUser
+ class V1 < NodeType
+ # A fixed reason so the review queue renders a translated sentence rather
+ # than a workflow-supplied string. Provenance lives in a note.
+ SCORE_REASON = "workflow_flagged_user"
+
+ description(
+ name: "action:flag_user",
+ version: "1.0",
+ defaults: {
+ icon: "user-xmark",
+ color: "red",
+ },
+ group: "discourse_actions",
+ capabilities: {
+ run_scope: "per_item",
+ },
+ output_contracts: [
+ {
+ schema: {
+ "$schema" => Schema::DRAFT_URI,
+ "type" => "object",
+ "properties" => {
+ "user_id" => {
+ "type" => "integer",
+ },
+ "username" => {
+ "type" => "string",
+ },
+ "reviewable_id" => {
+ "type" => "integer",
+ },
+ "reviewable_status" => {
+ "type" => "string",
+ },
+ "reviewable_created" => {
+ "type" => "boolean",
+ },
+ "score_added" => {
+ "type" => "boolean",
+ },
+ "user_approved" => {
+ "type" => "boolean",
+ },
+ },
+ },
+ },
+ ],
+ properties: {
+ username: {
+ type: :string,
+ required: true,
+ ui: {
+ control: :user,
+ },
+ },
+ reason: {
+ type: :string,
+ required: false,
+ ui: {
+ control: :textarea,
+ },
+ },
+ reopen_resolved: {
+ type: :boolean,
+ required: false,
+ default: false,
+ ui: {
+ control: :boolean,
+ expression: true,
+ },
+ },
+ actor_username: {
+ type: :string,
+ required: false,
+ default: "system",
+ ui: {
+ control: :actor,
+ },
+ },
+ },
+ )
+
+ def execute(exec_ctx)
+ items =
+ exec_ctx.input_items.map.with_index do |_item, item_index|
+ config = {
+ "username" => exec_ctx.get_node_parameter("username", item_index),
+ "reason" => exec_ctx.get_node_parameter("reason", item_index),
+ "reopen_resolved" =>
+ exec_ctx.get_node_parameter("reopen_resolved", item_index, default: false),
+ }
+
+ wrap(process(exec_ctx, config, item_index))
+ end
+
+ [items]
+ end
+
+ private
+
+ def process(exec_ctx, config, item_index)
+ actor = exec_ctx.actor_from_parameter("actor_username", item_index)
+ if !actor.staff?
+ raise_node_error!(I18n.t("discourse_workflows.errors.flag_user.actor_not_staff"))
+ end
+
+ user = exec_ctx.find_user(username: config["username"])
+ ensure_flaggable!(user)
+
+ resolved = resolved_reviewable_for(user)
+ if resolved.present? && !config["reopen_resolved"]
+ add_already_resolved_hint(exec_ctx, user, resolved)
+ return output(user, resolved, created: false, score_added: false)
+ end
+
+ reviewable =
+ ::ReviewableUser.needs_review!(
+ target: user,
+ created_by: actor,
+ reviewable_by_moderator: true,
+ potential_spam: false,
+ payload: reviewable_payload(user),
+ )
+ score_added = add_review_score(reviewable, actor)
+ add_provenance_note(exec_ctx, reviewable, actor, config["reason"])
+
+ output(
+ user,
+ reviewable,
+ created: reviewable.created_new.present?,
+ score_added: score_added,
+ )
+ end
+
+ def ensure_flaggable!(user)
+ return if !user.staff? && !user.bot?
+
+ raise_node_error!(
+ I18n.t(
+ "discourse_workflows.errors.flag_user.cannot_flag_staff",
+ username: user.username,
+ ),
+ )
+ end
+
+ def resolved_reviewable_for(user)
+ ::ReviewableUser
+ .where(target: user)
+ .where.not(status: ::Reviewable.statuses[:pending])
+ .first
+ end
+
+ def reviewable_payload(user)
+ profile = user.user_profile
+
+ {
+ username: user.username,
+ name: user.name,
+ email: user.email,
+ bio: profile&.bio_raw,
+ website: profile&.website,
+ }
+ end
+
+ def add_review_score(reviewable, actor)
+ score_type = ::ReviewableScore.types[:needs_approval]
+
+ if reviewable.reviewable_scores.pending.exists?(
+ user_id: actor.id,
+ reviewable_score_type: score_type,
+ reason: SCORE_REASON,
+ )
+ return false
+ end
+
+ reviewable.add_score(actor, score_type, reason: SCORE_REASON, force_review: true)
+ true
+ end
+
+ def add_provenance_note(exec_ctx, reviewable, actor, custom_reason)
+ parts = [
+ I18n.t(
+ "discourse_workflows.flag_user.flagged_by_workflow",
+ workflow_name: exec_ctx.get_workflow.name,
+ ),
+ ]
+ custom_reason = custom_reason.to_s.strip
+ parts << custom_reason if custom_reason.present?
+
+ content = parts.join("\n\n").truncate(::ReviewableNote::MAX_CONTENT_LENGTH)
+ return if reviewable.reviewable_notes.exists?(user_id: actor.id, content: content)
+
+ reviewable.reviewable_notes.create!(user: actor, content: content)
+ end
+
+ def add_already_resolved_hint(exec_ctx, user, reviewable)
+ exec_ctx.add_execution_hints(
+ {
+ message:
+ I18n.t(
+ "discourse_workflows.hints.flag_user.already_resolved",
+ username: user.username,
+ status: reviewable.status,
+ ),
+ location: "outputPane",
+ },
+ )
+ end
+
+ def output(user, reviewable, created:, score_added:)
+ {
+ user_id: user.id,
+ username: user.username,
+ reviewable_id: reviewable.id,
+ reviewable_status: reviewable.status,
+ reviewable_created: created,
+ score_added: score_added,
+ user_approved: user.approved?,
+ }
+ end
+ end
+ end
+ end
+end
diff --git a/plugins/discourse-workflows/plugin.rb b/plugins/discourse-workflows/plugin.rb
index 4bf3544cfe2..add6d8bc2ae 100644
--- a/plugins/discourse-workflows/plugin.rb
+++ b/plugins/discourse-workflows/plugin.rb
@@ -48,6 +48,7 @@ register_svg_icon "pause"
register_svg_icon "window-maximize"
register_svg_icon "user-plus"
register_svg_icon "user-minus"
+register_svg_icon "user-xmark"
register_svg_icon "grip-vertical"
register_svg_icon "paragraph"
register_svg_icon "arrow-down-a-z"
diff --git a/plugins/discourse-workflows/spec/integration/user_created_flag_user_spec.rb b/plugins/discourse-workflows/spec/integration/user_created_flag_user_spec.rb
new file mode 100644
index 00000000000..1caf84f3b42
--- /dev/null
+++ b/plugins/discourse-workflows/spec/integration/user_created_flag_user_spec.rb
@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+RSpec.describe "Workflow: user created -> flag user" do
+ fab!(:admin)
+
+ before do
+ Jobs::DiscourseWorkflows::ExecuteWorkflow.jobs.clear
+
+ graph =
+ build_workflow_graph do |g|
+ g.node "trigger-1", "trigger:user_created"
+ g.node "action-1",
+ "action:flag_user",
+ configuration: {
+ "username" => "={{ $trigger.user.username }}",
+ "reason" => "Automated signup screening",
+ }
+ g.chain "trigger-1", "action-1"
+ end
+
+ Fabricate(
+ :discourse_workflows_workflow,
+ created_by: admin,
+ published: true,
+ name: "Flag <b>spam</b> signups",
+ **graph,
+ )
+ end
+
+ it "queues the new signup for moderator review", :aggregate_failures do
+ user = Fabricate(:user)
+
+ job_data = Jobs::DiscourseWorkflows::ExecuteWorkflow.jobs.last
+ expect(job_data).to be_present
+
+ Jobs::DiscourseWorkflows::ExecuteWorkflow.new.execute(job_data["args"].first.symbolize_keys)
+
+ reviewable = ReviewableUser.pending.find_by(target: user)
+ expect(reviewable).to be_present
+ expect(reviewable.reviewable_scores.last.reason).to eq("workflow_flagged_user")
+
+ expect(reviewable.reviewable_notes.last.content).to eq(
+ "#{
+ I18n.t(
+ "discourse_workflows.flag_user.flagged_by_workflow",
+ workflow_name: "Flag <b>spam</b> signups",
+ )
+ }\n\nAutomated signup screening",
+ )
+
+ execution = DiscourseWorkflows::Execution.last
+ expect(execution.status).to eq("success")
+ end
+end
diff --git a/plugins/discourse-workflows/spec/lib/discourse_workflows/nodes/flag_user_spec.rb b/plugins/discourse-workflows/spec/lib/discourse_workflows/nodes/flag_user_spec.rb
new file mode 100644
index 00000000000..29ab725dd35
--- /dev/null
+++ b/plugins/discourse-workflows/spec/lib/discourse_workflows/nodes/flag_user_spec.rb
@@ -0,0 +1,260 @@
+# frozen_string_literal: true
+
+RSpec.describe DiscourseWorkflows::Nodes::FlagUser::V1 do
+ fab!(:moderator)
+ fab!(:admin)
+ fab!(:target, :user)
+ fab!(:workflow, :discourse_workflows_workflow)
+
+ let(:attribution) do
+ I18n.t("discourse_workflows.flag_user.flagged_by_workflow", workflow_name: workflow.name)
+ end
+
+ def flag(configuration = {}, item = { "json" => {} }, &block)
+ config = { "username" => target.username }.merge(configuration)
+ execute_node_output(configuration: config, item: item, workflow: workflow, &block)
+ .first
+ .first
+ .fetch("json")
+ end
+
+ describe "#execute" do
+ it "adds the user to the review queue", :aggregate_failures do
+ result = nil
+
+ expect { result = flag }.to change { ReviewableUser.pending.where(target: target).count }.by(
+ 1,
+ )
+
+ reviewable = ReviewableUser.pending.find_by(target: target)
+ score = reviewable.reviewable_scores.last
+
+ expect(score.reviewable_score_type).to eq(ReviewableScore.types[:needs_approval])
+ expect(score.user).to eq(Discourse.system_user)
+ expect(score.reason).to eq("workflow_flagged_user")
+ expect(result).to include(
+ "user_id" => target.id,
+ "username" => target.username,
+ "reviewable_id" => reviewable.id,
+ "reviewable_status" => "pending",
+ "reviewable_created" => true,
+ "score_added" => true,
+ "user_approved" => false,
+ )
+ end
+
+ it "matches the declared output contract" do
+ expect(flag).to match_node_output_schema(
+ described_class,
+ configuration: {
+ "username" => target.username,
+ },
+ )
+ end
+
+ it "snapshots the same payload fields core's suspect user job does" do
+ target.user_profile.update!(bio_raw: "Buy my links", website: "https://spam.example")
+
+ flag
+
+ payload = ReviewableUser.find_by(target: target).payload
+
+ expect(payload).to include(
+ "username" => target.username,
+ "name" => target.name,
+ "email" => target.email,
+ "bio" => "Buy my links",
+ "website" => "https://spam.example",
+ )
+ end
+
+ it "leaves the reviewable's spam flag alone" do
+ flag
+
+ expect(ReviewableUser.find_by(target: target).potential_spam).to eq(false)
+ end
+
+ it "records the workflow attribution as a note rather than in the score reason" do
+ flag("reason" => "Profile is link spam")
+
+ reviewable = ReviewableUser.find_by(target: target)
+ note = reviewable.reviewable_notes.last
+
+ expect(note.user).to eq(Discourse.system_user)
+ expect(note.content).to eq("#{attribution}\n\nProfile is link spam")
+ expect(reviewable.reviewable_scores.last.reason).to eq("workflow_flagged_user")
+ end
+
+ it "renders the score reason as a translated sentence in the review queue" do
+ flag
+
+ score = ReviewableUser.find_by(target: target).reviewable_scores.last
+ serialized = ReviewableScoreSerializer.new(score, scope: moderator.guardian, root: nil)
+
+ expect(serialized.reason).to match_html(<<~HTML)
+ <p>A workflow added this user to the review queue.</p>
+ HTML
+ end
+
+ it "offers moderators the approve and reject actions" do
+ flag
+
+ reviewable = ReviewableUser.find_by(target: target).reload
+
+ expect(reviewable.actions_for(moderator.guardian).to_a.map(&:server_action)).to eq(
+ %w[approve_user delete_user delete_user_block],
+ )
+ end
+ end
+
+ describe "idempotency" do
+ it "does not add a second score or note when the same flag runs again" do
+ flag("reason" => "Profile is link spam")
+
+ expect { flag("reason" => "Profile is link spam") }.to not_change {
+ ReviewableScore.count
+ }.and not_change { ReviewableNote.count }
+
+ expect(flag("reason" => "Profile is link spam")).to include(
+ "score_added" => false,
+ "reviewable_created" => false,
+ )
+ end
+ end
+
+ describe "resolved reviewables" do
+ before { ReviewableUser.create_for(target).update!(status: Reviewable.statuses[:approved]) }
+
+ it "leaves a settled moderator decision alone and explains why" do
+ hints = nil
+ result = nil
+
+ expect do
+ result =
+ execute_node_output(
+ configuration: {
+ "username" => target.username,
+ },
+ workflow: workflow,
+ ) { |ctx| hints = ctx.execution_hints }.first.first.fetch("json")
+ end.to not_change { ReviewableUser.find_by(target: target).status }.and not_change {
+ ReviewableScore.count
+ }
+
+ expect(result).to include("reviewable_status" => "approved", "score_added" => false)
+ expect(hints).to eq(
+ [
+ {
+ "message" =>
+ I18n.t(
+ "discourse_workflows.hints.flag_user.already_resolved",
+ username: target.username,
+ status: "approved",
+ ),
+ "location" => "outputPane",
+ },
+ ],
+ )
+ end
+
+ it "reopens the review when explicitly asked to" do
+ result = flag("reopen_resolved" => true)
+
+ expect(ReviewableUser.find_by(target: target).status).to eq("pending")
+ expect(result).to include("reviewable_status" => "pending", "score_added" => true)
+ end
+
+ it "reopens when an expression resolves to a truthy string" do
+ result =
+ flag({ "reopen_resolved" => "={{ $json.reopen }}" }, { "json" => { "reopen" => "true" } })
+
+ expect(ReviewableUser.find_by(target: target).status).to eq("pending")
+ expect(result).to include("score_added" => true)
+ end
+ end
+
+ describe "guards" do
+ it "rejects a non-staff actor" do
+ expect { flag("actor_username" => target.username) }.to raise_error(
+ DiscourseWorkflows::NodeError,
+ I18n.t("discourse_workflows.errors.flag_user.actor_not_staff"),
+ ).and not_change { Reviewable.count }
+ end
+
+ it "rejects the anonymous actor" do
+ expect { flag("actor_username" => "anonymous") }.to raise_error(
+ DiscourseWorkflows::NodeError,
+ I18n.t("discourse_workflows.errors.flag_user.actor_not_staff"),
+ ).and not_change { Reviewable.count }
+ end
+
+ it "refuses to flag staff" do
+ expect { flag("username" => moderator.username) }.to raise_error(
+ DiscourseWorkflows::NodeError,
+ I18n.t(
+ "discourse_workflows.errors.flag_user.cannot_flag_staff",
+ username: moderator.username,
+ ),
+ )
+ end
+
+ it "refuses to flag automated accounts" do
+ expect { flag("username" => Discourse.system_user.username) }.to raise_error(
+ DiscourseWorkflows::NodeError,
+ I18n.t(
+ "discourse_workflows.errors.flag_user.cannot_flag_staff",
+ username: Discourse.system_user.username,
+ ),
+ )
+ end
+
+ it "refuses a staff actor flagging their own account" do
+ expect { flag("username" => admin.username, "actor_username" => admin.username) }.to(
+ raise_error(
+ DiscourseWorkflows::NodeError,
+ I18n.t(
+ "discourse_workflows.errors.flag_user.cannot_flag_staff",
+ username: admin.username,
+ ),
+ ),
+ )
+ end
+
+ it "raises when the username does not resolve" do
+ expect { flag("username" => "nope") }.to raise_error(
+ DiscourseWorkflows::NodeError,
+ "User 'nope' not found",
+ )
+ end
+ end
+
+ describe "expressions" do
+ fab!(:other_user, :user)
+
+ it "resolves the username per item" do
+ output =
+ execute_node_output(
+ configuration: {
+ "username" => "={{ $json.username }}",
+ },
+ input_items: [
+ { "json" => { "username" => target.username } },
+ { "json" => { "username" => other_user.username } },
+ ],
+ workflow: workflow,
+ ).first
+
+ expect(output.map { |item| item.dig("json", "user_id") }).to eq([target.id, other_user.id])
+ end
+
+ it "resolves a nested username" do
+ result =
+ flag(
+ { "username" => "={{ $json.user.username }}" },
+ { "json" => { "user" => { "username" => target.username } } },
+ )
+
+ expect(result).to include("user_id" => target.id)
+ end
+ end
+end