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.ymlindex 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.ymlindex 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.rbindex 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.rbnew file mode 100644index 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+enddiff --git a/plugins/discourse-workflows/plugin.rb b/plugins/discourse-workflows/plugin.rbindex 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.rbnew file mode 100644index 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+enddiff --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.rbnew file mode 100644index 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