A platform for community discussion. Free, open, simple.
# frozen_string_literal: true
class GroupManager
def initialize(group)
@group = group
end
def add(user_ids, automatic: false)
return [] if user_ids.blank?
added_user_ids = bulk_add_transaction(user_ids)
return [] if added_user_ids.blank?
bulk_publish_category_updates(added_user_ids)
User
.where(id: added_user_ids)
.find_each { |user| @group.trigger_user_added_event(user, automatic) }
added_user_ids
end
def remove(user_ids)
return [] if user_ids.blank?
group_users_to_remove = @group.group_users.where(user_id: user_ids)
return [] if group_users_to_remove.empty?
webhook_payloads = build_user_removed_webhook_payloads(group_users_to_remove)
removed_user_ids = group_users_to_remove.pluck(:user_id)
bulk_remove_transaction(removed_user_ids)
recalculate_trust_level(removed_user_ids)
bulk_publish_category_updates(removed_user_ids)
enqueue_pm_notification_cleanup(removed_user_ids)
User.where(id: removed_user_ids).find_each { |user| @group.trigger_user_removed_event(user) }
enqueue_user_removed_webhook_events(webhook_payloads)
removed_user_ids
end
def sync_add_side_effects(added_user_ids)
update_title(added_user_ids)
set_primary_group_and_update_flair(added_user_ids)
grant_trust_level(added_user_ids)
GroupUser.bulk_set_category_notifications(@group, added_user_ids)
GroupUser.bulk_set_tag_notifications(@group, added_user_ids)
increase_group_user_count(added_user_ids)
end
def sync_removal_side_effects(removed_user_ids)
decrease_group_user_count(removed_user_ids)
removed_user_id = removed_user_ids.first
return unless User.exists?(removed_user_id)
grant_other_available_title(removed_user_ids)
remove_primary_and_flair_group(removed_user_ids)
sync_recalculate_trust_level(removed_user_id)
end
def decrease_group_user_count(removed_user_ids)
Group.update_counters(@group.id, user_count: -counted_user_ids(removed_user_ids).size)
end
private
def bulk_add_transaction(user_ids)
added_user_ids = nil
Group.transaction do
sql = <<~SQL
INSERT INTO group_users
(group_id, user_id, notification_level, created_at, updated_at)
SELECT
:group_id,
u.id,
:notification_level,
CURRENT_TIMESTAMP,
CURRENT_TIMESTAMP
FROM users AS u
WHERE u.id IN (:user_ids)
AND NOT EXISTS (
SELECT 1 FROM group_users AS gu
WHERE gu.user_id = u.id AND
gu.group_id = :group_id
)
ON CONFLICT (group_id, user_id) DO NOTHING
RETURNING user_id
SQL
added_user_ids =
DB.query_single(
sql,
group_id: @group.id,
user_ids: user_ids,
notification_level: @group.default_notification_level,
)
return added_user_ids if added_user_ids.blank?
sync_add_side_effects(added_user_ids)
end
added_user_ids
end
def bulk_remove_transaction(removed_user_ids)
Group.transaction do
@group.group_users.where(user_id: removed_user_ids).delete_all
remove_primary_and_flair_group(removed_user_ids)
grant_other_available_title(removed_user_ids)
decrease_group_user_count(removed_user_ids)
end
end
def publish_category_updates(user)
if @group.categories.count < Group::PUBLISH_CATEGORIES_LIMIT
guardian = Guardian.new(user)
group_categories = @group.categories.map { |c| Category.set_permission!(guardian, c) }
updated_categories = group_categories.select(&:permission)
removed_category_ids = group_categories.reject(&:permission).map(&:id)
MessageBus.publish(
"/categories",
{
categories: ActiveModel::ArraySerializer.new(updated_categories).as_json,
deleted_categories: removed_category_ids,
},
user_ids: [user.id],
)
else
Discourse.request_refresh!(user_ids: [user.id])
end
end
def bulk_publish_category_updates(user_ids)
return if user_ids.blank?
return unless @group.categories.exists?
if user_ids.size == 1
user = User.find(user_ids.first)
publish_category_updates(user)
else
Discourse.request_refresh!(user_ids:)
end
end
def enqueue_pm_notification_cleanup(removed_user_ids)
Notification
.where(
user_id: removed_user_ids,
topic_id: TopicAllowedGroup.where(group_id: @group.id).select(:topic_id),
)
.distinct
.pluck(:topic_id, :user_id)
.group_by(&:first)
.each do |topic_id, pairs|
Jobs.enqueue(
:delete_inaccessible_notifications,
topic_id: topic_id,
user_ids: pairs.map(&:last),
)
end
end
def build_user_removed_webhook_payloads(group_users_relation)
return unless WebHook.active_web_hooks(:group_user)
payloads = []
group_users_relation.find_each do |group_user|
payloads << {
id: group_user.id,
payload: WebHook.generate_payload(:group_user, group_user, WebHookGroupUserSerializer),
}
end
payloads
end
def enqueue_user_removed_webhook_events(webhook_payloads)
webhook_payloads&.each do |webhook_payload|
WebHook.enqueue_hooks(
:group_user,
:user_removed_from_group,
id: webhook_payload[:id],
payload: webhook_payload[:payload],
group_ids: [@group.id],
)
end
end
def update_title(added_user_ids)
if @group.title.present?
User.where(id: added_user_ids, title: [nil, ""]).update_all(title: @group.title)
end
end
def set_primary_group_and_update_flair(added_user_ids)
return unless @group.primary_group?
User
.where(id: added_user_ids)
.where("flair_group_id IS NOT DISTINCT FROM primary_group_id")
.update_all(flair_group_id: @group.id)
DB.exec(<<~SQL, user_ids: added_user_ids, new_title: @group.title)
UPDATE users u
SET title = :new_title
WHERE u.id IN (:user_ids)
AND u.primary_group_id IS NOT NULL
AND EXISTS (
SELECT 1 FROM groups g
WHERE g.id = u.primary_group_id
AND g.title = u.title
)
SQL
User.where(id: added_user_ids).update_all(primary_group_id: @group.id)
end
def grant_trust_level(added_user_ids)
return if @group.grant_trust_level.nil? || @group.grant_trust_level.zero?
if added_user_ids.size == 1
user = User.find(added_user_ids.first)
TrustLevelGranter.grant(@group.grant_trust_level, user)
else
Jobs.enqueue(
:bulk_grant_trust_level,
user_ids: added_user_ids,
trust_level: @group.grant_trust_level,
)
end
end
def increase_group_user_count(added_user_ids)
Group.update_counters(@group.id, user_count: counted_user_ids(added_user_ids).size)
end
def counted_user_ids(user_ids)
@group.hides_bot_members? ? user_ids.select(&:positive?) : user_ids
end
def grant_other_available_title(removed_user_ids)
if @group.title.present?
DB.exec(<<~SQL, user_ids: removed_user_ids, title: @group.title)
UPDATE users u
SET title = NULL
WHERE u.id IN (:user_ids)
AND u.title = :title
AND NOT EXISTS (
SELECT 1 FROM group_users gu
JOIN groups g ON g.id = gu.group_id
WHERE gu.user_id = u.id
AND g.title IS NOT NULL AND g.title <> ''
)
AND NOT EXISTS (
SELECT 1 FROM user_badges ub
JOIN badges b ON b.id = ub.badge_id
WHERE ub.user_id = u.id
AND b.allow_title = true
)
SQL
User
.where(id: removed_user_ids, title: @group.title)
.find_each { |user| user.update_column(:title, user.next_best_title) }
end
end
def remove_primary_and_flair_group(removed_user_ids)
User.where(primary_group_id: @group.id, id: removed_user_ids).update_all(primary_group_id: nil)
User.where(flair_group_id: @group.id, id: removed_user_ids).update_all(flair_group_id: nil)
end
def recalculate_trust_level(removed_user_ids)
return if @group.grant_trust_level.nil? || @group.grant_trust_level.zero?
Jobs.enqueue(:bulk_grant_trust_level, user_ids: removed_user_ids, recalculate: true)
end
def sync_recalculate_trust_level(removed_user_id)
return if @group.grant_trust_level.nil? || @group.grant_trust_level.zero?
user = User.find(removed_user_id)
Promotion.recalculate(user, use_previous_trust_level: true)
end
end