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.rbindex 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::StaffControllergroup = 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)enddef remove_ownergroup = 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)enddef set_primarydiff --git a/app/controllers/groups_controller.rb b/app/controllers/groups_controller.rbindex ed2c4437c68..18134c7f4f7 100644--- a/app/controllers/groups_controller.rb+++ b/app/controllers/groups_controller.rb@@ -24,7 +24,6 @@ class GroupsController < ApplicationControllerafter_action :add_noindex_headerTYPE_FILTERS = GroupDirectoryQuery::TYPE_FILTERS- ADD_MEMBERS_LIMIT = 1000def indexpage = fetch_int_from_params(:page, default: 0)@@ -104,43 +103,21 @@ class GroupsController < ApplicationControllergroup = 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],+ }enddef posts@@ -323,108 +300,56 @@ class GroupsController < ApplicationControllerdef add_membersgroup = 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,+ ),+ )enddef add_ownersgroup = 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)enddef joinensure_logged_in- unless current_user.staff?- RateLimiter.new(current_user, "public_group_membership", 3, 1.minute).performed!- endgroup = find_group_for_showraise 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)enddef handle_membership_request@@ -435,44 +360,7 @@ class GroupsController < ApplicationControlleruser = 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_jsonend@@ -506,97 +394,43 @@ class GroupsController < ApplicationControllerdef remove_membergroup = 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],+ )enddef leaveensure_logged_in- unless current_user.staff?- RateLimiter.new(current_user, "public_group_membership", 3, 1.minute).performed!- endgroup = 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: :conflictenddef set_notifications@@ -727,91 +561,26 @@ class GroupsController < ApplicationControllerendend- 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"enddef find_group_for_show(ensure_can_see: true)@@ -834,225 +603,4 @@ class GroupsController < ApplicationControllerraise Discourse::NotFound if ensure_can_see && !guardian.can_see_group?(group)groupend-- 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- endenddiff --git a/app/jobs/regular/notify_users_added_to_group.rb b/app/jobs/regular/notify_users_added_to_group.rbindex 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 Jobsgroup = 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) }endendenddiff --git a/app/models/group_tag_notification_default.rb b/app/models/group_tag_notification_default.rbindex 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::Basewhere(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::Baserecords = 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+ endremove = (old_ids - tag_ids)if remove.present?diff --git a/config/locales/server.en.yml b/config/locales/server.en.ymlindex 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.rbindex ed8ab086e7d..701265353e1 100644--- a/lib/discourse_mcp.rb+++ b/lib/discourse_mcp.rb@@ -19,6 +19,7 @@ module DiscourseMcpTHEMES_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"enddiff --git a/lib/discourse_mcp/core_primitives.rb b/lib/discourse_mcp/core_primitives.rbindex 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.rbindex 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.rbindex c6b0b9480b2..5583840433d 100644--- a/lib/discourse_mcp/tools/groups.rb+++ b/lib/discourse_mcp/tools/groups.rb@@ -74,6 +74,27 @@ module DiscourseMcpgroup 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? || falsecan_admin_group = guardian.can_admin_group?(group, is_group_owner:)@@ -289,6 +310,307 @@ module DiscourseMcpendend+ 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 ListGroupPostsREQUIRED_SCOPES = [Scopes::GROUPS_READ].freezeOUTPUT_SCHEMA =diff --git a/lib/group_destroyer.rb b/lib/group_destroyer.rbnew file mode 100644index 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+enddiff --git a/lib/group_member_adder.rb b/lib/group_member_adder.rbnew file mode 100644index 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+enddiff --git a/lib/group_member_remover.rb b/lib/group_member_remover.rbnew file mode 100644index 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+enddiff --git a/lib/group_membership_request_handler.rb b/lib/group_membership_request_handler.rbnew file mode 100644index 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+enddiff --git a/lib/group_membership_requester.rb b/lib/group_membership_requester.rbnew file mode 100644index 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+enddiff --git a/lib/group_mutations.rb b/lib/group_mutations.rbnew file mode 100644index 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+enddiff --git a/lib/group_owner_manager.rb b/lib/group_owner_manager.rbnew file mode 100644index 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+enddiff --git a/lib/group_self_membership.rb b/lib/group_self_membership.rbnew file mode 100644index 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!+enddiff --git a/lib/group_updater.rb b/lib/group_updater.rbnew file mode 100644index 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+enddiff --git a/spec/jobs/notify_users_added_to_group_spec.rb b/spec/jobs/notify_users_added_to_group_spec.rbnew file mode 100644index 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+enddiff --git a/spec/lib/discourse_mcp/tools/groups_spec.rb b/spec/lib/discourse_mcp/tools/groups_spec.rbnew file mode 100644index 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+enddiff --git a/spec/lib/group_destroyer_spec.rb b/spec/lib/group_destroyer_spec.rbnew file mode 100644index 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+enddiff --git a/spec/lib/group_member_adder_spec.rb b/spec/lib/group_member_adder_spec.rbnew file mode 100644index 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+enddiff --git a/spec/lib/group_member_remover_spec.rb b/spec/lib/group_member_remover_spec.rbnew file mode 100644index 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+enddiff --git a/spec/lib/group_membership_request_handler_spec.rb b/spec/lib/group_membership_request_handler_spec.rbnew file mode 100644index 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+enddiff --git a/spec/lib/group_membership_requester_spec.rb b/spec/lib/group_membership_requester_spec.rbnew file mode 100644index 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+enddiff --git a/spec/lib/group_mutations_spec.rb b/spec/lib/group_mutations_spec.rbnew file mode 100644index 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+enddiff --git a/spec/lib/group_owner_manager_spec.rb b/spec/lib/group_owner_manager_spec.rbnew file mode 100644index 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+enddiff --git a/spec/lib/group_self_membership_spec.rb b/spec/lib/group_self_membership_spec.rbnew file mode 100644index 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+enddiff --git a/spec/lib/group_updater_spec.rb b/spec/lib/group_updater_spec.rbnew file mode 100644index 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+enddiff --git a/spec/models/group_spec.rb b/spec/models/group_spec.rbindex b0459d86522..fa6337efb36 100644--- a/spec/models/group_spec.rb+++ b/spec/models/group_spec.rb@@ -1987,6 +1987,16 @@ RSpec.describe Group doexpect(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" dogroup = 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.rbnew file mode 100644index 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+enddiff --git a/spec/requests/admin/groups_controller_spec.rb b/spec/requests/admin/groups_controller_spec.rbindex 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 dolet(: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" dobefore { sign_in(admin) }diff --git a/spec/requests/groups_controller_spec.rb b/spec/requests/groups_controller_spec.rbindex ea7d84bcc89..72843e25afd 100644--- a/spec/requests/groups_controller_spec.rb+++ b/spec/requests/groups_controller_spec.rb@@ -1280,6 +1280,103 @@ RSpec.describe GroupsController dolet(: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" dobefore douser.update!(admin: true)@@ -2071,9 +2168,45 @@ RSpec.describe GroupsController doenddescribe "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" dobefore { 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" doexpect doput "/groups/#{group.id}/members.json", params: { usernames: user2.username }@@ -2130,16 +2263,18 @@ RSpec.describe GroupsController doexpect(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")])endit "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")])endcontext "when is able to add several members to a group" do@@ -2205,6 +2340,11 @@ RSpec.describe GroupsController doend.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,+ )endit "sends invites to new users and ignores existing users" do@@ -2288,7 +2428,7 @@ RSpec.describe GroupsController doendit "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) doexpect doput "/groups/#{group.id}/members.json",params: {@@ -2470,6 +2610,7 @@ RSpec.describe GroupsController doendit "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.rbindex 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" doexpect(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+ endend