Skip to content

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

FEATURE: Add group management tools to the MCP server (#44361)

Natalie Tay1d2bdfbc89ba
diff --git a/app/controllers/admin/groups_controller.rb b/app/controllers/admin/groups_controller.rb
index 4297e23eef3..de0887b854d 100644
--- a/app/controllers/admin/groups_controller.rb
+++ b/app/controllers/admin/groups_controller.rb
@@ -32,37 +32,28 @@ class Admin::GroupsController < Admin::StaffController
group = Group.find_by(id: params[:id])
raise Discourse::NotFound unless group
- if group.automatic
- can_not_modify_automatic
- else
- StaffActionLogger.new(current_user).log_group_deletion(group)
+ GroupDestroyer.destroy(guardian, group)
- group.destroy!
- render json: success_json
- end
+ render json: success_json
+ rescue GroupMutations::AutomaticGroup => error
+ render_json_error(error.message)
end
def remove_owner
group = Group.find_by(id: params.require(:id))
raise Discourse::NotFound unless group
- return can_not_modify_automatic if group.automatic
- guardian.ensure_can_edit_group!(group)
-
- if params[:user_id].present?
- users = [User.find_by(id: params[:user_id].to_i)]
- elsif usernames = group_params[:usernames].presence
- users = User.where(username: usernames.split(","))
- else
- raise Discourse::InvalidParameters.new(:user_id)
- end
-
- users.each do |user|
- group.group_users.where(user_id: user.id).update_all(owner: false)
- GroupActionLogger.new(current_user, group).log_remove_user_as_group_owner(user)
- end
+ user_id = params[:user_id]
+ GroupOwnerManager.remove(
+ guardian,
+ group,
+ user_id:,
+ usernames: user_id.present? ? nil : group_params[:usernames],
+ )
render json: success_json
+ rescue GroupMutations::AutomaticGroup => error
+ render_json_error(error.message)
end
def set_primary
diff --git a/app/controllers/groups_controller.rb b/app/controllers/groups_controller.rb
index ed2c4437c68..18134c7f4f7 100644
--- a/app/controllers/groups_controller.rb
+++ b/app/controllers/groups_controller.rb
@@ -24,7 +24,6 @@ class GroupsController < ApplicationController
after_action :add_noindex_header
TYPE_FILTERS = GroupDirectoryQuery::TYPE_FILTERS
- ADD_MEMBERS_LIMIT = 1000
def index
page = fetch_int_from_params(:page, default: 0)
@@ -104,43 +103,21 @@ class GroupsController < ApplicationController
group = Group.find(params[:id])
guardian.ensure_can_edit!(group) if !guardian.can_admin_group?(group)
- group_attributes = group_params(automatic: group.automatic, group:)
- reset_group_email_settings_if_disabled!(group, group_attributes)
-
- categories, tags = []
- if !group.automatic || current_user.admin
- notification_level, categories, tags = user_default_notifications(group, group_attributes)
-
- if params[:update_existing_users].blank?
- user_count = count_existing_users(group.group_users, notification_level, categories, tags)
- if user_count > 0
- return(
- render status: :unprocessable_entity,
- json: {
- user_count: user_count,
- errors: [
- I18n.t("groups.errors.update_existing_users_required", count: user_count),
- ],
- }
- )
- end
- end
- end
-
- if group.update(group_attributes)
- GroupActionLogger.new(current_user, group).log_change_group_settings
- group.record_email_setting_changes!(current_user)
- if params[:update_existing_users] == "true"
- update_existing_users(group.group_users, notification_level, categories, tags)
- end
+ attributes = params.require(:group).permit(*GroupUpdater.permitted_params(guardian, group:))
+ updated =
+ GroupUpdater.update(guardian, group, attributes, update_existing_users: existing_users_choice)
+ return render_json_error(group) if !updated
- # Redirect user to groups index page if they can no longer see the group
- return redirect_with_client_support groups_path if !guardian.can_see?(group)
+ # Redirect user to groups index page if they can no longer see the group
+ return redirect_with_client_support groups_path if !guardian.can_see?(group)
- render json: success_json
- else
- render_json_error(group)
- end
+ render json: success_json
+ rescue GroupUpdater::ExistingUsersConfirmationRequired => error
+ render status: :unprocessable_entity,
+ json: {
+ user_count: error.user_count,
+ errors: [error.message],
+ }
end
def posts
@@ -323,108 +300,56 @@ class GroupsController < ApplicationController
def add_members
group = Group.find(params[:id])
- guardian.ensure_can_edit!(group)
-
- users = users_from_params.to_a
- emails = []
- if params[:emails]
- params[:emails]
- .split(",")
- .each do |email|
- existing_user = User.find_by_email(email)
- existing_user.present? ? users.push(existing_user) : emails.push(email)
- end
- end
-
- if emails.present? && !guardian.can_invite_to_forum?([group])
- return render_json_error(I18n.t("groups.errors.cannot_add_emails"))
- end
-
- if users.empty? && emails.empty?
- raise Discourse::InvalidParameters.new(I18n.t("groups.errors.usernames_or_emails_required"))
- end
- if users.length > ADD_MEMBERS_LIMIT
- return(
- render_json_error(I18n.t("groups.errors.adding_too_many_users", count: ADD_MEMBERS_LIMIT))
- )
- end
-
- usernames_already_in_group = group.users.where(id: users.map(&:id)).pluck(:username)
- if usernames_already_in_group.present? && usernames_already_in_group.length == users.length &&
- emails.blank?
- render_json_error(
- I18n.t(
- "groups.errors.member_already_exist",
- username: usernames_already_in_group.sort.join(", "),
- count: usernames_already_in_group.size,
- ),
+ result =
+ GroupMemberAdder.add(
+ guardian,
+ group,
+ **user_selectors,
+ emails: params[:emails],
+ notify_users: notify_users_choice,
+ skip_email: params[:skip_email].to_s == "true",
)
- else
- notify = params[:notify_users]&.to_s == "true"
-
- uniq_users = users.uniq
- add_users_to_group(group, uniq_users, notify)
-
- group_ids = [group.id]
-
- skip_email = params[:skip_email].to_s == "true"
- skip_email ||= params.key?(:notify_users) && !notify
-
- emails.each do |email|
- Invite.generate(current_user, email:, group_ids:, skip_email:)
- rescue RateLimiter::LimitExceeded => e
- return(
- render_json_error(
- I18n.t(
- "invite.rate_limit",
- count: SiteSetting.max_invites_per_day,
- time_left: e.time_left,
- ),
- )
- )
- end
- render json: success_json.merge!(usernames: uniq_users.map(&:username), emails: emails)
- end
+ render json: success_json.merge!(usernames: result[:usernames], emails: result[:emails])
+ rescue GroupMemberAdder::EmailsNotAllowed,
+ GroupMemberAdder::TooManyUsers,
+ GroupMemberAdder::AlreadyMembers => error
+ render_json_error(error.message)
+ rescue RateLimiter::LimitExceeded => error
+ render_json_error(
+ I18n.t(
+ "invite.rate_limit",
+ count: SiteSetting.max_invites_per_day,
+ time_left: error.time_left,
+ ),
+ )
end
def add_owners
group = Group.find_by(id: params.require(:id))
raise Discourse::NotFound unless group
- return can_not_modify_automatic if group.automatic
- guardian.ensure_can_edit_group!(group)
-
- users = users_from_params
- group_action_logger = GroupActionLogger.new(current_user, group)
-
- users.each do |user|
- if !group.users.include?(user)
- group.add(user)
- group_action_logger.log_add_user_to_group(user)
- end
- group.group_users.where(user_id: user.id).update_all(owner: true)
- group_action_logger.log_make_user_group_owner(user)
-
- group.notify_added_to_group(user, owner: true) if params[:notify_users].to_s == "true"
- end
+ result =
+ GroupOwnerManager.add(
+ guardian,
+ group,
+ **user_selectors,
+ notify_users: params[:notify_users].to_s == "true",
+ )
- render json: success_json.merge!(usernames: users.pluck(:username))
+ render json: success_json.merge!(usernames: result[:usernames])
+ rescue GroupMutations::AutomaticGroup => error
+ render_json_error(error.message)
end
def join
ensure_logged_in
- unless current_user.staff?
- RateLimiter.new(current_user, "public_group_membership", 3, 1.minute).performed!
- end
group = find_group_for_show
raise Discourse::NotFound unless group
- raise Discourse::InvalidAccess unless group.public_admission
- return if group.users.exists?(id: current_user.id)
- add_users_to_group(group, [current_user])
+ GroupSelfMembership.join(guardian, group)
end
def handle_membership_request
@@ -435,44 +360,7 @@ class GroupsController < ApplicationController
user = User.find_by(id: params[:user_id])
raise Discourse::InvalidParameters.new(:user_id) if user.blank?
- # find original membership request PM
- request_topic =
- Topic.find_by(
- title:
- I18n.t(
- "groups.request_membership_pm.title",
- group_name: group.name,
- locale: user.effective_locale,
- ),
- archetype: Archetype.private_message,
- user_id: user.id,
- )
-
- ActiveRecord::Base.transaction do
- if params[:accept]
- group.add(user)
- GroupActionLogger.new(current_user, group).log_add_user_to_group(user)
- end
-
- GroupRequest.where(group_id: group.id, user_id: user.id).delete_all
- end
-
- if params[:accept]
- PostCreator.new(
- current_user,
- post_type: Post.types[:regular],
- topic_id: request_topic.id,
- raw:
- I18n.t(
- "groups.request_accepted_pm.body",
- group_name: group.name,
- locale: user.effective_locale,
- ),
- reply_to_post_number: 1,
- target_usernames: user.username,
- skip_validations: true,
- ).create!
- end
+ GroupMembershipRequestHandler.handle(guardian, group, user, accept: params[:accept].present?)
render json: success_json
end
@@ -506,97 +394,43 @@ class GroupsController < ApplicationController
def remove_member
group = Group.find_by(id: params[:id])
raise Discourse::NotFound unless group
- guardian.ensure_can_edit!(group)
-
- # Maintain backwards compatibility
- params[:usernames] = params[:username] if params[:username].present?
- params[:user_emails] = params[:user_email] if params[:user_email].present?
- users = users_from_params
- if users.empty?
- raise Discourse::InvalidParameters.new("user_ids or usernames or user_emails must be present")
- end
-
- removed_user_ids = GroupManager.new(group).remove(users.map(&:id))
- GroupActionLogger.new(current_user, group).bulk_log_remove_users_from_group(removed_user_ids)
-
- removed_usernames = []
- skipped_usernames = []
-
- users.each do |user|
- if removed_user_ids.include?(user.id)
- removed_usernames << user.username
- else
- if group.users.exclude? user
- skipped_usernames << user.username
- else
- raise Discourse::InvalidParameters
- end
- end
- end
+ # maintain backwards compatibility with the singular param names
+ result =
+ GroupMemberRemover.remove(
+ guardian,
+ group,
+ usernames: params[:username].presence || params[:usernames],
+ user_id: params[:user_id],
+ user_ids: params[:user_ids],
+ user_emails: params[:user_email].presence || params[:user_emails],
+ )
- render json: success_json.merge!(usernames: removed_usernames, skipped_usernames:)
+ render json:
+ success_json.merge!(
+ usernames: result[:usernames],
+ skipped_usernames: result[:skipped_usernames],
+ )
end
def leave
ensure_logged_in
- unless current_user.staff?
- RateLimiter.new(current_user, "public_group_membership", 3, 1.minute).performed!
- end
group = Group.find_by(id: params[:id])
raise Discourse::NotFound unless group
- raise Discourse::InvalidAccess unless group.public_exit
- if group.remove(current_user)
- GroupActionLogger.new(current_user, group).log_remove_user_from_group(current_user)
- end
+ GroupSelfMembership.leave(guardian, group)
end
- MAX_NOTIFIED_OWNERS = 20
-
def request_membership
- params.require(:reason)
-
+ reason = params.require(:reason)
group = find_group(:name)
- raise Discourse::InvalidAccess unless group.allow_membership_requests?
- raise Discourse::InvalidAccess if group.users.exists?(id: current_user.id)
-
- begin
- GroupRequest.create!(group: group, user: current_user, reason: params[:reason])
- rescue ActiveRecord::RecordNotUnique
- return(
- render json: failed_json.merge(error: I18n.t("groups.errors.already_requested_membership")),
- status: :conflict
- )
- end
-
- usernames = [current_user.username].concat(
- group
- .users
- .where("group_users.owner")
- .order("users.last_seen_at DESC")
- .limit(MAX_NOTIFIED_OWNERS)
- .pluck("users.username"),
- )
-
- post =
- PostCreator.new(
- current_user,
- title: I18n.t("groups.request_membership_pm.title", group_name: group.name),
- raw: params[:reason],
- archetype: Archetype.private_message,
- target_usernames: usernames.join(","),
- topic_opts: {
- custom_fields: {
- requested_group_id: group.id,
- },
- },
- skip_validations: true,
- ).create!
+ post = GroupMembershipRequester.request(guardian, group, reason)
render json: success_json.merge(relative_url: post.topic.relative_url)
+ rescue GroupMembershipRequester::AlreadyRequested => error
+ render json: failed_json.merge(error: error.message), status: :conflict
end
def set_notifications
@@ -727,91 +561,26 @@ class GroupsController < ApplicationController
end
end
- protected
-
- def can_not_modify_automatic
- render_json_error(I18n.t("groups.errors.can_not_modify_automatic"))
- end
-
private
- def add_users_to_group(group, users, notify = false)
- user_ids = users.map(&:id)
- added_user_ids = GroupManager.new(group).add(user_ids)
- GroupActionLogger.new(current_user, group).bulk_log_add_users_to_group(added_user_ids)
- if notify && added_user_ids.present?
- Jobs.enqueue(:notify_users_added_to_group, user_ids: added_user_ids, group_id: group.id)
- end
+ def user_selectors
+ {
+ usernames: params[:usernames],
+ user_id: params[:user_id],
+ user_ids: params[:user_ids],
+ user_emails: params[:user_emails],
+ }
end
- def group_params(automatic: false, group: nil)
- attributes = %i[
- bio_raw
- default_notification_level
- messageable_level
- mentionable_level
- flair_bg_color
- flair_color
- flair_icon
- flair_upload_id
- ]
-
- if !automatic
- attributes.push(
- :allow_membership_requests,
- :full_name,
- :public_exit,
- :public_admission,
- :membership_request_template,
- )
- end
-
- attributes.push(:visibility_level, :members_visibility_level) if current_user.staff?
-
- if !automatic && current_user.staff?
- attributes.push(
- :incoming_email,
- :title,
- :primary_group,
- :name,
- :grant_trust_level,
- :publish_read_state,
- )
-
- custom_fields = DiscoursePluginRegistry.editable_group_custom_fields
- attributes << { custom_fields: custom_fields } if custom_fields.present?
- end
-
- if !automatic && current_user.admin
- attributes.push(
- :smtp_server,
- :smtp_port,
- :smtp_ssl_mode,
- :smtp_enabled,
- :smtp_updated_by,
- :smtp_updated_at,
- :email_username,
- :email_password,
- :email_from_alias,
- :allow_unknown_sender_topic_replies,
- )
- end
-
- if !automatic && group && guardian.can_admin_group?(group)
- attributes.push(:automatic_membership_email_domains)
- end
-
- if !automatic || current_user.admin
- %i[muted regular tracking watching watching_first_post].each do |level|
- attributes << { "#{level}_category_ids" => [] }
- attributes << { "#{level}_tags" => [] }
- end
- end
-
- attributes << { associated_group_ids: [] } if guardian.can_associate_groups?
- attributes.concat(DiscoursePluginRegistry.group_params)
+ # nil when the caller said nothing, so the mutation keeps its own default
+ def notify_users_choice
+ return nil if !params.key?(:notify_users)
+ params[:notify_users].to_s == "true"
+ end
- params.require(:group).permit(*attributes)
+ def existing_users_choice
+ return nil if params[:update_existing_users].blank?
+ params[:update_existing_users] == "true"
end
def find_group_for_show(ensure_can_see: true)
@@ -834,225 +603,4 @@ class GroupsController < ApplicationController
raise Discourse::NotFound if ensure_can_see && !guardian.can_see_group?(group)
group
end
-
- def users_from_params
- if params[:usernames].present?
- users = User.where(username_lower: params[:usernames].split(",").map(&:downcase))
- raise Discourse::InvalidParameters.new(:usernames) if users.blank?
- elsif params[:user_id].present?
- users = User.where(id: params[:user_id].to_i)
- raise Discourse::InvalidParameters.new(:user_id) if users.blank?
- elsif params[:user_ids].present?
- users = User.where(id: params[:user_ids].to_s.split(","))
- raise Discourse::InvalidParameters.new(:user_ids) if users.blank?
- elsif params[:user_emails].present?
- users = User.with_email(params[:user_emails].split(","))
- raise Discourse::InvalidParameters.new(:user_emails) if users.blank?
- else
- users = []
- end
- users
- end
-
- def reset_group_email_settings_if_disabled!(group, attributes)
- should_clear_smtp = group.smtp_enabled && attributes[:smtp_enabled] == "false"
-
- if should_clear_smtp
- attributes[:smtp_server] = nil
- attributes[:smtp_ssl_mode] = Group.smtp_ssl_modes[:none]
- attributes[:smtp_port] = nil
- attributes[:email_username] = nil
- attributes[:email_password] = nil
- end
- end
-
- def user_default_notifications(group, params)
- category_notifications =
- group.group_category_notification_defaults.pluck(:category_id, :notification_level).to_h
- tag_notifications =
- group.group_tag_notification_defaults.pluck(:tag_id, :notification_level).to_h
- categories = {}
- tags = {}
-
- NotificationLevels.all.each do |key, value|
- category_ids = (params[:"#{key}_category_ids"] || []) - ["-1"]
-
- category_ids.each do |category_id|
- category_id = category_id.to_i
- old_value = category_notifications[category_id]
-
- metadata = { old_value: old_value, new_value: value }
-
- if old_value.blank?
- metadata[:action] = :create
- elsif old_value == value
- category_notifications.delete(category_id)
- next
- else
- metadata[:action] = :update
- end
-
- categories[category_id] = metadata
- end
-
- tag_names = (params[:"#{key}_tags"] || []) - ["-1"]
- tag_ids = Tag.where(name: tag_names).pluck(:id)
-
- tag_ids.each do |tag_id|
- old_value = tag_notifications[tag_id]
-
- metadata = { old_value: old_value, new_value: value }
-
- if old_value.blank?
- metadata[:action] = :create
- elsif old_value == value
- tag_notifications.delete(tag_id)
- next
- else
- metadata[:action] = :update
- end
-
- tags[tag_id] = metadata
- end
- end
-
- (category_notifications.keys - categories.keys).each do |category_id|
- categories[category_id] = { action: :delete, old_value: category_notifications[category_id] }
- end
-
- (tag_notifications.keys - tags.keys).each do |tag_id|
- tags[tag_id] = { action: :delete, old_value: tag_notifications[tag_id] }
- end
-
- notification_level = nil
- default_notification_level = params[:default_notification_level]&.to_i
-
- if default_notification_level.present? &&
- group.default_notification_level != default_notification_level
- notification_level = {
- old_value: group.default_notification_level,
- new_value: default_notification_level,
- }
- end
-
- [notification_level, categories, tags]
- end
-
- %i[count update].each do |action|
- define_method("#{action}_existing_users") do |group_users, notification_level, categories, tags|
- return 0 if notification_level.blank? && categories.blank? && tags.blank?
-
- ids = []
-
- if notification_level.present?
- users = group_users.where(notification_level: notification_level[:old_value])
-
- if action == :update
- users.update_all(notification_level: notification_level[:new_value])
- else
- ids += users.pluck(:user_id)
- end
- end
-
- categories.each do |category_id, data|
- if data[:action] == :update || data[:action] == :delete
- category_users =
- CategoryUser.where(
- category_id: category_id,
- notification_level: data[:old_value],
- user_id: group_users.select(:user_id),
- )
-
- if action == :update
- category_users.delete_all
- else
- ids += category_users.pluck(:user_id)
- end
-
- categories.delete(category_id) if data[:action] == :delete && action == :update
- end
- end
-
- tags.each do |tag_id, data|
- if data[:action] == :update || data[:action] == :delete
- tag_users =
- TagUser.where(
- tag_id: tag_id,
- notification_level: data[:old_value],
- user_id: group_users.select(:user_id),
- )
-
- if action == :update
- tag_users.delete_all
- else
- ids += tag_users.pluck(:user_id)
- end
-
- tags.delete(tag_id) if data[:action] == :delete && action == :update
- end
- end
-
- if categories.present? || tags.present?
- group_users
- .select(:id, :user_id)
- .find_in_batches do |batch|
- user_ids = batch.pluck(:user_id)
-
- categories.each do |category_id, data|
- category_users = []
- existing_users =
- CategoryUser
- .where(category_id:, user_id: user_ids)
- .where.not(notification_level: nil)
- skip_user_ids = existing_users.pluck(:user_id)
-
- batch.each do |group_user|
- next if skip_user_ids.include?(group_user.user_id)
- category_users << {
- category_id: category_id,
- user_id: group_user.user_id,
- notification_level: data[:new_value],
- }
- end
-
- next if category_users.blank?
-
- if action == :update
- CategoryUser.insert_all!(category_users)
- else
- ids += category_users.pluck(:user_id)
- end
- end
-
- tags.each do |tag_id, data|
- tag_users = []
- existing_users =
- TagUser.where(tag_id:, user_id: user_ids).where.not(notification_level: nil)
- skip_user_ids = existing_users.pluck(:user_id)
-
- batch.each do |group_user|
- next if skip_user_ids.include?(group_user.user_id)
- tag_users << {
- tag_id: tag_id,
- user_id: group_user.user_id,
- notification_level: data[:new_value],
- created_at: Time.now,
- updated_at: Time.now,
- }
- end
-
- next if tag_users.blank?
-
- if action == :update
- TagUser.insert_all!(tag_users)
- else
- ids += tag_users.pluck(:user_id)
- end
- end
- end
- end
-
- ids.uniq.count
- end
- end
end
diff --git a/app/jobs/regular/notify_users_added_to_group.rb b/app/jobs/regular/notify_users_added_to_group.rb
index 5d2f2042335..8d60c14ce0b 100644
--- a/app/jobs/regular/notify_users_added_to_group.rb
+++ b/app/jobs/regular/notify_users_added_to_group.rb
@@ -10,7 +10,9 @@ module Jobs
group = Group.find_by(id: group_id)
return if group.nil?
- User.where(id: user_ids).find_each { |user| group.notify_added_to_group(user) }
+ User
+ .where(id: user_ids)
+ .find_each { |user| group.notify_added_to_group(user, owner: args[:owner] == true) }
end
end
end
diff --git a/app/models/group_tag_notification_default.rb b/app/models/group_tag_notification_default.rb
index cb9f392f9d7..9ef6bf785cf 100644
--- a/app/models/group_tag_notification_default.rb
+++ b/app/models/group_tag_notification_default.rb
@@ -12,6 +12,16 @@ class GroupTagNotificationDefault < ActiveRecord::Base
where(group: group, notification_level: notification_levels[level])
end
+ def self.resolve_tag_ids(tag_names)
+ return [] if tag_names.blank?
+
+ Tag
+ .where_name(tag_names)
+ .pluck(:id, :target_tag_id)
+ .map { |id, target_id| target_id || id }
+ .uniq
+ end
+
def self.batch_set(group, level, tag_names)
tag_names ||= []
changed = false
@@ -19,14 +29,13 @@ class GroupTagNotificationDefault < ActiveRecord::Base
records = where(group: group, notification_level: notification_levels[level])
old_ids = records.pluck(:tag_id)
- tag_ids = tag_names.empty? ? [] : Tag.where_name(tag_names).pluck(:id)
+ tag_ids = resolve_tag_ids(tag_names)
- Tag
- .where_name(tag_names)
- .joins(:target_tag)
- .each { |tag| tag_ids[tag_ids.index(tag.id)] = tag.target_tag_id }
-
- tag_ids.uniq!
+ if where(group:, tag_id: tag_ids)
+ .where.not(notification_level: notification_levels[level])
+ .update_all(notification_level: notification_levels[level]) > 0
+ changed = true
+ end
remove = (old_ids - tag_ids)
if remove.present?
diff --git a/config/locales/server.en.yml b/config/locales/server.en.yml
index 2e6b23e4826..e7d6eeffc0c 100644
--- a/config/locales/server.en.yml
+++ b/config/locales/server.en.yml
@@ -28,8 +28,22 @@ en:
category_update_required: "At least one category field must be provided"
draft_sequence_conflict: "Draft sequence conflict"
draft_too_long: "Draft is too long"
+ group_create_failed: "The group could not be created"
+ group_delete_confirmation_required: "Group deletion must be confirmed"
+ group_delete_name_mismatch: "Group name does not match"
+ group_member_selector_required: "Provide exactly one of usernames, user_ids, or user_emails"
+ group_user_limit:
+ one: "Select no more than %{count} user."
+ other: "Select no more than %{count} users."
+ group_membership_request_not_found: "This user has no pending membership request for the group"
group_not_found: "Group not found"
group_post_single_cursor: "Provide either before_post_id or before, not both"
+ group_request_reason_required: "A reason is required to request group membership"
+ group_update_existing_users_required:
+ one: "This change also affects %{count} existing member. Call again with update_existing_users to decide whether to apply it to them."
+ other: "This change also affects %{count} existing members. Call again with update_existing_users to decide whether to apply it to them."
+ group_update_failed: "The group could not be updated"
+ group_update_required: "Provide at least one group field to update"
invalid_date: "Invalid date"
invalid_directory_period: "Invalid directory period"
invalid_reply_mode: "Invalid reply mode"
@@ -837,6 +851,8 @@ en:
one: "Maximum %{count} user can be added at once"
other: "Maximum %{count} users can be added at once"
usernames_or_emails_required: "Usernames or emails must be present"
+ users_not_found: "No user accounts match: %{values}"
+ conflicting_notification_defaults: "Each category or tag can have only one default notification level."
cannot_add_emails: "Only usernames can be used to add members to this group. To invite by email, use the Invite button."
counting_too_many_email_domains:
one: "Maximum %{count} email domain can be counted at once"
diff --git a/lib/discourse_mcp.rb b/lib/discourse_mcp.rb
index ed8ab086e7d..701265353e1 100644
--- a/lib/discourse_mcp.rb
+++ b/lib/discourse_mcp.rb
@@ -19,6 +19,7 @@ module DiscourseMcp
THEMES_READ = "mcp:themes:read"
THEMES_WRITE = "mcp:themes:write"
GROUPS_READ = "mcp:groups:read"
+ GROUPS_WRITE = "mcp:groups:write"
USERS_READ = "mcp:users:read"
USERS_WRITE = "mcp:users:write"
end
diff --git a/lib/discourse_mcp/core_primitives.rb b/lib/discourse_mcp/core_primitives.rb
index ece9b3a0f93..7a344d7a08f 100644
--- a/lib/discourse_mcp/core_primitives.rb
+++ b/lib/discourse_mcp/core_primitives.rb
@@ -1906,6 +1906,366 @@ module DiscourseMcp
),
annotations: READ_ONLY,
)
+ group_id = { type: "integer", minimum: 1 }
+ user_selectors = {
+ usernames: {
+ type: "array",
+ items: {
+ type: "string",
+ minLength: 1,
+ maxLength: 60,
+ },
+ minItems: 1,
+ maxItems: Tools::ManageGroupMembers::MAX_SELECTED_USERS,
+ },
+ user_ids: {
+ type: "array",
+ items: {
+ type: "integer",
+ minimum: 1,
+ },
+ minItems: 1,
+ maxItems: Tools::ManageGroupMembers::MAX_SELECTED_USERS,
+ },
+ user_emails: {
+ type: "array",
+ items: {
+ type: "string",
+ format: "email",
+ minLength: 3,
+ maxLength: 513,
+ },
+ minItems: 1,
+ maxItems: Tools::ManageGroupMembers::MAX_SELECTED_USERS,
+ },
+ }
+ group_settings = {
+ full_name: {
+ type: %w[string null],
+ maxLength: Tools::CreateGroup::MAX_NAME_LENGTH,
+ },
+ title: {
+ type: %w[string null],
+ maxLength: Tools::CreateGroup::MAX_NAME_LENGTH,
+ },
+ bio_raw: {
+ type: %w[string null],
+ maxLength: Tools::CreateGroup::MAX_BIO_LENGTH,
+ },
+ visibility_level: {
+ type: "integer",
+ enum: Tools::CreateGroup::VISIBILITY_LEVELS,
+ },
+ members_visibility_level: {
+ type: "integer",
+ enum: Tools::CreateGroup::VISIBILITY_LEVELS,
+ },
+ mentionable_level: {
+ type: "integer",
+ enum: Tools::CreateGroup::ALIAS_LEVELS,
+ },
+ messageable_level: {
+ type: "integer",
+ enum: Tools::CreateGroup::ALIAS_LEVELS,
+ },
+ default_notification_level: {
+ type: "integer",
+ enum: Tools::CreateGroup::NOTIFICATION_LEVELS,
+ },
+ public_admission: {
+ type: "boolean",
+ },
+ public_exit: {
+ type: "boolean",
+ },
+ allow_membership_requests: {
+ type: "boolean",
+ },
+ membership_request_template: {
+ type: %w[string null],
+ maxLength: Tools::CreateGroup::MAX_TEMPLATE_LENGTH,
+ },
+ primary_group: {
+ type: "boolean",
+ },
+ publish_read_state: {
+ type: "boolean",
+ },
+ grant_trust_level: {
+ type: %w[integer null],
+ minimum: 0,
+ maximum: 4,
+ },
+ automatic_membership_email_domains: {
+ type: %w[string null],
+ maxLength: 1_000,
+ },
+ flair_icon: {
+ type: %w[string null],
+ maxLength: 100,
+ },
+ flair_bg_color: {
+ type: %w[string null],
+ maxLength: 20,
+ },
+ flair_color: {
+ type: %w[string null],
+ maxLength: 20,
+ },
+ }
+ notification_defaults =
+ GroupUpdater::NOTIFICATION_DEFAULT_LEVELS.each_with_object({}) do |level, schema|
+ schema[:"#{level}_category_ids"] = {
+ type: "array",
+ items: {
+ type: "integer",
+ minimum: 1,
+ },
+ maxItems: 100,
+ }
+ schema[:"#{level}_tags"] = {
+ type: "array",
+ items: {
+ type: "string",
+ minLength: 1,
+ maxLength: 100,
+ },
+ maxItems: 100,
+ }
+ end
+
+ register_tool(
+ registry,
+ "discourse_create_group",
+ title: "Create group",
+ description: "Creates a group and returns its ID and name. Requires group creation rights.",
+ implementation: Tools::CreateGroup,
+ input_schema:
+ object_schema(
+ {
+ name: {
+ type: "string",
+ minLength: 1,
+ maxLength: Tools::CreateGroup::MAX_NAME_LENGTH,
+ },
+ **group_settings,
+ owner_usernames: {
+ type: "array",
+ items: {
+ type: "string",
+ minLength: 1,
+ maxLength: 60,
+ },
+ maxItems: Tools::CreateGroup::MAX_INITIAL_USERNAMES,
+ },
+ usernames: {
+ type: "array",
+ items: {
+ type: "string",
+ minLength: 1,
+ maxLength: 60,
+ },
+ maxItems: Tools::CreateGroup::MAX_INITIAL_USERNAMES,
+ },
+ },
+ required: %w[name],
+ ),
+ annotations: WRITE,
+ risk: :administration,
+ )
+ register_tool(
+ registry,
+ "discourse_update_group",
+ title: "Update group",
+ description:
+ "Updates the group settings the authenticated user may change. " \
+ "Fields the user cannot change are ignored.",
+ implementation: Tools::UpdateGroup,
+ input_schema:
+ object_schema(
+ {
+ group_id:,
+ name: {
+ type: "string",
+ minLength: 1,
+ maxLength: Tools::UpdateGroup::MAX_NAME_LENGTH,
+ },
+ **group_settings,
+ **notification_defaults,
+ update_existing_users: {
+ type: "boolean",
+ },
+ },
+ required: %w[group_id],
+ ),
+ annotations: WRITE,
+ risk: :administration,
+ )
+ register_tool(
+ registry,
+ "discourse_delete_group",
+ title: "Delete group",
+ description:
+ "Deletes a group after confirming its current name. Administrators only. " \
+ "Automatic groups cannot be deleted.",
+ implementation: Tools::DeleteGroup,
+ input_schema:
+ object_schema(
+ {
+ group_id:,
+ expected_name: {
+ type: "string",
+ minLength: 1,
+ maxLength: Tools::UpdateGroup::MAX_NAME_LENGTH,
+ },
+ confirm: {
+ type: "boolean",
+ },
+ },
+ required: %w[group_id expected_name confirm],
+ ),
+ annotations: DESTRUCTIVE,
+ risk: :destructive,
+ )
+ register_tool(
+ registry,
+ "discourse_manage_group_members",
+ title: "Manage group members",
+ description:
+ "Adds or removes members of a group the authenticated user may manage. " \
+ "Provide exactly one of usernames, user_ids, or user_emails. " \
+ "The user_emails selector requires permission to view email addresses.",
+ implementation: Tools::ManageGroupMembers,
+ input_schema:
+ object_schema(
+ {
+ group_id:,
+ action: {
+ type: "string",
+ enum: Tools::ManageGroupMembers::ACTIONS,
+ },
+ **user_selectors,
+ notify_users: {
+ type: "boolean",
+ },
+ },
+ required: %w[group_id action],
+ ),
+ annotations: WRITE,
+ risk: :administration,
+ )
+ register_tool(
+ registry,
+ "discourse_invite_group_members",
+ title: "Invite group members by email",
+ description:
+ "Adds existing accounts that match an address and invites the rest to the forum " \
+ "with the group preassigned. Requires permission to view email addresses.",
+ implementation: Tools::InviteGroupMembers,
+ input_schema:
+ object_schema(
+ {
+ group_id:,
+ emails: {
+ type: "array",
+ items: {
+ type: "string",
+ format: "email",
+ minLength: 3,
+ maxLength: 513,
+ },
+ minItems: 1,
+ maxItems: Tools::InviteGroupMembers::MAX_EMAILS,
+ },
+ skip_email: {
+ type: "boolean",
+ },
+ },
+ required: %w[group_id emails],
+ ),
+ annotations: EXTERNAL_SIDE_EFFECT,
+ risk: :external_side_effect,
+ )
+ register_tool(
+ registry,
+ "discourse_manage_group_owners",
+ title: "Manage group owners",
+ description:
+ "Grants or revokes group ownership. Adding an owner also adds them as a member. " \
+ "Automatic groups cannot be changed.",
+ implementation: Tools::ManageGroupOwners,
+ input_schema:
+ object_schema(
+ {
+ group_id:,
+ action: {
+ type: "string",
+ enum: Tools::ManageGroupOwners::ACTIONS,
+ },
+ **user_selectors,
+ notify_users: {
+ type: "boolean",
+ },
+ },
+ required: %w[group_id action],
+ ),
+ annotations: WRITE,
+ risk: :administration,
+ )
+ register_tool(
+ registry,
+ "discourse_manage_group_membership",
+ title: "Manage own group membership",
+ description:
+ "Joins a group that allows public admission, leaves a group that allows public exit, " \
+ "or requests membership with a reason.",
+ implementation: Tools::ManageGroupMembership,
+ input_schema:
+ object_schema(
+ {
+ group_id:,
+ action: {
+ type: "string",
+ enum: Tools::ManageGroupMembership::ACTIONS,
+ },
+ reason: {
+ type: "string",
+ minLength: 1,
+ maxLength: Tools::ManageGroupMembership::MAX_REASON_LENGTH,
+ },
+ },
+ required: %w[group_id action],
+ ),
+ annotations: WRITE,
+ risk: :write,
+ )
+ register_tool(
+ registry,
+ "discourse_handle_group_membership_request",
+ title: "Handle group membership request",
+ description:
+ "Approves or denies one pending membership request for a group the authenticated " \
+ "user may manage. Approving adds the requester to the group.",
+ implementation: Tools::HandleGroupMembershipRequest,
+ input_schema:
+ object_schema(
+ {
+ group_id:,
+ username: {
+ type: "string",
+ minLength: 1,
+ maxLength: 60,
+ },
+ action: {
+ type: "string",
+ enum: Tools::HandleGroupMembershipRequest::ACTIONS,
+ },
+ },
+ required: %w[group_id username action],
+ ),
+ annotations: WRITE,
+ risk: :administration,
+ )
register_tool(
registry,
"discourse_list_group_posts",
diff --git a/lib/discourse_mcp/core_tools.rb b/lib/discourse_mcp/core_tools.rb
index 8e4d1624bb5..50a63532beb 100644
--- a/lib/discourse_mcp/core_tools.rb
+++ b/lib/discourse_mcp/core_tools.rb
@@ -3,6 +3,15 @@
require "category_creator"
require "category_destroyer"
require "category_updater"
+require "group_destroyer"
+require "group_member_adder"
+require "group_member_remover"
+require "group_membership_request_handler"
+require "group_membership_requester"
+require "group_mutations"
+require "group_owner_manager"
+require "group_self_membership"
+require "group_updater"
require "discourse_mcp/tool_helpers"
require "discourse_mcp/output_schema"
require "discourse_mcp/tools/search"
diff --git a/lib/discourse_mcp/tools/groups.rb b/lib/discourse_mcp/tools/groups.rb
index c6b0b9480b2..5583840433d 100644
--- a/lib/discourse_mcp/tools/groups.rb
+++ b/lib/discourse_mcp/tools/groups.rb
@@ -74,6 +74,27 @@ module DiscourseMcp
group or raise ToolError, I18n.t("mcp.errors.group_not_found")
end
+ def find_managed!(group_id, guardian)
+ group = Group.visible_groups(guardian.user).find_by(id: group_id)
+ group or raise ToolError, I18n.t("mcp.errors.group_not_found")
+ end
+
+ def user_selectors!(arguments)
+ selectors = {
+ usernames: arguments["usernames"],
+ user_ids: arguments["user_ids"],
+ user_emails: arguments["user_emails"],
+ }.compact_blank
+ raise ToolError, I18n.t("mcp.errors.group_member_selector_required") if selectors.size != 1
+
+ limit = ManageGroupMembers::MAX_SELECTED_USERS
+ if GroupMutations.split_values(selectors.values.first).size > limit
+ raise ToolError, I18n.t("mcp.errors.group_user_limit", count: limit)
+ end
+
+ selectors.merge(require_all: true)
+ end
+
def group_json(group, guardian, membership:, can_see_members:)
is_group_owner = membership&.owner? || false
can_admin_group = guardian.can_admin_group?(group, is_group_owner:)
@@ -289,6 +310,307 @@ module DiscourseMcp
end
end
+ class CreateGroup
+ REQUIRED_SCOPES = [Scopes::GROUPS_WRITE].freeze
+ # The MCP registry is built before app models are loadable, so these
+ # mirror Group.visibility_levels, Group::ALIAS_LEVELS and
+ # GroupUser.notification_levels. A spec guards them against drift.
+ VISIBILITY_LEVELS = [0, 1, 2, 3, 4].freeze
+ ALIAS_LEVELS = [0, 1, 2, 3, 4, 99].freeze
+ NOTIFICATION_LEVELS = [0, 1, 2, 3, 4].freeze
+ MAX_NAME_LENGTH = 100
+ MAX_BIO_LENGTH = 3_000
+ MAX_TEMPLATE_LENGTH = 1_000
+ MAX_INITIAL_USERNAMES = 100
+ OUTPUT_SCHEMA =
+ OutputSchema.object(
+ id: OutputSchema::INTEGER,
+ name: OutputSchema::STRING,
+ full_name: OutputSchema::STRING_OR_NULL,
+ )
+
+ def self.call(arguments:, request_context:)
+ guardian = request_context.guardian
+ created = nil
+ message = nil
+
+ Groups::Create.call(guardian:, params: arguments.symbolize_keys) do
+ on_success { |group:| created = group }
+ on_failed_policy(:can_create_group) { raise Discourse::InvalidAccess }
+ on_failed_policy(:can_request_access) do
+ message = I18n.t("groups.errors.cant_allow_membership_requests")
+ end
+ on_failed_contract { |contract| message = contract.errors.full_messages.to_sentence }
+ on_model_errors(:group) { |group:| message = group.errors.full_messages.to_sentence }
+ end
+
+ if created.nil?
+ raise ToolError, message.presence || I18n.t("mcp.errors.group_create_failed")
+ end
+
+ ToolHelpers.text_and_structured(
+ id: created.id,
+ name: created.name,
+ full_name: created.full_name,
+ )
+ end
+ end
+
+ class UpdateGroup
+ REQUIRED_SCOPES = [Scopes::GROUPS_WRITE].freeze
+ MAX_NAME_LENGTH = CreateGroup::MAX_NAME_LENGTH
+ MAX_BIO_LENGTH = CreateGroup::MAX_BIO_LENGTH
+ MAX_TEMPLATE_LENGTH = CreateGroup::MAX_TEMPLATE_LENGTH
+ OUTPUT_SCHEMA = OutputSchema.object(group: OutputSchema::OBJECT)
+
+ def self.call(arguments:, request_context:)
+ guardian = request_context.guardian
+ group = GroupSupport.find_managed!(arguments.fetch("group_id"), guardian)
+ attributes = arguments.slice(*GroupUpdater.permitted_names(guardian, group:))
+ raise ToolError, I18n.t("mcp.errors.group_update_required") if attributes.empty?
+
+ updated =
+ GroupUpdater.update(
+ guardian,
+ group,
+ attributes,
+ update_existing_users: arguments["update_existing_users"],
+ )
+ if !updated
+ raise ToolError,
+ group.errors.full_messages.to_sentence.presence ||
+ I18n.t("mcp.errors.group_update_failed")
+ end
+
+ ToolHelpers.text_and_structured(
+ group: GroupSupport.group_detail_json(group.reload, guardian),
+ )
+ rescue GroupUpdater::ExistingUsersConfirmationRequired => error
+ raise ToolError,
+ I18n.t("mcp.errors.group_update_existing_users_required", count: error.user_count)
+ end
+ end
+
+ class DeleteGroup
+ REQUIRED_SCOPES = [Scopes::GROUPS_WRITE].freeze
+ OUTPUT_SCHEMA =
+ OutputSchema.object(deleted: OutputSchema::BOOLEAN, group_id: OutputSchema::INTEGER)
+
+ def self.call(arguments:, request_context:)
+ guardian = request_context.guardian
+ group = GroupSupport.find_managed!(arguments.fetch("group_id"), guardian)
+ GroupDestroyer.ensure_allowed!(guardian, group)
+
+ if arguments["confirm"] != true
+ raise ToolError, I18n.t("mcp.errors.group_delete_confirmation_required")
+ end
+ if arguments.fetch("expected_name") != group.name
+ raise ToolError, I18n.t("mcp.errors.group_delete_name_mismatch")
+ end
+
+ group_id = group.id
+ GroupDestroyer.destroy(guardian, group)
+ ToolHelpers.text_and_structured(deleted: true, group_id:)
+ rescue GroupMutations::AutomaticGroup => error
+ raise ToolError, error.message
+ end
+ end
+
+ class ManageGroupMembers
+ REQUIRED_SCOPES = [Scopes::GROUPS_WRITE].freeze
+ ACTIONS = %w[add remove].freeze
+ MAX_SELECTED_USERS = 100
+ OUTPUT_SCHEMA =
+ OutputSchema.object(
+ action: OutputSchema::STRING,
+ group_id: OutputSchema::INTEGER,
+ usernames: OutputSchema::STRING_ARRAY,
+ skipped_usernames: OutputSchema::STRING_ARRAY,
+ user_count: OutputSchema::INTEGER,
+ )
+
+ def self.call(arguments:, request_context:)
+ guardian = request_context.guardian
+ group = GroupSupport.find_managed!(arguments.fetch("group_id"), guardian)
+ selectors = GroupSupport.user_selectors!(arguments)
+ action = arguments.fetch("action")
+
+ result =
+ if action == "add"
+ GroupMemberAdder.add(
+ guardian,
+ group,
+ notify_users: arguments["notify_users"],
+ **selectors,
+ )
+ else
+ GroupMemberRemover.remove(guardian, group, **selectors)
+ end
+
+ ToolHelpers.text_and_structured(
+ action:,
+ group_id: group.id,
+ usernames: action == "add" ? result[:added_usernames] : result[:usernames],
+ skipped_usernames: result[:skipped_usernames] || [],
+ user_count: group.reload.user_count,
+ )
+ rescue GroupMemberAdder::EmailsNotAllowed,
+ GroupMemberAdder::TooManyUsers,
+ GroupMemberAdder::AlreadyMembers,
+ GroupMutations::UnknownUsers => error
+ raise ToolError, error.message
+ end
+ end
+
+ class InviteGroupMembers
+ REQUIRED_SCOPES = [Scopes::GROUPS_WRITE].freeze
+ MAX_EMAILS = 50
+ OUTPUT_SCHEMA =
+ OutputSchema.object(
+ group_id: OutputSchema::INTEGER,
+ usernames: OutputSchema::STRING_ARRAY,
+ emails: OutputSchema::STRING_ARRAY,
+ )
+
+ def self.call(arguments:, request_context:)
+ guardian = request_context.guardian
+ group = GroupSupport.find_managed!(arguments.fetch("group_id"), guardian)
+ # GroupMutations guards the user_emails selector, but this tool passes
+ # addresses as `emails`, and the response names the accounts they matched.
+ guardian.ensure_can_see_emails!
+
+ result =
+ GroupMemberAdder.add(
+ guardian,
+ group,
+ emails: arguments.fetch("emails"),
+ skip_email: arguments.fetch("skip_email", false),
+ )
+
+ ToolHelpers.text_and_structured(
+ group_id: group.id,
+ usernames: result[:usernames],
+ emails: result[:emails],
+ )
+ rescue GroupMemberAdder::EmailsNotAllowed, GroupMemberAdder::AlreadyMembers => error
+ raise ToolError, error.message
+ end
+ end
+
+ class ManageGroupOwners
+ REQUIRED_SCOPES = [Scopes::GROUPS_WRITE].freeze
+ ACTIONS = %w[add remove].freeze
+ OUTPUT_SCHEMA =
+ OutputSchema.object(
+ action: OutputSchema::STRING,
+ group_id: OutputSchema::INTEGER,
+ usernames: OutputSchema::STRING_ARRAY,
+ )
+
+ def self.call(arguments:, request_context:)
+ guardian = request_context.guardian
+ group = GroupSupport.find_managed!(arguments.fetch("group_id"), guardian)
+ selectors = GroupSupport.user_selectors!(arguments)
+ action = arguments.fetch("action")
+
+ result =
+ if action == "add"
+ GroupOwnerManager.add(
+ guardian,
+ group,
+ notify_users: arguments.fetch("notify_users", false),
+ **selectors,
+ )
+ else
+ GroupOwnerManager.remove(guardian, group, **selectors)
+ end
+
+ ToolHelpers.text_and_structured(action:, group_id: group.id, usernames: result[:usernames])
+ rescue GroupMutations::AutomaticGroup, GroupMutations::UnknownUsers => error
+ raise ToolError, error.message
+ end
+ end
+
+ class ManageGroupMembership
+ REQUIRED_SCOPES = [Scopes::GROUPS_WRITE].freeze
+ ACTIONS = %w[join leave request].freeze
+ MAX_REASON_LENGTH = 1_000
+ OUTPUT_SCHEMA =
+ OutputSchema.object(
+ action: OutputSchema::STRING,
+ group_id: OutputSchema::INTEGER,
+ changed: OutputSchema::BOOLEAN,
+ member: OutputSchema::BOOLEAN,
+ topic_id: OutputSchema::INTEGER_OR_NULL,
+ )
+
+ def self.call(arguments:, request_context:)
+ guardian = request_context.guardian
+ group = GroupSupport.find_managed!(arguments.fetch("group_id"), guardian)
+ action = arguments.fetch("action")
+ topic_id = nil
+
+ changed =
+ case action
+ when "join"
+ GroupSelfMembership.join(guardian, group)
+ when "leave"
+ GroupSelfMembership.leave(guardian, group)
+ else
+ reason = arguments["reason"].to_s.strip
+ raise ToolError, I18n.t("mcp.errors.group_request_reason_required") if reason.blank?
+
+ topic_id = GroupMembershipRequester.request(guardian, group, reason).topic_id
+ true
+ end
+
+ ToolHelpers.text_and_structured(
+ action:,
+ group_id: group.id,
+ changed:,
+ member: group.users.exists?(id: request_context.user_id),
+ topic_id:,
+ )
+ rescue GroupMembershipRequester::AlreadyRequested => error
+ raise ToolError, error.message
+ end
+ end
+
+ class HandleGroupMembershipRequest
+ REQUIRED_SCOPES = [Scopes::GROUPS_WRITE].freeze
+ ACTIONS = %w[approve deny].freeze
+ OUTPUT_SCHEMA =
+ OutputSchema.object(
+ group_id: OutputSchema::INTEGER,
+ username: OutputSchema::STRING,
+ action: OutputSchema::STRING,
+ accepted: OutputSchema::BOOLEAN,
+ )
+
+ def self.call(arguments:, request_context:)
+ guardian = request_context.guardian
+ group = GroupSupport.find_managed!(arguments.fetch("group_id"), guardian)
+ guardian.ensure_can_edit!(group)
+
+ user = User.find_by_username(arguments.fetch("username"))
+ raise ToolError, I18n.t("mcp.errors.user_not_found") if user.blank?
+ if !GroupRequest.exists?(group_id: group.id, user_id: user.id)
+ raise ToolError, I18n.t("mcp.errors.group_membership_request_not_found")
+ end
+
+ action = arguments.fetch("action")
+ accepted = action == "approve"
+ GroupMembershipRequestHandler.handle(guardian, group, user, accept: accepted)
+
+ ToolHelpers.text_and_structured(
+ group_id: group.id,
+ username: user.username,
+ action:,
+ accepted:,
+ )
+ end
+ end
+
class ListGroupPosts
REQUIRED_SCOPES = [Scopes::GROUPS_READ].freeze
OUTPUT_SCHEMA =
diff --git a/lib/group_destroyer.rb b/lib/group_destroyer.rb
new file mode 100644
index 00000000000..72241709cd7
--- /dev/null
+++ b/lib/group_destroyer.rb
@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+class GroupDestroyer
+ # Deleting a group is admin-only. The HTTP route gets that from
+ # AdminConstraint, so the check lives here for callers without a route.
+ def self.ensure_allowed!(guardian, group)
+ raise Discourse::InvalidAccess if !guardian.is_admin?
+ GroupMutations.ensure_not_automatic!(group)
+ end
+
+ def self.destroy(guardian, group)
+ ensure_allowed!(guardian, group)
+
+ Group.transaction do
+ StaffActionLogger.new(guardian.user).log_group_deletion(group)
+ group.destroy!
+ end
+
+ group
+ end
+end
diff --git a/lib/group_member_adder.rb b/lib/group_member_adder.rb
new file mode 100644
index 00000000000..574a4fd5b3b
--- /dev/null
+++ b/lib/group_member_adder.rb
@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+class GroupMemberAdder
+ LIMIT = 1000
+
+ class EmailsNotAllowed < StandardError
+ def initialize(message = nil)
+ super(message || I18n.t("groups.errors.cannot_add_emails"))
+ end
+ end
+
+ class TooManyUsers < StandardError
+ def initialize(message = nil)
+ super(message || I18n.t("groups.errors.adding_too_many_users", count: LIMIT))
+ end
+ end
+
+ class AlreadyMembers < StandardError
+ attr_reader :usernames
+
+ def initialize(usernames)
+ @usernames = usernames
+ super(
+ I18n.t(
+ "groups.errors.member_already_exist",
+ username: usernames.sort.join(", "),
+ count: usernames.size,
+ ),
+ )
+ end
+ end
+
+ def self.add(guardian, group, notify_users: nil, skip_email: false, emails: nil, **selectors)
+ new(guardian, group, notify_users:, skip_email:, emails:, **selectors).add
+ end
+
+ def initialize(guardian, group, notify_users: nil, skip_email: false, emails: nil, **selectors)
+ @guardian = guardian
+ @group = group
+ @notify_users = notify_users
+ @skip_email = skip_email
+ @emails = GroupMutations.split_values(emails)
+ @selectors = selectors
+ end
+
+ def add
+ guardian.ensure_can_edit!(group)
+ raise EmailsNotAllowed if emails.present? && !guardian.can_invite_to_forum?([group])
+
+ users = GroupMutations.resolve_users(guardian:, **selectors).to_a
+ invite_emails = []
+ users_by_email = users_for_emails
+ emails.each do |email|
+ existing_user = users_by_email[Email.downcase(email)]
+ existing_user ? users << existing_user : invite_emails << email
+ end
+
+ if users.empty? && invite_emails.empty?
+ raise Discourse::InvalidParameters.new(I18n.t("groups.errors.usernames_or_emails_required"))
+ end
+ raise TooManyUsers if users.length > LIMIT
+
+ already_in_group = group.users.where(id: users.map(&:id)).pluck(:username)
+ if already_in_group.present? && already_in_group.length == users.length && invite_emails.blank?
+ raise AlreadyMembers, already_in_group
+ end
+
+ unique_users = users.uniq
+ added_user_ids = add_users(unique_users).to_set
+ added_users, skipped_users = unique_users.partition { |user| added_user_ids.include?(user.id) }
+ invite_emails.each do |email|
+ Invite.generate(guardian.user, email:, group_ids: [group.id], skip_email: skip_invite_email?)
+ end
+
+ {
+ usernames: unique_users.map(&:username),
+ added_usernames: added_users.map(&:username),
+ skipped_usernames: skipped_users.map(&:username),
+ emails: invite_emails,
+ }
+ end
+
+ private
+
+ attr_reader :guardian, :group, :notify_users, :skip_email, :emails, :selectors
+
+ def users_for_emails
+ return {} if emails.blank?
+
+ User
+ .with_email(emails.map { Email.downcase(it) })
+ .includes(:user_emails)
+ .each_with_object({}) do |user, by_email|
+ user.user_emails.each { |user_email| by_email[user_email.email.downcase] ||= user }
+ end
+ end
+
+ def notify?
+ notify_users == true
+ end
+
+ # An explicit notify_users: false also suppresses the invitation email.
+ def skip_invite_email?
+ skip_email || (!notify_users.nil? && !notify?)
+ end
+
+ def add_users(users)
+ added_user_ids = GroupManager.new(group).add(users.map(&:id))
+ GroupActionLogger.new(guardian.user, group).bulk_log_add_users_to_group(added_user_ids)
+ if notify? && added_user_ids.present?
+ Jobs.enqueue(:notify_users_added_to_group, user_ids: added_user_ids, group_id: group.id)
+ end
+ added_user_ids
+ end
+end
diff --git a/lib/group_member_remover.rb b/lib/group_member_remover.rb
new file mode 100644
index 00000000000..82f993c5014
--- /dev/null
+++ b/lib/group_member_remover.rb
@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+class GroupMemberRemover
+ def self.remove(guardian, group, **selectors)
+ new(guardian, group, **selectors).remove
+ end
+
+ def initialize(guardian, group, **selectors)
+ @guardian = guardian
+ @group = group
+ @selectors = selectors
+ end
+
+ def remove
+ guardian.ensure_can_edit!(group)
+
+ users = GroupMutations.resolve_users(guardian:, **selectors)
+ if users.empty?
+ raise Discourse::InvalidParameters.new("user_ids or usernames or user_emails must be present")
+ end
+
+ removed_user_ids = GroupManager.new(group).remove(users.map(&:id))
+ GroupActionLogger.new(guardian.user, group).bulk_log_remove_users_from_group(removed_user_ids)
+
+ removed_usernames = []
+ skipped_usernames = []
+ member_ids = group.users.where(id: users.map(&:id)).pluck(:id).to_set
+
+ users.each do |user|
+ if removed_user_ids.include?(user.id)
+ removed_usernames << user.username
+ elsif !member_ids.include?(user.id)
+ skipped_usernames << user.username
+ else
+ raise Discourse::InvalidParameters
+ end
+ end
+
+ { usernames: removed_usernames, skipped_usernames: }
+ end
+
+ private
+
+ attr_reader :guardian, :group, :selectors
+end
diff --git a/lib/group_membership_request_handler.rb b/lib/group_membership_request_handler.rb
new file mode 100644
index 00000000000..f82e9ce0151
--- /dev/null
+++ b/lib/group_membership_request_handler.rb
@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+class GroupMembershipRequestHandler
+ def self.handle(guardian, group, user, accept:)
+ new(guardian, group, user, accept:).handle
+ end
+
+ def initialize(guardian, group, user, accept:)
+ @guardian = guardian
+ @group = group
+ @user = user
+ @accept = accept
+ end
+
+ def handle
+ guardian.ensure_can_edit!(group)
+ request_topic = accept ? find_request_topic : nil
+
+ Group.transaction do
+ if accept
+ group.add(user)
+ GroupActionLogger.new(guardian.user, group).log_add_user_to_group(user)
+ end
+
+ GroupRequest.where(group_id: group.id, user_id: user.id).delete_all
+ end
+
+ reply_to_request(request_topic) if accept && request_topic
+ { accepted: accept }
+ end
+
+ private
+
+ attr_reader :guardian, :group, :user, :accept
+
+ def find_request_topic
+ Topic.find_by(
+ title:
+ I18n.t(
+ "groups.request_membership_pm.title",
+ group_name: group.name,
+ locale: user.effective_locale,
+ ),
+ archetype: Archetype.private_message,
+ user_id: user.id,
+ )
+ end
+
+ def reply_to_request(request_topic)
+ PostCreator.new(
+ guardian.user,
+ post_type: Post.types[:regular],
+ topic_id: request_topic.id,
+ raw:
+ I18n.t(
+ "groups.request_accepted_pm.body",
+ group_name: group.name,
+ locale: user.effective_locale,
+ ),
+ reply_to_post_number: 1,
+ target_usernames: user.username,
+ skip_validations: true,
+ ).create!
+ end
+end
diff --git a/lib/group_membership_requester.rb b/lib/group_membership_requester.rb
new file mode 100644
index 00000000000..d88f1568c2c
--- /dev/null
+++ b/lib/group_membership_requester.rb
@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+class GroupMembershipRequester
+ MAX_NOTIFIED_OWNERS = 20
+
+ class AlreadyRequested < StandardError
+ def initialize(message = nil)
+ super(message || I18n.t("groups.errors.already_requested_membership"))
+ end
+ end
+
+ def self.request(guardian, group, reason)
+ new(guardian, group, reason).request
+ end
+
+ def initialize(guardian, group, reason)
+ @guardian = guardian
+ @group = group
+ @reason = reason
+ end
+
+ def request
+ user = guardian.user or raise Discourse::NotLoggedIn
+ raise Discourse::InvalidAccess if !group.allow_membership_requests?
+ raise Discourse::InvalidAccess if group.users.exists?(id: user.id)
+
+ begin
+ GroupRequest.create!(group:, user:, reason:)
+ rescue ActiveRecord::RecordNotUnique
+ raise AlreadyRequested
+ end
+
+ PostCreator.new(
+ user,
+ title: I18n.t("groups.request_membership_pm.title", group_name: group.name),
+ raw: reason,
+ archetype: Archetype.private_message,
+ target_usernames: notified_usernames(user).join(","),
+ topic_opts: {
+ custom_fields: {
+ requested_group_id: group.id,
+ },
+ },
+ skip_validations: true,
+ ).create!
+ end
+
+ private
+
+ attr_reader :guardian, :group, :reason
+
+ def notified_usernames(user)
+ [user.username].concat(
+ group
+ .users
+ .where("group_users.owner")
+ .order("users.last_seen_at DESC")
+ .limit(MAX_NOTIFIED_OWNERS)
+ .pluck("users.username"),
+ )
+ end
+end
diff --git a/lib/group_mutations.rb b/lib/group_mutations.rb
new file mode 100644
index 00000000000..716f08fe5f2
--- /dev/null
+++ b/lib/group_mutations.rb
@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+# Shared guards and user selection for the group mutation service objects, so
+# HTTP controllers and the MCP server apply the same rules.
+module GroupMutations
+ class UnknownUsers < StandardError
+ def initialize(values)
+ super(I18n.t("groups.errors.users_not_found", values: values.join(", ")))
+ end
+ end
+
+ class AutomaticGroup < StandardError
+ def initialize(message = nil)
+ super(message || I18n.t("groups.errors.can_not_modify_automatic"))
+ end
+ end
+
+ module_function
+
+ def ensure_not_automatic!(group)
+ raise AutomaticGroup if group.automatic
+ end
+
+ def resolve_users(
+ guardian:,
+ usernames: nil,
+ user_id: nil,
+ user_ids: nil,
+ user_emails: nil,
+ require_all: false
+ )
+ # Resolving an address reveals whether it has an account, so this follows the
+ # staff-only rule core applies elsewhere via hide_email_address_taken.
+ guardian.ensure_can_see_emails! if split_values(user_emails).present?
+
+ if (values = split_values(usernames)).present?
+ values = values.map { User.normalize_username(it) }
+ found(
+ User.where(username_lower: values),
+ :username_lower,
+ values,
+ require_all:,
+ error_key: :usernames,
+ )
+ elsif user_id.present?
+ found(User.where(id: user_id.to_i), :id, [user_id.to_i], require_all:, error_key: :user_id)
+ elsif (values = split_values(user_ids)).present?
+ found(User.where(id: values), :id, values, require_all:, error_key: :user_ids)
+ elsif (values = split_values(user_emails)).present?
+ values = values.map { Email.downcase(it) }
+ found(
+ User.with_email(values),
+ "user_emails.email",
+ values,
+ require_all:,
+ error_key: :user_emails,
+ )
+ else
+ User.none
+ end
+ end
+
+ def split_values(value)
+ Array.wrap(value).flat_map { it.to_s.split(",") }.map(&:strip).reject(&:blank?)
+ end
+
+ def found(users, column, values, require_all:, error_key:)
+ if require_all
+ missing = values.map(&:to_s) - users.pluck(column).map(&:to_s)
+ raise UnknownUsers, missing if missing.present?
+ elsif !users.exists?
+ raise Discourse::InvalidParameters.new(error_key)
+ end
+ users
+ end
+ private_class_method :found
+end
diff --git a/lib/group_owner_manager.rb b/lib/group_owner_manager.rb
new file mode 100644
index 00000000000..e54cd548d39
--- /dev/null
+++ b/lib/group_owner_manager.rb
@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+class GroupOwnerManager
+ def self.add(guardian, group, notify_users: false, **selectors)
+ new(guardian, group, **selectors).add(notify_users:)
+ end
+
+ def self.remove(guardian, group, **selectors)
+ new(guardian, group, **selectors).remove
+ end
+
+ def initialize(guardian, group, **selectors)
+ @guardian = guardian
+ @group = group
+ @selectors = selectors
+ end
+
+ def add(notify_users: false)
+ users = authorized_users
+ logger = GroupActionLogger.new(guardian.user, group)
+ user_ids = users.map(&:id)
+ member_ids = group.group_users.where(user_id: user_ids).pluck(:user_id).to_set
+
+ users.each do |user|
+ next if member_ids.include?(user.id)
+ group.add(user)
+ logger.log_add_user_to_group(user)
+ end
+
+ group.group_users.where(user_id: user_ids).update_all(owner: true)
+ users.each { |user| logger.log_make_user_group_owner(user) }
+ if notify_users && user_ids.present?
+ Jobs.enqueue(:notify_users_added_to_group, user_ids:, group_id: group.id, owner: true)
+ end
+
+ { usernames: users.map(&:username) }
+ end
+
+ def remove
+ raise Discourse::InvalidAccess if !guardian.is_staff?
+ users = authorized_users
+ raise Discourse::InvalidParameters.new(:user_id) if users.empty?
+ logger = GroupActionLogger.new(guardian.user, group)
+
+ group.group_users.where(user_id: users.map(&:id)).update_all(owner: false)
+ users.each { |user| logger.log_remove_user_as_group_owner(user) }
+
+ { usernames: users.map(&:username) }
+ end
+
+ private
+
+ attr_reader :guardian, :group, :selectors
+
+ def authorized_users
+ GroupMutations.ensure_not_automatic!(group)
+ guardian.ensure_can_edit_group!(group)
+
+ GroupMutations.resolve_users(guardian:, **selectors).to_a
+ end
+end
diff --git a/lib/group_self_membership.rb b/lib/group_self_membership.rb
new file mode 100644
index 00000000000..d582c83025b
--- /dev/null
+++ b/lib/group_self_membership.rb
@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+# Join and leave actions a user performs on their own membership.
+class GroupSelfMembership
+ def self.join(guardian, group)
+ user = acting_user(guardian)
+ rate_limit!(user)
+ raise Discourse::InvalidAccess if group.automatic
+ raise Discourse::InvalidAccess if !group.public_admission
+ return false if group.users.exists?(id: user.id)
+
+ added_user_ids = GroupManager.new(group).add([user.id])
+ GroupActionLogger.new(user, group).bulk_log_add_users_to_group(added_user_ids)
+ true
+ end
+
+ def self.leave(guardian, group)
+ user = acting_user(guardian)
+ rate_limit!(user)
+ raise Discourse::InvalidAccess if group.automatic
+ raise Discourse::InvalidAccess if !group.public_exit
+ return false if !group.remove(user)
+
+ GroupActionLogger.new(user, group).log_remove_user_from_group(user)
+ true
+ end
+
+ def self.acting_user(guardian)
+ guardian.user or raise Discourse::NotLoggedIn
+ end
+ private_class_method :acting_user
+
+ def self.rate_limit!(user)
+ return if user.staff?
+ RateLimiter.new(user, "public_group_membership", 3, 1.minute).performed!
+ end
+ private_class_method :rate_limit!
+end
diff --git a/lib/group_updater.rb b/lib/group_updater.rb
new file mode 100644
index 00000000000..a8ec56f95d8
--- /dev/null
+++ b/lib/group_updater.rb
@@ -0,0 +1,344 @@
+# frozen_string_literal: true
+
+class GroupUpdater
+ # Raised when a notification-default change would alter existing members and
+ # the caller has not said whether to apply it to them.
+ class ExistingUsersConfirmationRequired < StandardError
+ attr_reader :user_count
+
+ def initialize(user_count)
+ @user_count = user_count
+ super(I18n.t("groups.errors.update_existing_users_required", count: user_count))
+ end
+ end
+
+ NOTIFICATION_DEFAULT_LEVELS = %i[muted regular tracking watching watching_first_post].freeze
+ BLANK_SELECTION = ["-1", -1].freeze
+
+ def self.permitted_params(guardian, group:)
+ new(guardian, group, {}).permitted_params
+ end
+
+ def self.permitted_names(guardian, group:)
+ permitted_params(guardian, group:).flat_map do |attribute|
+ attribute.is_a?(Hash) ? attribute.keys.map(&:to_s) : attribute.to_s
+ end
+ end
+
+ def self.update(guardian, group, attributes, update_existing_users: nil)
+ new(guardian, group, attributes, update_existing_users:).update
+ end
+
+ def initialize(guardian, group, attributes, update_existing_users: nil)
+ @guardian = guardian
+ @group = group
+ @attributes = attributes.to_h.with_indifferent_access
+ @update_existing_users = update_existing_users
+ end
+
+ def permitted_params
+ attributes = %i[
+ bio_raw
+ default_notification_level
+ messageable_level
+ mentionable_level
+ flair_bg_color
+ flair_color
+ flair_icon
+ flair_upload_id
+ ]
+
+ if !group.automatic
+ attributes.push(
+ :allow_membership_requests,
+ :full_name,
+ :public_exit,
+ :public_admission,
+ :membership_request_template,
+ )
+ end
+
+ attributes.push(:visibility_level, :members_visibility_level) if guardian.is_staff?
+
+ if !group.automatic && guardian.is_staff?
+ attributes.push(
+ :incoming_email,
+ :title,
+ :primary_group,
+ :name,
+ :grant_trust_level,
+ :publish_read_state,
+ )
+
+ custom_fields = DiscoursePluginRegistry.editable_group_custom_fields
+ attributes << { custom_fields: custom_fields } if custom_fields.present?
+ end
+
+ if !group.automatic && guardian.is_admin?
+ attributes.push(
+ :smtp_server,
+ :smtp_port,
+ :smtp_ssl_mode,
+ :smtp_enabled,
+ :smtp_updated_by,
+ :smtp_updated_at,
+ :email_username,
+ :email_password,
+ :email_from_alias,
+ :allow_unknown_sender_topic_replies,
+ )
+ end
+
+ attributes << :automatic_membership_email_domains if !group.automatic && can_admin_group?
+
+ if !group.automatic || guardian.is_admin?
+ NOTIFICATION_DEFAULT_LEVELS.each do |level|
+ attributes << { "#{level}_category_ids" => [] }
+ attributes << { "#{level}_tags" => [] }
+ end
+ end
+
+ attributes << { associated_group_ids: [] } if guardian.can_associate_groups?
+ attributes.concat(DiscoursePluginRegistry.group_params)
+ attributes
+ end
+
+ def update
+ guardian.ensure_can_edit!(group) if !can_admin_group?
+
+ @attributes = ActionController::Parameters.new(attributes).permit(*permitted_params).to_h
+ group_attributes = attributes_without_disabled_email_settings
+ notification_level, categories, tags = nil
+
+ if !group.automatic || guardian.is_admin?
+ changes = notification_default_changes(group_attributes)
+ return false if !changes
+ notification_level, categories, tags = changes
+
+ if update_existing_users.nil?
+ user_count = apply_to_existing_users(notification_level, categories, tags, mutate: false)
+ raise ExistingUsersConfirmationRequired, user_count if user_count > 0
+ end
+ end
+
+ return false if !group.update(group_attributes)
+
+ GroupActionLogger.new(guardian.user, group).log_change_group_settings
+ group.record_email_setting_changes!(guardian.user)
+ if update_existing_users
+ apply_to_existing_users(notification_level, categories, tags, mutate: true)
+ end
+
+ true
+ end
+
+ private
+
+ attr_reader :guardian, :group, :attributes, :update_existing_users
+
+ def can_admin_group?
+ return @can_admin_group if defined?(@can_admin_group)
+ @can_admin_group = guardian.can_admin_group?(group)
+ end
+
+ def attributes_without_disabled_email_settings
+ return attributes if !group.smtp_enabled
+ return attributes if !attributes.key?(:smtp_enabled)
+ return attributes if ActiveModel::Type::Boolean.new.cast(attributes[:smtp_enabled]) != false
+
+ attributes.merge(
+ smtp_server: nil,
+ smtp_ssl_mode: Group.smtp_ssl_modes[:none],
+ smtp_port: nil,
+ email_username: nil,
+ email_password: nil,
+ )
+ end
+
+ def notification_default_changes(group_attributes)
+ category_notifications =
+ group.group_category_notification_defaults.pluck(:category_id, :notification_level).to_h
+ tag_notifications =
+ group.group_tag_notification_defaults.pluck(:tag_id, :notification_level).to_h
+ categories = {}
+ tags = {}
+ selected_categories = Set.new
+ selected_tags = Set.new
+
+ NotificationLevels.all.each do |key, value|
+ category_ids =
+ Category.where(id: Array(group_attributes[:"#{key}_category_ids"]) - BLANK_SELECTION).pluck(
+ :id,
+ )
+ tag_names = Array(group_attributes[:"#{key}_tags"]) - BLANK_SELECTION
+ tag_ids = GroupTagNotificationDefault.resolve_tag_ids(tag_names)
+
+ if selected_categories.intersect?(category_ids) || selected_tags.intersect?(tag_ids)
+ group.errors.add(:base, I18n.t("groups.errors.conflicting_notification_defaults"))
+ return false
+ end
+ selected_categories.merge(category_ids)
+ selected_tags.merge(tag_ids)
+
+ category_ids.each do |category_id|
+ metadata = change_metadata(category_notifications, category_id, value)
+ categories[category_id] = metadata if metadata
+ end
+
+ tag_ids.each do |tag_id|
+ metadata = change_metadata(tag_notifications, tag_id, value)
+ tags[tag_id] = metadata if metadata
+ end
+ end
+
+ (category_notifications.keys - categories.keys).each do |category_id|
+ level = NotificationLevels.all.key(category_notifications[category_id])
+ next if !group_attributes.key?(:"#{level}_category_ids")
+
+ categories[category_id] = { action: :delete, old_value: category_notifications[category_id] }
+ end
+
+ (tag_notifications.keys - tags.keys).each do |tag_id|
+ level = NotificationLevels.all.key(tag_notifications[tag_id])
+ next if !group_attributes.key?(:"#{level}_tags")
+
+ tags[tag_id] = { action: :delete, old_value: tag_notifications[tag_id] }
+ end
+
+ notification_level = nil
+ default_notification_level = group_attributes[:default_notification_level]&.to_i
+
+ if default_notification_level.present? &&
+ group.default_notification_level != default_notification_level
+ notification_level = {
+ old_value: group.default_notification_level,
+ new_value: default_notification_level,
+ }
+ end
+
+ [notification_level, categories, tags]
+ end
+
+ # Returns nil when the existing default already matches, which also drops the
+ # target from the "no longer defaulted" set computed by the caller.
+ def change_metadata(existing, id, new_value)
+ old_value = existing[id]
+ return { old_value:, new_value:, action: :create } if old_value.blank?
+
+ if old_value == new_value
+ existing.delete(id)
+ return nil
+ end
+
+ { old_value:, new_value:, action: :update }
+ end
+
+ def apply_to_existing_users(notification_level, categories, tags, mutate:)
+ return 0 if notification_level.blank? && categories.blank? && tags.blank?
+
+ group_users = group.group_users
+ user_ids = []
+
+ if notification_level.present?
+ users = group_users.where(notification_level: notification_level[:old_value])
+
+ if mutate
+ users.update_all(notification_level: notification_level[:new_value])
+ else
+ user_ids += users.pluck(:user_id)
+ end
+ end
+
+ categories.to_a.each do |category_id, data|
+ next if data[:action] != :update && data[:action] != :delete
+
+ category_users =
+ CategoryUser.where(
+ category_id:,
+ notification_level: data[:old_value],
+ user_id: group_users.select(:user_id),
+ )
+
+ if mutate
+ category_users.delete_all
+ else
+ user_ids += category_users.pluck(:user_id)
+ end
+
+ categories.delete(category_id) if data[:action] == :delete && mutate
+ end
+
+ tags.to_a.each do |tag_id, data|
+ next if data[:action] != :update && data[:action] != :delete
+
+ tag_users =
+ TagUser.where(
+ tag_id:,
+ notification_level: data[:old_value],
+ user_id: group_users.select(:user_id),
+ )
+
+ if mutate
+ tag_users.delete_all
+ else
+ user_ids += tag_users.pluck(:user_id)
+ end
+
+ tags.delete(tag_id) if data[:action] == :delete && mutate
+ end
+
+ if categories.present? || tags.present?
+ user_ids += backfill_notification_defaults(group_users, categories, tags, mutate:)
+ end
+
+ user_ids.uniq.count
+ end
+
+ def backfill_notification_defaults(group_users, categories, tags, mutate:)
+ user_ids = []
+
+ group_users
+ .select(:id, :user_id)
+ .find_in_batches do |batch|
+ batch_user_ids = batch.pluck(:user_id)
+
+ categories.each do |category_id, data|
+ skip_user_ids =
+ CategoryUser
+ .where(category_id:, user_id: batch_user_ids)
+ .where.not(notification_level: nil)
+ .pluck(:user_id)
+ rows =
+ (batch_user_ids - skip_user_ids).map do |user_id|
+ { category_id:, user_id:, notification_level: data[:new_value] }
+ end
+ next if rows.blank?
+
+ mutate ? CategoryUser.insert_all!(rows) : user_ids += rows.pluck(:user_id)
+ end
+
+ tags.each do |tag_id, data|
+ skip_user_ids =
+ TagUser
+ .where(tag_id:, user_id: batch_user_ids)
+ .where.not(notification_level: nil)
+ .pluck(:user_id)
+ rows =
+ (batch_user_ids - skip_user_ids).map do |user_id|
+ {
+ tag_id:,
+ user_id:,
+ notification_level: data[:new_value],
+ created_at: Time.zone.now,
+ updated_at: Time.zone.now,
+ }
+ end
+ next if rows.blank?
+
+ mutate ? TagUser.insert_all!(rows) : user_ids += rows.pluck(:user_id)
+ end
+ end
+
+ user_ids
+ end
+end
diff --git a/spec/jobs/notify_users_added_to_group_spec.rb b/spec/jobs/notify_users_added_to_group_spec.rb
new file mode 100644
index 00000000000..8531c425ba2
--- /dev/null
+++ b/spec/jobs/notify_users_added_to_group_spec.rb
@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+describe Jobs::NotifyUsersAddedToGroup do
+ fab!(:user)
+ fab!(:group)
+
+ describe "#execute" do
+ it "sends the owner message when ownership notifications are requested" do
+ group.add_owner(user)
+
+ described_class.new.execute(user_ids: [user.id], group_id: group.id, owner: true)
+
+ topic = Topic.private_messages.last
+ expect(topic.title).to eq(
+ I18n.t(
+ "system_messages.user_added_to_group_as_owner.subject_template",
+ group_name: group.name,
+ ),
+ )
+ expect(topic.allowed_users).to include(user)
+ end
+
+ it "keeps the member message for jobs without an owner flag" do
+ group.add(user)
+
+ described_class.new.execute(user_ids: [user.id], group_id: group.id)
+
+ topic = Topic.private_messages.last
+ expect(topic.title).to eq(
+ I18n.t(
+ "system_messages.user_added_to_group_as_member.subject_template",
+ group_name: group.name,
+ ),
+ )
+ expect(topic.allowed_users).to include(user)
+ end
+ end
+end
diff --git a/spec/lib/discourse_mcp/tools/groups_spec.rb b/spec/lib/discourse_mcp/tools/groups_spec.rb
new file mode 100644
index 00000000000..3ac71fe018a
--- /dev/null
+++ b/spec/lib/discourse_mcp/tools/groups_spec.rb
@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+describe DiscourseMcp::Tools::CreateGroup do
+ describe "level constants" do
+ it "matches the group levels the models define" do
+ expect(described_class::VISIBILITY_LEVELS).to eq(Group.visibility_levels.values.uniq.sort)
+ expect(described_class::ALIAS_LEVELS).to eq(Group::ALIAS_LEVELS.values.uniq.sort)
+ expect(described_class::NOTIFICATION_LEVELS).to eq(
+ GroupUser.notification_levels.values.uniq.sort,
+ )
+ end
+ end
+end
diff --git a/spec/lib/group_destroyer_spec.rb b/spec/lib/group_destroyer_spec.rb
new file mode 100644
index 00000000000..b64157de890
--- /dev/null
+++ b/spec/lib/group_destroyer_spec.rb
@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+describe GroupDestroyer do
+ fab!(:admin)
+ fab!(:moderator)
+ fab!(:user)
+ fab!(:group)
+
+ describe ".destroy" do
+ it "deletes the group and logs the deletion" do
+ expect { described_class.destroy(admin.guardian, group) }.to change { Group.count }.by(-1)
+
+ expect(
+ UserHistory.exists?(action: UserHistory.actions[:delete_group], acting_user_id: admin.id),
+ ).to eq(true)
+ end
+
+ it "refuses an automatic group" do
+ automatic = Group.find(Group::AUTO_GROUPS[:trust_level_1])
+
+ expect { described_class.destroy(admin.guardian, automatic) }.to raise_error(
+ GroupMutations::AutomaticGroup,
+ )
+ end
+
+ it "refuses a moderator even when moderators manage groups" do
+ SiteSetting.moderators_manage_groups = true
+
+ expect { described_class.destroy(moderator.guardian, group) }.to raise_error(
+ Discourse::InvalidAccess,
+ )
+ expect(Group.exists?(group.id)).to eq(true)
+ end
+
+ it "refuses a regular user" do
+ expect { described_class.destroy(user.guardian, group) }.to raise_error(
+ Discourse::InvalidAccess,
+ )
+ end
+ end
+end
diff --git a/spec/lib/group_member_adder_spec.rb b/spec/lib/group_member_adder_spec.rb
new file mode 100644
index 00000000000..cb1f76ace2e
--- /dev/null
+++ b/spec/lib/group_member_adder_spec.rb
@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+describe GroupMemberAdder do
+ fab!(:admin)
+ fab!(:owner, :user)
+ fab!(:user)
+ fab!(:user_1, :user)
+ fab!(:group)
+
+ before { group.add_owner(owner) }
+
+ describe ".add" do
+ it "adds members and logs the change" do
+ result = described_class.add(owner.guardian, group, usernames: user.username)
+
+ expect(result[:usernames]).to eq([user.username])
+ expect(group.reload.users).to include(user)
+ expect(
+ GroupHistory.exists?(
+ group:,
+ action: GroupHistory.actions[:add_user_to_group],
+ target_user: user,
+ ),
+ ).to eq(true)
+ end
+
+ it "notifies added members only when asked" do
+ expect_not_enqueued_with(job: :notify_users_added_to_group) do
+ described_class.add(owner.guardian, group, usernames: user.username)
+ end
+
+ expect_enqueued_with(
+ job: :notify_users_added_to_group,
+ args: {
+ user_ids: [user_1.id],
+ group_id: group.id,
+ },
+ ) do
+ described_class.add(owner.guardian, group, usernames: user_1.username, notify_users: true)
+ end
+ end
+
+ it "refuses a user who cannot edit the group" do
+ expect {
+ described_class.add(user.guardian, group, usernames: user_1.username)
+ }.to raise_error(Discourse::InvalidAccess)
+ end
+
+ it "refuses when every selected user is already a member" do
+ group.add(user)
+
+ expect {
+ described_class.add(owner.guardian, group, usernames: user.username)
+ }.to raise_error(GroupMemberAdder::AlreadyMembers)
+ end
+
+ it "refuses more users than the limit allows" do
+ stub_const(described_class, "LIMIT", 1) do
+ expect {
+ described_class.add(owner.guardian, group, usernames: [user.username, user_1.username])
+ }.to raise_error(GroupMemberAdder::TooManyUsers)
+ end
+ end
+
+ it "requires at least one user or email" do
+ expect { described_class.add(owner.guardian, group) }.to raise_error(
+ Discourse::InvalidParameters,
+ )
+ end
+
+ it "adds an account that already owns the given email instead of inviting it" do
+ result = described_class.add(admin.guardian, group, emails: user.email)
+
+ expect(result[:usernames]).to eq([user.username])
+ expect(result[:emails]).to be_empty
+ expect(group.reload.users).to include(user)
+ end
+
+ it "invites unknown email addresses to the forum with the group preassigned" do
+ result = described_class.add(admin.guardian, group, emails: "[email protected]")
+
+ expect(result[:emails]).to eq(["[email protected]"])
+ invite = Invite.last
+ expect(invite.email).to eq("[email protected]")
+ expect(invite.groups).to eq([group])
+ end
+
+ it "refuses email invitations before adding users when the owner cannot invite" do
+ SiteSetting.invite_allowed_groups = Group::AUTO_GROUPS[:staff]
+
+ [user.email, "[email protected]"].each do |email|
+ expect do
+ described_class.add(owner.guardian, group, usernames: user.username, emails: email)
+ end.to raise_error(GroupMemberAdder::EmailsNotAllowed)
+ end
+ expect(group.users).not_to include(user)
+ expect(Invite.where(invited_by: owner)).to be_empty
+ end
+ end
+end
diff --git a/spec/lib/group_member_remover_spec.rb b/spec/lib/group_member_remover_spec.rb
new file mode 100644
index 00000000000..18db23b6d19
--- /dev/null
+++ b/spec/lib/group_member_remover_spec.rb
@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+describe GroupMemberRemover do
+ fab!(:owner, :user)
+ fab!(:user)
+ fab!(:user_1, :user)
+ fab!(:group)
+
+ before do
+ group.add_owner(owner)
+ group.add(user)
+ end
+
+ describe ".remove" do
+ it "removes members and logs the change" do
+ result = described_class.remove(owner.guardian, group, usernames: user.username)
+
+ expect(result[:usernames]).to eq([user.username])
+ expect(result[:skipped_usernames]).to be_empty
+ expect(group.reload.users).not_to include(user)
+ expect(
+ GroupHistory.exists?(
+ group:,
+ action: GroupHistory.actions[:remove_user_from_group],
+ target_user: user,
+ ),
+ ).to eq(true)
+ end
+
+ it "reports users who were not members as skipped" do
+ result =
+ described_class.remove(owner.guardian, group, usernames: [user.username, user_1.username])
+
+ expect(result[:usernames]).to eq([user.username])
+ expect(result[:skipped_usernames]).to eq([user_1.username])
+ end
+
+ it "refuses a user who cannot edit the group" do
+ expect {
+ described_class.remove(user_1.guardian, group, usernames: user.username)
+ }.to raise_error(Discourse::InvalidAccess)
+ end
+
+ it "requires a selector" do
+ expect { described_class.remove(owner.guardian, group) }.to raise_error(
+ Discourse::InvalidParameters,
+ )
+ end
+ end
+end
diff --git a/spec/lib/group_membership_request_handler_spec.rb b/spec/lib/group_membership_request_handler_spec.rb
new file mode 100644
index 00000000000..47dc6ee7ea6
--- /dev/null
+++ b/spec/lib/group_membership_request_handler_spec.rb
@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+describe GroupMembershipRequestHandler do
+ fab!(:user)
+ fab!(:owner, :user)
+ fab!(:group)
+
+ before do
+ group.add_owner(owner)
+ group.update!(allow_membership_requests: true)
+ GroupMembershipRequester.request(user.guardian, group, "I write the docs")
+ end
+
+ describe ".handle" do
+ it "adds the requester, clears the request, and replies in the request message" do
+ expect { described_class.handle(owner.guardian, group, user, accept: true) }.to change {
+ GroupRequest.count
+ }.by(-1)
+
+ expect(group.reload.users).to include(user)
+ expect(
+ GroupHistory.exists?(
+ group:,
+ action: GroupHistory.actions[:add_user_to_group],
+ target_user: user,
+ ),
+ ).to eq(true)
+ request_topic = Topic.private_messages.last
+ expect(request_topic.posts.last.raw).to eq(
+ I18n.t("groups.request_accepted_pm.body", group_name: group.name).strip,
+ )
+ end
+
+ it "clears the request without adding the user when denied" do
+ expect { described_class.handle(owner.guardian, group, user, accept: false) }.to change {
+ GroupRequest.count
+ }.by(-1)
+
+ expect(group.reload.users).not_to include(user)
+ end
+
+ it "refuses a user who cannot edit the group" do
+ expect {
+ described_class.handle(Fabricate(:user).guardian, group, user, accept: true)
+ }.to raise_error(Discourse::InvalidAccess)
+ end
+
+ it "still accepts the request when the original message is gone" do
+ Topic.private_messages.last.destroy!
+
+ expect { described_class.handle(owner.guardian, group, user, accept: true) }.to change {
+ GroupRequest.count
+ }.by(-1)
+ expect(group.reload.users).to include(user)
+ end
+ end
+end
diff --git a/spec/lib/group_membership_requester_spec.rb b/spec/lib/group_membership_requester_spec.rb
new file mode 100644
index 00000000000..4d83ad97b78
--- /dev/null
+++ b/spec/lib/group_membership_requester_spec.rb
@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+describe GroupMembershipRequester do
+ fab!(:user)
+ fab!(:owner, :user)
+ fab!(:group)
+
+ before do
+ group.add_owner(owner)
+ group.update!(allow_membership_requests: true)
+ end
+
+ describe ".request" do
+ it "records the request and messages the group owners" do
+ post = described_class.request(user.guardian, group, "I write the docs")
+
+ expect(GroupRequest.find_by(group:, user:).reason).to eq("I write the docs")
+ expect(post.topic.archetype).to eq(Archetype.private_message)
+ expect(post.topic.allowed_users).to include(user, owner)
+ expect(post.topic.custom_fields["requested_group_id"]).to eq(group.id.to_s)
+ end
+
+ it "refuses a group that does not allow requests" do
+ group.update!(allow_membership_requests: false)
+
+ expect { described_class.request(user.guardian, group, "please") }.to raise_error(
+ Discourse::InvalidAccess,
+ )
+ end
+
+ it "refuses an existing member" do
+ group.add(user)
+
+ expect { described_class.request(user.guardian, group, "please") }.to raise_error(
+ Discourse::InvalidAccess,
+ )
+ end
+
+ it "refuses a second request from the same user" do
+ described_class.request(user.guardian, group, "please")
+
+ expect { described_class.request(user.guardian, group, "again") }.to raise_error(
+ GroupMembershipRequester::AlreadyRequested,
+ )
+ end
+
+ it "refuses an anonymous caller" do
+ expect { described_class.request(Guardian.new, group, "please") }.to raise_error(
+ Discourse::NotLoggedIn,
+ )
+ end
+ end
+end
diff --git a/spec/lib/group_mutations_spec.rb b/spec/lib/group_mutations_spec.rb
new file mode 100644
index 00000000000..efe31f3b762
--- /dev/null
+++ b/spec/lib/group_mutations_spec.rb
@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+describe GroupMutations do
+ fab!(:admin)
+ fab!(:user) { Fabricate(:user, username: "ichigo") }
+ fab!(:user_1) { Fabricate(:user, username: "rukia") }
+
+ describe ".ensure_not_automatic!" do
+ it "raises for an automatic group" do
+ expect {
+ described_class.ensure_not_automatic!(Group.find(Group::AUTO_GROUPS[:trust_level_1]))
+ }.to raise_error(
+ GroupMutations::AutomaticGroup,
+ I18n.t("groups.errors.can_not_modify_automatic"),
+ )
+ end
+
+ it "allows a custom group" do
+ expect { described_class.ensure_not_automatic!(Fabricate(:group)) }.not_to raise_error
+ end
+ end
+
+ describe ".resolve_users" do
+ it "finds users by username regardless of case" do
+ expect(
+ described_class.resolve_users(guardian: admin.guardian, usernames: "ICHIGO").pluck(:id),
+ ).to eq([user.id])
+ end
+
+ it "accepts a comma separated list and an array" do
+ expect(
+ described_class.resolve_users(guardian: admin.guardian, usernames: "ichigo,rukia").pluck(
+ :id,
+ ),
+ ).to contain_exactly(user.id, user_1.id)
+ expect(
+ described_class.resolve_users(guardian: admin.guardian, usernames: %w[ichigo rukia]).pluck(
+ :id,
+ ),
+ ).to contain_exactly(user.id, user_1.id)
+ end
+
+ it "prefers usernames over the other selectors" do
+ expect(
+ described_class.resolve_users(
+ guardian: admin.guardian,
+ usernames: "ichigo",
+ user_ids: [user_1.id],
+ ).pluck(:id),
+ ).to eq([user.id])
+ end
+
+ it "keeps partial matches for existing HTTP callers" do
+ expect(
+ described_class.resolve_users(
+ guardian: admin.guardian,
+ usernames: [user.username, "missing_user"],
+ ).pluck(:id),
+ ).to eq([user.id])
+ end
+
+ it "rejects incomplete ID and email selections when all accounts are required" do
+ expect do
+ described_class.resolve_users(
+ guardian: admin.guardian,
+ user_ids: [user.id, 999_999_999],
+ require_all: true,
+ )
+ end.to raise_error(
+ GroupMutations::UnknownUsers,
+ I18n.t("groups.errors.users_not_found", values: "999999999"),
+ )
+
+ expect do
+ described_class.resolve_users(
+ guardian: admin.guardian,
+ user_emails: [user.email.upcase, "[email protected]"],
+ require_all: true,
+ )
+ end.to raise_error(
+ GroupMutations::UnknownUsers,
+ I18n.t("groups.errors.users_not_found", values: "[email protected]"),
+ )
+ end
+
+ it "finds users by id and by email" do
+ expect(
+ described_class.resolve_users(guardian: admin.guardian, user_ids: [user.id]).pluck(:id),
+ ).to eq([user.id])
+ expect(
+ described_class.resolve_users(guardian: admin.guardian, user_emails: user.email).pluck(:id),
+ ).to eq([user.id])
+ end
+
+ it "returns no users when no selector is given" do
+ expect(described_class.resolve_users(guardian: admin.guardian)).to be_empty
+ end
+
+ it "raises naming the selector that matched nothing" do
+ expect {
+ described_class.resolve_users(guardian: admin.guardian, usernames: "nobody")
+ }.to raise_error(Discourse::InvalidParameters)
+ expect {
+ described_class.resolve_users(guardian: admin.guardian, user_ids: [-999_999])
+ }.to raise_error(Discourse::InvalidParameters)
+ expect {
+ described_class.resolve_users(guardian: admin.guardian, user_emails: "[email protected]")
+ }.to raise_error(Discourse::InvalidParameters)
+ end
+
+ it "refuses the email selector for a user who may not view email addresses" do
+ expect {
+ described_class.resolve_users(guardian: user.guardian, user_emails: user_1.email)
+ }.to raise_error(Discourse::InvalidAccess)
+ end
+
+ it "allows the email selector for a moderator once email viewing is enabled" do
+ moderator = Fabricate(:moderator)
+ SiteSetting.moderators_view_emails = true
+
+ expect(
+ described_class.resolve_users(guardian: moderator.guardian, user_emails: user.email).pluck(
+ :id,
+ ),
+ ).to eq([user.id])
+ end
+ end
+end
diff --git a/spec/lib/group_owner_manager_spec.rb b/spec/lib/group_owner_manager_spec.rb
new file mode 100644
index 00000000000..924ab3e84bc
--- /dev/null
+++ b/spec/lib/group_owner_manager_spec.rb
@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+describe GroupOwnerManager do
+ fab!(:admin)
+ fab!(:owner, :user)
+ fab!(:user)
+ fab!(:group)
+
+ before { group.add_owner(owner) }
+
+ describe ".add" do
+ it "makes a user an owner and adds them as a member" do
+ result = described_class.add(owner.guardian, group, usernames: user.username)
+
+ expect(result[:usernames]).to eq([user.username])
+ expect(group.group_users.find_by(user:).owner).to eq(true)
+ expect(
+ GroupHistory.exists?(
+ group:,
+ action: GroupHistory.actions[:make_user_group_owner],
+ target_user: user,
+ ),
+ ).to eq(true)
+ end
+
+ it "notifies the new owner only when asked" do
+ expect {
+ described_class.add(owner.guardian, group, usernames: user.username)
+ }.not_to change { Topic.private_messages.count }
+
+ expect_enqueued_with(
+ job: :notify_users_added_to_group,
+ args: {
+ user_ids: [user.id],
+ group_id: group.id,
+ owner: true,
+ },
+ ) do
+ expect do
+ described_class.add(admin.guardian, group, usernames: user.username, notify_users: true)
+ end.not_to change { Topic.private_messages.count }
+ end
+ end
+
+ it "refuses an automatic group" do
+ automatic = Group.find(Group::AUTO_GROUPS[:trust_level_1])
+
+ expect {
+ described_class.add(admin.guardian, automatic, usernames: user.username)
+ }.to raise_error(GroupMutations::AutomaticGroup)
+ end
+
+ it "refuses a user who cannot edit the group" do
+ expect { described_class.add(user.guardian, group, usernames: user.username) }.to raise_error(
+ Discourse::InvalidAccess,
+ )
+ end
+ end
+
+ describe ".remove" do
+ it "revokes ownership but keeps the membership" do
+ group.add_owner(user)
+
+ result = described_class.remove(admin.guardian, group, usernames: user.username)
+
+ expect(result[:usernames]).to eq([user.username])
+ expect(group.group_users.find_by(user:).owner).to eq(false)
+ expect(group.reload.users).to include(user)
+ expect(
+ GroupHistory.exists?(
+ group:,
+ action: GroupHistory.actions[:remove_user_as_group_owner],
+ target_user: user,
+ ),
+ ).to eq(true)
+ end
+
+ it "requires a selector" do
+ expect { described_class.remove(admin.guardian, group) }.to raise_error(
+ Discourse::InvalidParameters,
+ )
+ end
+ end
+end
diff --git a/spec/lib/group_self_membership_spec.rb b/spec/lib/group_self_membership_spec.rb
new file mode 100644
index 00000000000..1a8852a8750
--- /dev/null
+++ b/spec/lib/group_self_membership_spec.rb
@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+describe GroupSelfMembership do
+ fab!(:user)
+ fab!(:group) { Fabricate(:group, public_admission: true, public_exit: true) }
+
+ describe ".join" do
+ it "adds the user and logs the change" do
+ expect(described_class.join(user.guardian, group)).to eq(true)
+ expect(group.reload.users).to include(user)
+ expect(
+ GroupHistory.exists?(
+ group:,
+ action: GroupHistory.actions[:add_user_to_group],
+ target_user: user,
+ ),
+ ).to eq(true)
+ end
+
+ it "reports no change when the user is already a member" do
+ group.add(user)
+
+ expect(described_class.join(user.guardian, group)).to eq(false)
+ end
+
+ it "refuses a group that does not allow public admission" do
+ group.update!(public_admission: false)
+
+ expect { described_class.join(user.guardian, group) }.to raise_error(Discourse::InvalidAccess)
+ end
+
+ it "refuses an anonymous caller" do
+ expect { described_class.join(Guardian.new, group) }.to raise_error(Discourse::NotLoggedIn)
+ end
+
+ it "refuses an automatic group even when it allows public admission" do
+ automatic = Group.find(Group::AUTO_GROUPS[:admins])
+ automatic.update_columns(public_admission: true)
+
+ expect { described_class.join(user.guardian, automatic) }.to raise_error(
+ Discourse::InvalidAccess,
+ )
+ expect(automatic.reload.users).not_to include(user)
+ end
+
+ it "rate limits a regular user" do
+ RateLimiter.enable
+ RateLimiter.any_instance.stubs(:rate_unlimited?).returns(false)
+
+ 3.times { described_class.join(user.guardian, Fabricate(:group, public_admission: true)) }
+
+ expect { described_class.join(user.guardian, group) }.to raise_error(
+ RateLimiter::LimitExceeded,
+ )
+ end
+ end
+
+ describe ".leave" do
+ before { group.add(user) }
+
+ it "removes the user and logs the change" do
+ expect(described_class.leave(user.guardian, group)).to eq(true)
+ expect(group.reload.users).not_to include(user)
+ expect(
+ GroupHistory.exists?(
+ group:,
+ action: GroupHistory.actions[:remove_user_from_group],
+ target_user: user,
+ ),
+ ).to eq(true)
+ end
+
+ it "refuses a group that does not allow public exit" do
+ group.update!(public_exit: false)
+
+ expect { described_class.leave(user.guardian, group) }.to raise_error(
+ Discourse::InvalidAccess,
+ )
+ end
+
+ it "reports no change when the user is not a member" do
+ expect(described_class.leave(Fabricate(:user).guardian, group)).to eq(false)
+ end
+
+ it "refuses an automatic group even when it allows public exit" do
+ automatic = Group.find(Group::AUTO_GROUPS[:admins])
+ automatic.update_columns(public_exit: true)
+ automatic.add(user)
+
+ expect { described_class.leave(user.guardian, automatic) }.to raise_error(
+ Discourse::InvalidAccess,
+ )
+ expect(automatic.reload.users).to include(user)
+ end
+ end
+end
diff --git a/spec/lib/group_updater_spec.rb b/spec/lib/group_updater_spec.rb
new file mode 100644
index 00000000000..5629d4f4b44
--- /dev/null
+++ b/spec/lib/group_updater_spec.rb
@@ -0,0 +1,263 @@
+# frozen_string_literal: true
+
+describe GroupUpdater do
+ fab!(:admin)
+ fab!(:moderator)
+ fab!(:owner, :user)
+ fab!(:user)
+ fab!(:group)
+
+ before { group.add_owner(owner) }
+
+ describe ".permitted_names" do
+ it "lets a group owner change the profile but not staff-only settings" do
+ names = described_class.permitted_names(owner.guardian, group:)
+
+ expect(names).to include("bio_raw", "full_name", "public_admission")
+ expect(names).not_to include("name", "title", "visibility_level", "smtp_server")
+ end
+
+ it "lets staff change visibility and group identity" do
+ names = described_class.permitted_names(moderator.guardian, group:)
+
+ expect(names).to include("name", "title", "visibility_level", "members_visibility_level")
+ expect(names).not_to include("smtp_server", "email_password")
+ end
+
+ it "lets an admin change email settings" do
+ expect(described_class.permitted_names(admin.guardian, group:)).to include(
+ "smtp_server",
+ "email_password",
+ "automatic_membership_email_domains",
+ )
+ end
+
+ it "drops settings that do not apply to an automatic group" do
+ automatic = Group.find(Group::AUTO_GROUPS[:trust_level_1])
+ names = described_class.permitted_names(admin.guardian, group: automatic)
+
+ expect(names).not_to include("name", "public_admission", "automatic_membership_email_domains")
+ expect(names).to include("bio_raw", "visibility_level")
+ end
+ end
+
+ describe ".update" do
+ it "accepts registered custom fields without allowing other nested fields" do
+ Plugin::Instance.new.register_editable_group_custom_field(:editable)
+
+ described_class.update(
+ admin.guardian,
+ group,
+ { custom_fields: { editable: "yes", private: "no" } },
+ )
+
+ expect(group.reload.custom_fields).to eq("editable" => "yes")
+ ensure
+ DiscoursePluginRegistry.reset!
+ end
+
+ it "filters staff-only settings when called directly by an owner" do
+ original_name = group.name
+ described_class.update(
+ owner.guardian,
+ group,
+ { bio_raw: "Allowed", name: "forbidden", grant_trust_level: 4 },
+ )
+
+ expect(group.reload.bio_raw).to eq("Allowed")
+ expect(group.name).to eq(original_name)
+ expect(group.grant_trust_level).to be_nil
+ end
+
+ it "filters admin-only email settings when called directly by a moderator" do
+ group.add_owner(moderator)
+ described_class.update(
+ moderator.guardian,
+ group,
+ { bio_raw: "Allowed", email_password: "secret" },
+ )
+
+ expect(group.reload.bio_raw).to eq("Allowed")
+ expect(group.email_password).to be_blank
+ end
+
+ it "updates the group and logs the change" do
+ expect(described_class.update(owner.guardian, group, { "bio_raw" => "We write docs" })).to eq(
+ true,
+ )
+
+ expect(group.reload.bio_raw).to eq("We write docs")
+ expect(
+ GroupHistory.exists?(group:, action: GroupHistory.actions[:change_group_setting]),
+ ).to eq(true)
+ end
+
+ it "refuses a user who cannot edit the group" do
+ expect {
+ described_class.update(user.guardian, group, { "bio_raw" => "nope" })
+ }.to raise_error(Discourse::InvalidAccess)
+ end
+
+ it "returns false and keeps the model errors when the group is invalid" do
+ expect(described_class.update(admin.guardian, group, { "name" => "" })).to eq(false)
+ expect(group.errors).to be_present
+ end
+
+ it "clears the SMTP credentials when SMTP is turned off" do
+ smtp_group = Fabricate(:smtp_group)
+
+ described_class.update(admin.guardian, smtp_group, { "smtp_enabled" => false })
+
+ smtp_group.reload
+ expect(smtp_group.smtp_enabled).to eq(false)
+ expect(smtp_group.smtp_server).to eq(nil)
+ expect(smtp_group.smtp_port).to eq(nil)
+ expect(smtp_group.email_username).to eq(nil)
+ expect(smtp_group.email_password).to eq(nil)
+ end
+
+ it "accepts the string form of smtp_enabled sent by the HTTP endpoint" do
+ smtp_group = Fabricate(:smtp_group)
+
+ described_class.update(admin.guardian, smtp_group, { "smtp_enabled" => "false" })
+
+ expect(smtp_group.reload.smtp_server).to eq(nil)
+ end
+
+ context "with notification defaults" do
+ fab!(:category)
+ fab!(:member, :user)
+
+ before { group.add(member) }
+
+ it "asks for confirmation when existing members would be changed" do
+ described_class.update(
+ admin.guardian,
+ group,
+ { "watching_category_ids" => [category.id] },
+ update_existing_users: false,
+ )
+
+ expect {
+ described_class.update(
+ admin.guardian,
+ group,
+ { "tracking_category_ids" => [category.id] },
+ )
+ }.to raise_error(GroupUpdater::ExistingUsersConfirmationRequired) { |error|
+ expect(error.user_count).to eq(2) # the owner and the member
+ }
+ end
+
+ it "leaves existing members alone when confirmation is declined" do
+ described_class.update(
+ admin.guardian,
+ group,
+ { "watching_category_ids" => [category.id] },
+ update_existing_users: false,
+ )
+
+ expect(CategoryUser.where(user: member, category:)).to be_empty
+ expect(group.reload.group_category_notification_defaults.pluck(:category_id)).to eq(
+ [category.id],
+ )
+ end
+
+ it "applies the default to existing members when confirmed" do
+ described_class.update(
+ admin.guardian,
+ group,
+ { "watching_category_ids" => [category.id] },
+ update_existing_users: true,
+ )
+
+ expect(CategoryUser.find_by(user: member, category:).notification_level).to eq(
+ NotificationLevels.all[:watching],
+ )
+ end
+
+ it "does not ask for confirmation when nothing changes for existing members" do
+ expect(described_class.update(admin.guardian, group, { "bio_raw" => "unrelated" })).to eq(
+ true,
+ )
+ end
+
+ it "clears only explicitly emptied defaults and leaves other levels untouched" do
+ tag = Fabricate(:tag)
+ described_class.update(
+ admin.guardian,
+ group,
+ { watching_category_ids: [category.id], tracking_tags: [tag.name] },
+ update_existing_users: true,
+ )
+
+ described_class.update(
+ admin.guardian,
+ group.reload,
+ { watching_category_ids: [] },
+ update_existing_users: true,
+ )
+
+ expect(group.reload.group_category_notification_defaults).to be_empty
+ expect(CategoryUser.where(user: member, category:)).to be_empty
+ expect(group.group_tag_notification_defaults.pluck(:tag_id)).to eq([tag.id])
+ expect(TagUser.find_by!(user: member, tag:).notification_level).to eq(
+ NotificationLevels.all[:tracking],
+ )
+
+ described_class.update(
+ admin.guardian,
+ group,
+ { tracking_tags: [] },
+ update_existing_users: true,
+ )
+
+ expect(group.reload.group_tag_notification_defaults).to be_empty
+ expect(TagUser.where(user: member, tag:)).to be_empty
+ end
+
+ it "only lets an admin change notification defaults on an automatic group" do
+ automatic = Group.find(Group::AUTO_GROUPS[:trust_level_1])
+
+ expect(
+ described_class.permitted_names(moderator.guardian, group: automatic),
+ ).not_to include("watching_category_ids")
+ expect(described_class.permitted_names(admin.guardian, group: automatic)).to include(
+ "watching_category_ids",
+ )
+ end
+
+ it "requires confirmation for a synonym and preserves members when applying it is declined" do
+ tag = Fabricate(:tag)
+ synonym = Fabricate(:tag, target_tag: tag)
+ group.update!(tracking_tags: [tag.name])
+ TagUser.change(member.id, tag.id, NotificationLevels.all[:tracking])
+
+ expect {
+ described_class.update(
+ admin.guardian,
+ group.reload,
+ { watching_tags: [synonym.name.upcase] },
+ )
+ }.to raise_error(GroupUpdater::ExistingUsersConfirmationRequired)
+ expect(group.reload.group_tag_notification_defaults.pluck(:notification_level)).to eq(
+ [NotificationLevels.all[:tracking]],
+ )
+
+ described_class.update(
+ admin.guardian,
+ group,
+ { watching_tags: [synonym.name.upcase] },
+ update_existing_users: false,
+ )
+
+ expect(
+ group.reload.group_tag_notification_defaults.pluck(:tag_id, :notification_level),
+ ).to eq([[tag.id, NotificationLevels.all[:watching]]])
+ expect(TagUser.find_by!(user: member, tag:).notification_level).to eq(
+ NotificationLevels.all[:tracking],
+ )
+ end
+ end
+ end
+end
diff --git a/spec/models/group_spec.rb b/spec/models/group_spec.rb
index b0459d86522..fa6337efb36 100644
--- a/spec/models/group_spec.rb
+++ b/spec/models/group_spec.rb
@@ -1987,6 +1987,16 @@ RSpec.describe Group do
expect(GroupTagNotificationDefault.lookup(group, :tracking).pluck(:tag_id)).to eq([tag1.id])
end
+ it "moves a tag between levels without clearing the previous level" do
+ group.update!(tracking_tags: [tag1.name])
+
+ group.reload.update!(watching_tags: [tag1.name])
+
+ expect(
+ group.reload.group_tag_notification_defaults.pluck(:tag_id, :notification_level),
+ ).to eq([[tag1.id, NotificationLevels.all[:watching]]])
+ end
+
it "can apply default notifications for admins group" do
group = Group.find(Group::AUTO_GROUPS[:admins])
group.tracking_category_ids = [category1.id]
diff --git a/spec/models/group_tag_notification_default_spec.rb b/spec/models/group_tag_notification_default_spec.rb
new file mode 100644
index 00000000000..e03c1e0a98d
--- /dev/null
+++ b/spec/models/group_tag_notification_default_spec.rb
@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+describe GroupTagNotificationDefault do
+ describe ".resolve_tag_ids" do
+ it "returns an empty selection without querying tags" do
+ queries = track_sql_queries { expect(described_class.resolve_tag_ids([])).to eq([]) }
+
+ expect(queries).to be_empty
+ end
+ end
+end
diff --git a/spec/requests/admin/groups_controller_spec.rb b/spec/requests/admin/groups_controller_spec.rb
index 0c4a5dac482..8ba034807f5 100644
--- a/spec/requests/admin/groups_controller_spec.rb
+++ b/spec/requests/admin/groups_controller_spec.rb
@@ -231,6 +231,36 @@ RSpec.describe Admin::GroupsController do
let(:user2) { Fabricate(:user) }
let(:user3) { Fabricate(:user) }
+ it "rejects an unknown username without changing ownership" do
+ sign_in(admin)
+ group.add_owner(user)
+
+ delete "/admin/groups/#{group.id}/owners.json",
+ params: {
+ group: {
+ usernames: "unknown_owner",
+ },
+ }
+
+ expect(response.status).to eq(400)
+ expect(group.group_users.find_by(user:)).to be_owner
+ end
+
+ it "matches owner usernames regardless of case" do
+ sign_in(admin)
+ group.add_owner(user)
+
+ delete "/admin/groups/#{group.id}/owners.json",
+ params: {
+ group: {
+ usernames: user.username.upcase,
+ },
+ }
+
+ expect(response.status).to eq(200)
+ expect(group.group_users.find_by(user:)).not_to be_owner
+ end
+
context "when logged in as an admin" do
before { sign_in(admin) }
diff --git a/spec/requests/groups_controller_spec.rb b/spec/requests/groups_controller_spec.rb
index ea7d84bcc89..72843e25afd 100644
--- a/spec/requests/groups_controller_spec.rb
+++ b/spec/requests/groups_controller_spec.rb
@@ -1280,6 +1280,103 @@ RSpec.describe GroupsController do
let(:category) { Fabricate(:category) }
let(:tag) { Fabricate(:tag) }
+ it "keeps existing notification defaults during a profile-only update" do
+ group.add_owner(user)
+ group.update!(watching_category_ids: [category.id], tracking_tags: [tag.name])
+ CategoryUser.set_notification_level_for_category(
+ user,
+ NotificationLevels.all[:watching],
+ category.id,
+ )
+ TagUser.change(user.id, tag.id, NotificationLevels.all[:tracking])
+ sign_in(user)
+
+ put "/groups/#{group.id}.json",
+ params: {
+ group: {
+ bio_raw: "Updated profile 猫",
+ },
+ update_existing_users: "true",
+ }
+
+ expect(response.status).to eq(200)
+ expect(group.reload.bio_raw).to eq("Updated profile 猫")
+ expect(CategoryUser.find_by(user:, category:)&.notification_level).to eq(
+ NotificationLevels.all[:watching],
+ )
+ expect(TagUser.find_by(user:, tag:)&.notification_level).to eq(
+ NotificationLevels.all[:tracking],
+ )
+ end
+
+ it "ignores nonexistent category IDs when applying notification defaults to members" do
+ missing_id = Category.maximum(:id) + 1000
+ group.add_owner(user)
+ sign_in(user)
+
+ put "/groups/#{group.id}.json",
+ params: {
+ group: {
+ watching_category_ids: [category.id.to_s, missing_id.to_s],
+ },
+ update_existing_users: "true",
+ }
+
+ expect(response.status).to eq(200)
+ expect(group.reload.group_category_notification_defaults.pluck(:category_id)).to eq(
+ [category.id],
+ )
+ expect(CategoryUser.where(user:).pluck(:category_id)).to eq([category.id])
+ end
+
+ it "rejects conflicting tag defaults before saving profile changes or asking for confirmation" do
+ synonym = Fabricate(:tag, target_tag: tag)
+ group.add_owner(user)
+ original_bio = group.bio_raw
+ sign_in(user)
+
+ put "/groups/#{group.id}.json",
+ params: {
+ group: {
+ bio_raw: "Must not be saved",
+ watching_tags: [tag.name],
+ tracking_tags: [synonym.name],
+ },
+ }
+
+ expect(response.status).to eq(422)
+ expect(response.parsed_body["errors"]).to include(
+ I18n.t("groups.errors.conflicting_notification_defaults"),
+ )
+ expect(group.reload.bio_raw).to eq(original_bio)
+ expect(group.group_tag_notification_defaults).to be_empty
+ expect(TagUser.where(user:, tag:)).to be_empty
+ end
+
+ it "moves a synonym's tag default and member preference using a mixed-case name" do
+ synonym = Fabricate(:tag, target_tag: tag)
+ group.add_owner(user)
+ group.update!(tracking_tags: [tag.name])
+ TagUser.change(user.id, tag.id, NotificationLevels.all[:tracking])
+ sign_in(user)
+
+ put "/groups/#{group.id}.json",
+ params: {
+ group: {
+ watching_tags: [synonym.name.upcase],
+ },
+ update_existing_users: "true",
+ }
+
+ expect(response.status).to eq(200)
+ expect(
+ group.reload.group_tag_notification_defaults.pluck(:tag_id, :notification_level),
+ ).to eq([[tag.id, NotificationLevels.all[:watching]]])
+ expect(TagUser.where(user:).pluck(:tag_id, :notification_level)).to eq(
+ [[tag.id, NotificationLevels.all[:watching]]],
+ )
+ end
+
context "with custom_fields" do
before do
user.update!(admin: true)
@@ -2071,9 +2168,45 @@ RSpec.describe GroupsController do
end
describe "membership edits" do
+ it "refuses the email selector from a group owner who may not view emails" do
+ group.add_owner(user)
+ sign_in(user)
+
+ [other_user.email, "[email protected]"].each do |email|
+ put "/groups/#{group.id}/members.json", params: { user_emails: email }
+ expect(response.status).to eq(403)
+ expect(response.body).not_to include(email, other_user.username)
+
+ delete "/groups/#{group.id}/members.json", params: { user_emails: email }
+ expect(response.status).to eq(403)
+ expect(response.body).not_to include(email, other_user.username)
+ end
+
+ expect(group.users).to contain_exactly(user)
+ end
+
describe "#add_members" do
before { sign_in(admin) }
+ it "lets a TL2 owner add a username and invite an email without email visibility" do
+ owner = Fabricate(:user, trust_level: TrustLevel[2], refresh_auto_groups: true)
+ group.add_owner(owner)
+ sign_in(owner)
+ expect(owner.guardian.can_invite_to_forum?([group])).to eq(true)
+ expect(owner.guardian.can_see_emails?).to eq(false)
+
+ put "/groups/#{group.id}/members.json",
+ params: {
+ usernames: other_user.username,
+ emails: "[email protected]",
+ }
+
+ expect(response.status).to eq(200)
+ expect(group.reload.users).to include(other_user)
+ invite = Invite.find_by!(email: "[email protected]", invited_by: owner)
+ expect(invite.groups).to eq([group])
+ end
+
it "can make incremental adds" do
expect do
put "/groups/#{group.id}/members.json", params: { usernames: user2.username }
@@ -2130,16 +2263,18 @@ RSpec.describe GroupsController do
expect(response.status).to eq(200)
end
- it "returns a clear error when group owner without invite permission submits emails" do
+ it "refuses email invitations when the group owner cannot invite" do
+ SiteSetting.invite_allowed_groups = Group::AUTO_GROUPS[:staff]
group.add_owner(user)
sign_in(user)
put "/groups/#{group.id}/members.json", params: { emails: "[email protected]" }
expect(response.status).to eq(422)
- expect(response.parsed_body["errors"].first).to include("Only usernames")
+ expect(response.parsed_body["errors"]).to eq([I18n.t("groups.errors.cannot_add_emails")])
end
it "rejects emails even when valid usernames are also submitted by owner without invite permission" do
+ SiteSetting.invite_allowed_groups = Group::AUTO_GROUPS[:staff]
group.add_owner(user)
sign_in(user)
@@ -2152,7 +2287,7 @@ RSpec.describe GroupsController do
}.not_to change { group.users.count }
expect(response.status).to eq(422)
- expect(response.parsed_body["errors"].first).to include("Only usernames")
+ expect(response.parsed_body["errors"]).to eq([I18n.t("groups.errors.cannot_add_emails")])
end
context "when is able to add several members to a group" do
@@ -2205,6 +2340,11 @@ RSpec.describe GroupsController do
end.to change { group.users.count }.by(1)
expect(response.status).to eq(200)
+ expect(response.parsed_body["usernames"]).to contain_exactly(
+ user1.username,
+ user2.username,
+ user3.username,
+ )
end
it "sends invites to new users and ignores existing users" do
@@ -2288,7 +2428,7 @@ RSpec.describe GroupsController do
end
it "display error when try to add to many users at once" do
- stub_const(GroupsController, "ADD_MEMBERS_LIMIT", 1) do
+ stub_const(GroupMemberAdder, "LIMIT", 1) do
expect do
put "/groups/#{group.id}/members.json",
params: {
@@ -2470,6 +2610,7 @@ RSpec.describe GroupsController do
end
it "notifies users when the param is present" do
+ Jobs.run_immediately!
put "/groups/#{group.id}/owners.json",
params: {
usernames: user.username,
diff --git a/spec/requests/mcp_groups_spec.rb b/spec/requests/mcp_groups_spec.rb
index 167e0c57e17..0be0dbe6536 100644
--- a/spec/requests/mcp_groups_spec.rb
+++ b/spec/requests/mcp_groups_spec.rb
@@ -537,4 +537,909 @@ describe "MCP group tools" do
expect(response.status).to eq(403)
expect(response.body).not_to include(post.topic.title)
end
+
+ describe "write tools" do
+ fab!(:group)
+ fab!(:member, :user)
+
+ def tool_error
+ response.parsed_body.dig("result", "content", 0, "text")
+ end
+
+ it "requires the group write scope" do
+ authorize("mcp:groups:read")
+
+ {
+ "discourse_create_group" => {
+ name: "new-group",
+ },
+ "discourse_update_group" => {
+ group_id: group.id,
+ bio_raw: "hi",
+ },
+ "discourse_delete_group" => {
+ group_id: group.id,
+ expected_name: group.name,
+ confirm: true,
+ },
+ "discourse_manage_group_members" => {
+ group_id: group.id,
+ action: "add",
+ usernames: [member.username],
+ },
+ "discourse_invite_group_members" => {
+ group_id: group.id,
+ emails: ["[email protected]"],
+ },
+ "discourse_manage_group_owners" => {
+ group_id: group.id,
+ action: "add",
+ usernames: [member.username],
+ },
+ "discourse_manage_group_membership" => {
+ group_id: group.id,
+ action: "join",
+ },
+ "discourse_handle_group_membership_request" => {
+ group_id: group.id,
+ username: member.username,
+ action: "approve",
+ },
+ }.each do |name, arguments|
+ call_tool(name, arguments)
+ aggregate_failures(name) do
+ expect(response.status).to eq(403)
+ expect(response.headers["WWW-Authenticate"]).to include(
+ 'error="insufficient_scope"',
+ 'scope="mcp:groups:write"',
+ )
+ end
+ end
+ end
+
+ it "denies every management tool when the token has scope but the user has no group rights" do
+ authorize("mcp:groups:write")
+
+ {
+ "discourse_create_group" => {
+ name: "new-group",
+ },
+ "discourse_update_group" => {
+ group_id: group.id,
+ bio_raw: "hi",
+ },
+ "discourse_delete_group" => {
+ group_id: group.id,
+ expected_name: group.name,
+ confirm: true,
+ },
+ "discourse_manage_group_members" => {
+ group_id: group.id,
+ action: "add",
+ usernames: [member.username],
+ },
+ "discourse_invite_group_members" => {
+ group_id: group.id,
+ emails: ["[email protected]"],
+ },
+ "discourse_manage_group_owners" => {
+ group_id: group.id,
+ action: "add",
+ usernames: [member.username],
+ },
+ "discourse_handle_group_membership_request" => {
+ group_id: group.id,
+ username: member.username,
+ action: "approve",
+ },
+ }.each do |name, arguments|
+ call_tool(name, arguments)
+ aggregate_failures(name) { expect(response.status).to eq(403) }
+ end
+
+ expect(Group.exists?(group.id)).to eq(true)
+ expect(group.reload.users).not_to include(member)
+ end
+
+ it "does not reveal groups the user cannot see" do
+ hidden = Fabricate(:group, visibility_level: Group.visibility_levels[:owners])
+ make_owner(hidden, Fabricate(:user))
+ authorize("mcp:groups:write")
+
+ call_tool("discourse_update_group", { group_id: hidden.id, bio_raw: "hi" })
+
+ expect(response.status).to eq(200)
+ expect(tool_error).to eq(I18n.t("mcp.errors.group_not_found"))
+ end
+
+ describe "discourse_create_group" do
+ it "creates a group with owners and members for an admin" do
+ admin = Fabricate(:admin, refresh_auto_groups: true)
+ authorize("mcp:groups:write", auth_user: admin)
+
+ call_tool(
+ "discourse_create_group",
+ {
+ name: "docs-team",
+ full_name: "Documentation 猫",
+ visibility_level: Group.visibility_levels[:logged_on_users],
+ owner_usernames: [member.username],
+ },
+ )
+
+ expect(response.status).to eq(200)
+ created = Group.find(structured_content["id"])
+ expect(created.name).to eq("docs-team")
+ expect(created.full_name).to eq("Documentation 猫")
+ expect(created.visibility_level).to eq(Group.visibility_levels[:logged_on_users])
+ expect(created.group_users.find_by(user: member).owner).to eq(true)
+ end
+
+ it "creates a group with a unicode name when unicode usernames are enabled" do
+ SiteSetting.unicode_usernames = true
+ admin = Fabricate(:admin, refresh_auto_groups: true)
+ authorize("mcp:groups:write", auth_user: admin)
+
+ call_tool("discourse_create_group", { name: "docs-猫" })
+
+ expect(response.status).to eq(200)
+ expect(Group.find(structured_content["id"]).name).to eq("docs-猫")
+ end
+
+ it "lets a moderator create a group only when moderators manage groups" do
+ moderator = Fabricate(:moderator, refresh_auto_groups: true)
+ authorize("mcp:groups:write", auth_user: moderator)
+
+ call_tool("discourse_create_group", { name: "mod-group" })
+ expect(response.status).to eq(403)
+
+ SiteSetting.moderators_manage_groups = true
+ call_tool("discourse_create_group", { name: "mod-group" })
+ expect(response.status).to eq(200)
+ end
+
+ it "reports validation errors without creating a group" do
+ admin = Fabricate(:admin, refresh_auto_groups: true)
+ authorize("mcp:groups:write", auth_user: admin)
+
+ expect { call_tool("discourse_create_group", { name: group.name }) }.not_to change {
+ Group.count
+ }
+ expect(response.parsed_body.dig("result", "isError")).to eq(true)
+ end
+
+ it "rejects fields the tool does not expose" do
+ admin = Fabricate(:admin, refresh_auto_groups: true)
+ authorize("mcp:groups:write", auth_user: admin)
+
+ call_tool("discourse_create_group", { name: "smtp-group", smtp_server: "evil.example.com" })
+
+ expect(response.parsed_body.dig("error", "code")).to eq(-32_602)
+ end
+ end
+
+ describe "discourse_update_group" do
+ it "applies only existing categories to group and member notification defaults" do
+ category = Fabricate(:category)
+ missing_id = Category.maximum(:id) + 1
+ make_owner(group, user)
+ authorize("mcp:groups:write")
+
+ call_tool(
+ "discourse_update_group",
+ {
+ group_id: group.id,
+ watching_category_ids: [category.id, missing_id],
+ update_existing_users: true,
+ },
+ )
+
+ expect(response.status).to eq(200)
+ expect(response.parsed_body.dig("result", "isError")).to eq(false)
+ expect(group.reload.group_category_notification_defaults.pluck(:category_id)).to eq(
+ [category.id],
+ )
+ expect(CategoryUser.where(user:).pluck(:category_id, :notification_level)).to eq(
+ [[category.id, NotificationLevels.all[:watching]]],
+ )
+ end
+
+ it "rejects conflicting tag levels including synonyms before changing the group or its members" do
+ tag = Fabricate(:tag)
+ synonym = Fabricate(:tag, target_tag: tag)
+ make_owner(group, user)
+ group.update!(watching_tags: [tag.name])
+ original_bio = group.bio_raw
+ TagUser.change(user.id, tag.id, NotificationLevels.all[:watching])
+ authorize("mcp:groups:write")
+
+ [tag.name, synonym.name.upcase].each do |name|
+ call_tool(
+ "discourse_update_group",
+ {
+ group_id: group.id,
+ bio_raw: "Must not be saved",
+ watching_tags: [tag.name],
+ tracking_tags: [name],
+ update_existing_users: true,
+ },
+ )
+
+ expect(response.parsed_body.dig("result", "isError")).to eq(true)
+ expect(tool_error).to eq(I18n.t("groups.errors.conflicting_notification_defaults"))
+ expect(group.reload.bio_raw).to eq(original_bio)
+ expect(group.group_tag_notification_defaults.pluck(:tag_id, :notification_level)).to eq(
+ [[tag.id, NotificationLevels.all[:watching]]],
+ )
+ expect(TagUser.find_by!(user:, tag:).notification_level).to eq(
+ NotificationLevels.all[:watching],
+ )
+ end
+ end
+
+ it "rejects conflicting category levels even when existing members would be left alone" do
+ category = Fabricate(:category)
+ make_owner(group, user)
+ authorize("mcp:groups:write")
+
+ call_tool(
+ "discourse_update_group",
+ {
+ group_id: group.id,
+ watching_category_ids: [category.id],
+ muted_category_ids: [category.id],
+ update_existing_users: false,
+ },
+ )
+
+ expect(response.parsed_body.dig("result", "isError")).to eq(true)
+ expect(tool_error).to eq(I18n.t("groups.errors.conflicting_notification_defaults"))
+ expect(group.reload.group_category_notification_defaults).to be_empty
+ expect(CategoryUser.where(user:, category:)).to be_empty
+ end
+
+ it "moves a tag default and matching member preferences with a partial update" do
+ tag = Fabricate(:tag)
+ make_owner(group, user)
+ group.update!(tracking_tags: [tag.name])
+ TagUser.change(user.id, tag.id, NotificationLevels.all[:tracking])
+ group.add(member)
+ TagUser.change(member.id, tag.id, NotificationLevels.all[:muted])
+ authorize("mcp:groups:write")
+
+ call_tool(
+ "discourse_update_group",
+ { group_id: group.id, watching_tags: [tag.name], update_existing_users: true },
+ )
+
+ expect(response.status).to eq(200)
+ expect(response.parsed_body.dig("result", "isError")).not_to eq(true)
+ expect(
+ group.reload.group_tag_notification_defaults.pluck(:tag_id, :notification_level),
+ ).to eq([[tag.id, NotificationLevels.all[:watching]]])
+ expect(TagUser.find_by!(user:, tag:).notification_level).to eq(
+ NotificationLevels.all[:watching],
+ )
+ expect(TagUser.find_by!(user: member, tag:).notification_level).to eq(
+ NotificationLevels.all[:muted],
+ )
+ newcomer = Fabricate(:user)
+ group.add(newcomer)
+ expect(TagUser.find_by!(user: newcomer, tag:).notification_level).to eq(
+ NotificationLevels.all[:watching],
+ )
+ end
+
+ it "applies mixed-case tag names and synonyms to the canonical tags for members" do
+ tag = Fabricate(:tag, name: "release-猫")
+ target = Fabricate(:tag)
+ synonym = Fabricate(:tag, target_tag: target)
+ make_owner(group, user)
+ authorize("mcp:groups:write")
+
+ call_tool(
+ "discourse_update_group",
+ {
+ group_id: group.id,
+ watching_tags: [tag.name.upcase, synonym.name, target.name],
+ update_existing_users: true,
+ },
+ )
+
+ expect(response.status).to eq(200)
+ expect(response.parsed_body.dig("result", "isError")).not_to eq(true)
+ expect(group.reload.group_tag_notification_defaults.pluck(:tag_id)).to contain_exactly(
+ tag.id,
+ target.id,
+ )
+ expect(TagUser.where(user:).pluck(:tag_id, :notification_level)).to contain_exactly(
+ [tag.id, NotificationLevels.all[:watching]],
+ [target.id, NotificationLevels.all[:watching]],
+ )
+ end
+
+ it "preserves omitted notification defaults when editing the profile" do
+ category = Fabricate(:category)
+ tag = Fabricate(:tag)
+ make_owner(group, user)
+ group.update!(watching_category_ids: [category.id], tracking_tags: [tag.name])
+ group.add(member)
+ CategoryUser.set_notification_level_for_category(
+ member,
+ NotificationLevels.all[:watching],
+ category.id,
+ )
+ TagUser.change(member.id, tag.id, NotificationLevels.all[:tracking])
+ authorize("mcp:groups:write")
+
+ [nil, true].each do |choice|
+ arguments = { group_id: group.id, bio_raw: "Updated bio 猫" }
+ arguments[:update_existing_users] = choice unless choice.nil?
+ call_tool("discourse_update_group", arguments)
+
+ expect(response.parsed_body.dig("result", "isError")).not_to eq(true)
+ expect(CategoryUser.find_by(user: member, category:)&.notification_level).to eq(
+ NotificationLevels.all[:watching],
+ )
+ expect(TagUser.find_by(user: member, tag:)&.notification_level).to eq(
+ NotificationLevels.all[:tracking],
+ )
+ end
+ expect(group.reload.bio_raw).to eq("Updated bio 猫")
+ end
+
+ it "lets a group owner change the profile but ignores staff-only fields" do
+ make_owner(group, user)
+ original_name = group.name
+ authorize("mcp:groups:write")
+
+ call_tool(
+ "discourse_update_group",
+ { group_id: group.id, bio_raw: "We write docs 猫", name: "renamed" },
+ )
+
+ expect(response.status).to eq(200)
+ group.reload
+ expect(group.bio_raw).to eq("We write docs 猫")
+ expect(group.name).to eq(original_name)
+ end
+
+ it "requires at least one field the user may change" do
+ make_owner(group, user)
+ authorize("mcp:groups:write")
+
+ call_tool("discourse_update_group", { group_id: group.id, name: "renamed" })
+
+ expect(tool_error).to eq(I18n.t("mcp.errors.group_update_required"))
+ end
+
+ it "asks for confirmation before changing notification defaults of existing members" do
+ admin = Fabricate(:admin, refresh_auto_groups: true)
+ category = Fabricate(:category)
+ group.add(member)
+ authorize("mcp:groups:write", auth_user: admin)
+
+ call_tool(
+ "discourse_update_group",
+ { group_id: group.id, watching_category_ids: [category.id] },
+ )
+
+ expect(response.parsed_body.dig("result", "isError")).to eq(true)
+ expect(tool_error).to eq(
+ I18n.t("mcp.errors.group_update_existing_users_required", count: 1),
+ )
+ expect(CategoryUser.where(user: member, category:)).to be_empty
+
+ call_tool(
+ "discourse_update_group",
+ { group_id: group.id, watching_category_ids: [category.id], update_existing_users: true },
+ )
+
+ expect(response.status).to eq(200)
+ expect(CategoryUser.find_by(user: member, category:).notification_level).to eq(
+ NotificationLevels.all[:watching],
+ )
+ end
+ end
+
+ describe "discourse_delete_group" do
+ fab!(:admin) { Fabricate(:admin, refresh_auto_groups: true) }
+
+ it "deletes a group for an admin after confirmation" do
+ authorize("mcp:groups:write", auth_user: admin)
+
+ call_tool(
+ "discourse_delete_group",
+ { group_id: group.id, expected_name: group.name, confirm: true },
+ )
+
+ expect(response.status).to eq(200)
+ expect(structured_content).to eq("deleted" => true, "group_id" => group.id)
+ expect(Group.exists?(group.id)).to eq(false)
+ end
+
+ it "refuses without confirmation or with the wrong name" do
+ authorize("mcp:groups:write", auth_user: admin)
+
+ call_tool(
+ "discourse_delete_group",
+ { group_id: group.id, expected_name: group.name, confirm: false },
+ )
+ expect(tool_error).to eq(I18n.t("mcp.errors.group_delete_confirmation_required"))
+
+ call_tool(
+ "discourse_delete_group",
+ { group_id: group.id, expected_name: "wrong", confirm: true },
+ )
+ expect(tool_error).to eq(I18n.t("mcp.errors.group_delete_name_mismatch"))
+ expect(Group.exists?(group.id)).to eq(true)
+ end
+
+ it "refuses an automatic group" do
+ authorize("mcp:groups:write", auth_user: admin)
+ automatic = Group.find(Group::AUTO_GROUPS[:trust_level_1])
+
+ call_tool(
+ "discourse_delete_group",
+ { group_id: automatic.id, expected_name: automatic.name, confirm: true },
+ )
+
+ expect(tool_error).to eq(I18n.t("groups.errors.can_not_modify_automatic"))
+ expect(Group.exists?(automatic.id)).to eq(true)
+ end
+
+ it "refuses a moderator who may otherwise manage groups" do
+ SiteSetting.moderators_manage_groups = true
+ moderator = Fabricate(:moderator, refresh_auto_groups: true)
+ make_owner(group, moderator)
+ authorize("mcp:groups:write", auth_user: moderator)
+
+ call_tool(
+ "discourse_delete_group",
+ { group_id: group.id, expected_name: group.name, confirm: true },
+ )
+
+ expect(response.status).to eq(403)
+ expect(Group.exists?(group.id)).to eq(true)
+ end
+ end
+
+ describe "discourse_manage_group_members" do
+ before { make_owner(group, user) }
+
+ it "rejects conflicting selectors without changing members or owners" do
+ authorize("mcp:groups:write")
+ %w[discourse_manage_group_members discourse_manage_group_owners].each do |tool|
+ expect do
+ call_tool(
+ tool,
+ {
+ group_id: group.id,
+ action: "add",
+ usernames: [member.username],
+ user_ids: [user.id],
+ },
+ )
+ end.not_to change { group.group_users.count }
+
+ expect(response.parsed_body.dig("result", "isError")).to eq(true)
+ expect(tool_error).to eq(I18n.t("mcp.errors.group_member_selector_required"))
+ end
+ end
+
+ it "resolves mixed-case account emails for a user who may view emails" do
+ authorize("mcp:groups:write", auth_user: Fabricate(:admin, refresh_auto_groups: true))
+ call_tool(
+ "discourse_manage_group_members",
+ { group_id: group.id, action: "add", user_emails: [member.email.upcase] },
+ )
+
+ expect(response.parsed_body.dig("result", "isError")).not_to eq(true)
+ expect(group.users).to include(member)
+ end
+
+ it "refuses the email selector for an owner who may not view emails" do
+ authorize("mcp:groups:write")
+ expect(user.guardian.can_see_emails?).to eq(false)
+
+ %w[discourse_manage_group_members discourse_manage_group_owners].each do |tool|
+ [member.email, "[email protected]"].each do |email|
+ call_tool(tool, { group_id: group.id, action: "add", user_emails: [email] })
+ expect(response.status).to eq(403)
+ expect(response.body).not_to include(email, member.username)
+ end
+ end
+ expect(group.reload.users).not_to include(member)
+ end
+
+ it "rejects more than 100 parsed usernames before changing members or owners" do
+ selected_users = 101.times.map { |index| Fabricate(:user, username: "limituser#{index}") }
+ usernames = selected_users.map(&:username).each_slice(2).map { |names| names.join(",") }
+ authorize("mcp:groups:write")
+
+ %w[discourse_manage_group_members discourse_manage_group_owners].each do |tool|
+ expect do
+ call_tool(tool, { group_id: group.id, action: "add", usernames: })
+ end.not_to change { group.group_users.count }
+
+ expect(response.parsed_body.dig("result", "isError")).to eq(true)
+ expect(tool_error).to eq(I18n.t("mcp.errors.group_user_limit", count: 100))
+ end
+ end
+
+ it "accepts exactly 100 parsed usernames for member and owner changes" do
+ selected_users = 100.times.map { |index| Fabricate(:user, username: "limituser#{index}") }
+ usernames = selected_users.map(&:username).each_slice(2).map { |names| names.join(",") }
+ authorize("mcp:groups:write")
+
+ %w[discourse_manage_group_members discourse_manage_group_owners].each do |tool|
+ call_tool(tool, { group_id: group.id, action: "add", usernames: })
+
+ expect(response.parsed_body.dig("result", "isError")).to eq(false)
+ expect(structured_content["usernames"]).to match_array(selected_users.map(&:username))
+ end
+ expect(group.group_users.where(owner: true).pluck(:user_id)).to match_array(
+ [user.id, *selected_users.map(&:id)],
+ )
+ end
+
+ it "resolves decomposed Unicode usernames" do
+ SiteSetting.unicode_usernames = true
+ unicode_user = Fabricate(:user, username: "café猫")
+ authorize("mcp:groups:write")
+ call_tool(
+ "discourse_manage_group_members",
+ {
+ group_id: group.id,
+ action: "add",
+ usernames: [unicode_user.username.unicode_normalize(:nfd)],
+ },
+ )
+
+ expect(response.parsed_body.dig("result", "isError")).not_to eq(true)
+ expect(group.users).to include(unicode_user)
+ end
+
+ it "reports unknown usernames and makes no partial membership change" do
+ authorize("mcp:groups:write")
+ unknown_username = "missing_group_user"
+ [[member.username, unknown_username], [unknown_username]].each do |usernames|
+ expect do
+ call_tool(
+ "discourse_manage_group_members",
+ { group_id: group.id, action: "add", usernames: },
+ )
+ end.not_to change { group.group_users.count }
+
+ expect(response.parsed_body.dig("result", "isError")).to eq(true)
+ expect(tool_error).to eq(
+ I18n.t("groups.errors.users_not_found", values: unknown_username),
+ )
+ end
+ end
+
+ it "adds and removes members by username" do
+ authorize("mcp:groups:write")
+
+ call_tool(
+ "discourse_manage_group_members",
+ { group_id: group.id, action: "add", usernames: [member.username] },
+ )
+
+ expect(response.status).to eq(200)
+ expect(structured_content["usernames"]).to eq([member.username])
+ expect(group.reload.users).to include(member)
+
+ call_tool(
+ "discourse_manage_group_members",
+ { group_id: group.id, action: "remove", user_ids: [member.id] },
+ )
+
+ expect(response.status).to eq(200)
+ expect(group.reload.users).not_to include(member)
+ end
+
+ it "reports existing members as skipped when adding a mixed selection" do
+ authorize("mcp:groups:write")
+
+ expect_enqueued_with(
+ job: :notify_users_added_to_group,
+ args: {
+ user_ids: [member.id],
+ group_id: group.id,
+ },
+ ) do
+ call_tool(
+ "discourse_manage_group_members",
+ {
+ group_id: group.id,
+ action: "add",
+ usernames: [user.username, member.username],
+ notify_users: true,
+ },
+ )
+ end
+
+ expect(response.status).to eq(200)
+ expect(structured_content["usernames"]).to eq([member.username])
+ expect(structured_content["skipped_usernames"]).to eq([user.username])
+ expect(group.reload.users).to contain_exactly(user, member)
+ end
+
+ it "reports users who were never members as skipped" do
+ authorize("mcp:groups:write")
+
+ call_tool(
+ "discourse_manage_group_members",
+ { group_id: group.id, action: "remove", usernames: [member.username] },
+ )
+
+ expect(structured_content["skipped_usernames"]).to eq([member.username])
+ end
+
+ it "requires a user selector" do
+ authorize("mcp:groups:write")
+
+ call_tool("discourse_manage_group_members", { group_id: group.id, action: "add" })
+
+ expect(tool_error).to eq(I18n.t("mcp.errors.group_member_selector_required"))
+ end
+
+ it "refuses a member who does not own the group" do
+ group.add(member)
+ authorize("mcp:groups:write", auth_user: member)
+
+ call_tool(
+ "discourse_manage_group_members",
+ { group_id: group.id, action: "add", usernames: [user.username] },
+ )
+
+ expect(response.status).to eq(403)
+ end
+
+ it "refuses an automatic group" do
+ authorize("mcp:groups:write", auth_user: Fabricate(:admin, refresh_auto_groups: true))
+
+ call_tool(
+ "discourse_manage_group_members",
+ {
+ group_id: Group::AUTO_GROUPS[:trust_level_1],
+ action: "add",
+ usernames: [member.username],
+ },
+ )
+
+ expect(response.status).to eq(403)
+ end
+ end
+
+ describe "discourse_invite_group_members" do
+ it "adds known addresses and invites the rest" do
+ admin = Fabricate(:admin, refresh_auto_groups: true)
+ authorize("mcp:groups:write", auth_user: admin)
+
+ call_tool(
+ "discourse_invite_group_members",
+ { group_id: group.id, emails: [member.email, "[email protected]"] },
+ )
+
+ expect(response.status).to eq(200)
+ expect(structured_content["usernames"]).to eq([member.username])
+ expect(structured_content["emails"]).to eq(["[email protected]"])
+ expect(group.reload.users).to include(member)
+ expect(Invite.last.groups).to eq([group])
+ end
+
+ it "refuses a TL2 group owner who may invite but may not view emails" do
+ owner = Fabricate(:user, trust_level: TrustLevel[2], refresh_auto_groups: true)
+ make_owner(group, owner)
+ authorize("mcp:groups:write", auth_user: owner)
+ expect(owner.guardian.can_invite_to_forum?([group])).to eq(true)
+ expect(owner.guardian.can_see_emails?).to eq(false)
+
+ expect do
+ call_tool(
+ "discourse_invite_group_members",
+ { group_id: group.id, emails: [member.email, "[email protected]"] },
+ )
+ end.not_to change { Invite.count }
+
+ expect(response.status).to eq(403)
+ expect(response.body).not_to include(member.email, member.username)
+ expect(group.reload.users).not_to include(member)
+ end
+ end
+
+ describe "discourse_manage_group_owners" do
+ before { make_owner(group, user) }
+
+ it "lets an owner grant ownership and an admin revoke it" do
+ authorize("mcp:groups:write")
+
+ call_tool(
+ "discourse_manage_group_owners",
+ { group_id: group.id, action: "add", usernames: [member.username] },
+ )
+
+ expect(response.status).to eq(200)
+ expect(group.group_users.find_by(user: member).owner).to eq(true)
+
+ authorize("mcp:groups:write", auth_user: Fabricate(:admin, refresh_auto_groups: true))
+ call_tool(
+ "discourse_manage_group_owners",
+ { group_id: group.id, action: "remove", usernames: [member.username] },
+ )
+
+ expect(response.status).to eq(200)
+ expect(group.group_users.find_by(user: member).owner).to eq(false)
+ expect(group.reload.users).to include(member)
+ end
+
+ it "refuses owner removal by a non-staff owner even with write scope" do
+ make_owner(group, member)
+ authorize("mcp:groups:write")
+
+ call_tool(
+ "discourse_manage_group_owners",
+ { group_id: group.id, action: "remove", user_ids: [member.id] },
+ )
+
+ expect(response.status).to eq(403)
+ expect(group.group_users.find_by(user: member)).to be_owner
+ end
+
+ it "allows moderator owner removal only when they can manage the group" do
+ moderator = Fabricate(:moderator, refresh_auto_groups: true)
+ make_owner(group, member)
+ authorize("mcp:groups:write", auth_user: moderator)
+
+ SiteSetting.moderators_manage_groups = false
+ call_tool(
+ "discourse_manage_group_owners",
+ { group_id: group.id, action: "remove", user_ids: [member.id] },
+ )
+ expect(response.status).to eq(403)
+ expect(group.group_users.find_by(user: member)).to be_owner
+
+ SiteSetting.moderators_manage_groups = true
+ call_tool(
+ "discourse_manage_group_owners",
+ { group_id: group.id, action: "remove", user_ids: [member.id] },
+ )
+ expect(response.parsed_body.dig("result", "isError")).not_to eq(true)
+ expect(group.group_users.find_by(user: member)).not_to be_owner
+ end
+
+ it "refuses an automatic group" do
+ authorize("mcp:groups:write", auth_user: Fabricate(:admin, refresh_auto_groups: true))
+
+ call_tool(
+ "discourse_manage_group_owners",
+ {
+ group_id: Group::AUTO_GROUPS[:trust_level_1],
+ action: "add",
+ usernames: [member.username],
+ },
+ )
+
+ expect(tool_error).to eq(I18n.t("groups.errors.can_not_modify_automatic"))
+ end
+ end
+
+ describe "discourse_manage_group_membership" do
+ it "joins and leaves a group that allows public admission and exit" do
+ group.update!(public_admission: true, public_exit: true)
+ authorize("mcp:groups:write")
+
+ call_tool("discourse_manage_group_membership", { group_id: group.id, action: "join" })
+
+ expect(response.status).to eq(200)
+ expect(structured_content).to include("changed" => true, "member" => true)
+ expect(group.reload.users).to include(user)
+
+ call_tool("discourse_manage_group_membership", { group_id: group.id, action: "leave" })
+
+ expect(structured_content).to include("changed" => true, "member" => false)
+ expect(group.reload.users).not_to include(user)
+ end
+
+ it "refuses to join a group that does not allow public admission" do
+ authorize("mcp:groups:write")
+
+ call_tool("discourse_manage_group_membership", { group_id: group.id, action: "join" })
+
+ expect(response.status).to eq(403)
+ expect(group.reload.users).not_to include(user)
+ end
+
+ it "requests membership and messages the owners" do
+ owner = Fabricate(:user)
+ make_owner(group, owner)
+ group.update!(allow_membership_requests: true)
+ authorize("mcp:groups:write")
+
+ call_tool(
+ "discourse_manage_group_membership",
+ { group_id: group.id, action: "request", reason: "I write the docs 猫" },
+ )
+
+ expect(response.status).to eq(200)
+ expect(GroupRequest.find_by(group:, user:).reason).to eq("I write the docs 猫")
+ topic = Topic.find(structured_content["topic_id"])
+ expect(topic.archetype).to eq(Archetype.private_message)
+ expect(topic.allowed_users).to include(owner)
+ end
+
+ it "requires a reason to request membership" do
+ make_owner(group, Fabricate(:user))
+ group.update!(allow_membership_requests: true)
+ authorize("mcp:groups:write")
+
+ call_tool("discourse_manage_group_membership", { group_id: group.id, action: "request" })
+
+ expect(tool_error).to eq(I18n.t("mcp.errors.group_request_reason_required"))
+ end
+ end
+
+ describe "discourse_handle_group_membership_request" do
+ fab!(:requester, :user)
+
+ before do
+ make_owner(group, user)
+ group.update!(allow_membership_requests: true)
+ GroupMembershipRequester.request(requester.guardian, group, "I write the docs")
+ end
+
+ it "approves a request and adds the requester" do
+ authorize("mcp:groups:write")
+
+ call_tool(
+ "discourse_handle_group_membership_request",
+ { group_id: group.id, username: requester.username, action: "approve" },
+ )
+
+ expect(response.status).to eq(200)
+ expect(structured_content).to include("accepted" => true)
+ expect(group.reload.users).to include(requester)
+ expect(GroupRequest.where(group:, user: requester)).to be_empty
+ end
+
+ it "denies a request without adding the requester" do
+ authorize("mcp:groups:write")
+
+ call_tool(
+ "discourse_handle_group_membership_request",
+ { group_id: group.id, username: requester.username, action: "deny" },
+ )
+
+ expect(response.status).to eq(200)
+ expect(structured_content).to include("accepted" => false)
+ expect(group.reload.users).not_to include(requester)
+ expect(GroupRequest.where(group:, user: requester)).to be_empty
+ end
+
+ it "reports a user with no pending request" do
+ authorize("mcp:groups:write")
+
+ call_tool(
+ "discourse_handle_group_membership_request",
+ { group_id: group.id, username: member.username, action: "approve" },
+ )
+
+ expect(tool_error).to eq(I18n.t("mcp.errors.group_membership_request_not_found"))
+ end
+
+ it "does not tell a non-owner whether a request exists" do
+ authorize("mcp:groups:write", auth_user: member)
+
+ call_tool(
+ "discourse_handle_group_membership_request",
+ { group_id: group.id, username: requester.username, action: "approve" },
+ )
+
+ expect(response.status).to eq(403)
+ expect(response.body).not_to include(requester.username)
+ end
+ end
+ end
end