discourse/app/models/group.rb

246 lines
6.3 KiB
Ruby

class Group < ActiveRecord::Base
has_many :category_groups
has_many :group_users, dependent: :destroy
has_many :categories, through: :category_groups
has_many :users, through: :group_users
after_save :destroy_deletions
validate :name_format_validator
AUTO_GROUPS = {
:everyone => 0,
:admins => 1,
:moderators => 2,
:staff => 3,
:trust_level_1 => 11,
:trust_level_2 => 12,
:trust_level_3 => 13,
:trust_level_4 => 14,
:trust_level_5 => 15
}
ALIAS_LEVELS = {
:nobody => 0,
:only_admins => 1,
:mods_and_admins => 2,
:members_mods_and_admins => 3,
:everyone => 99
}
validate :alias_level, inclusion: { in: ALIAS_LEVELS.values}
def posts_for(guardian, before_post_id)
user_ids = group_users.map {|gu| gu.user_id}
result = Post.where(user_id: user_ids).includes(:user, :topic).references(:posts, :topics)
result = result.where('topics.archetype <> ?', Archetype.private_message)
unless guardian.is_staff?
allowed_ids = guardian.allowed_category_ids
if allowed_ids.length > 0
result = result.where('topics.category_id IS NULL or topics.category_id IN (?)', allowed_ids)
else
result = result.where('topics.category_id IS NULL')
end
end
result = result.where('posts.id < ?', before_post_id) if before_post_id
result.order('posts.created_at desc').limit(20)
end
def self.trust_group_ids
(10..19).to_a
end
def self.refresh_automatic_group!(name)
id = AUTO_GROUPS[name]
return unless id
unless group = self.lookup_group(name)
group = Group.new(name: name.to_s, automatic: true)
group.id = id
group.save!
end
# the everyone group is special, it can include non-users so there is no
# way to have the membership in a table
return group if name == :everyone
group.name = I18n.t("groups.default_names.#{name}")
# don't allow shoddy localization to break this
validator = UsernameValidator.new(group.name)
unless validator.valid_format?
group.name = name
end
real_ids = case name
when :admins
"SELECT u.id FROM users u WHERE u.admin"
when :moderators
"SELECT u.id FROM users u WHERE u.moderator"
when :staff
"SELECT u.id FROM users u WHERE u.moderator OR u.admin"
when :trust_level_1, :trust_level_2, :trust_level_3, :trust_level_4, :trust_level_5
"SELECT u.id FROM users u WHERE u.trust_level = #{id-10}"
end
extra_users = group.users.where("users.id NOT IN (#{real_ids})").select('users.id')
missing_users = GroupUser
.joins("RIGHT JOIN (#{real_ids}) X ON X.id = user_id AND group_id = #{group.id}")
.where("user_id IS NULL")
.select("X.id")
group.group_users.where("user_id IN (#{extra_users.to_sql})").delete_all
missing_users.each do |u|
group.group_users.build(user_id: u.id)
end
group.save!
# we want to ensure consistency
Group.reset_counters(group.id, :group_users)
group
end
def self.refresh_automatic_groups!(*args)
if args.length == 0
args = AUTO_GROUPS.keys
end
args.each do |group|
refresh_automatic_group!(group)
end
end
def self.ensure_automatic_groups!
AUTO_GROUPS.keys.each do |name|
refresh_automatic_group!(name) unless lookup_group(name)
end
end
def self.[](name)
lookup_group(name) || refresh_automatic_group!(name)
end
def self.search_group(name, current_user)
levels = [ALIAS_LEVELS[:everyone]]
if current_user.admin?
levels = [ALIAS_LEVELS[:everyone],
ALIAS_LEVELS[:only_admins],
ALIAS_LEVELS[:mods_and_admins],
ALIAS_LEVELS[:members_mods_and_admins]]
elsif current_user.moderator?
levels = [ALIAS_LEVELS[:everyone],
ALIAS_LEVELS[:mods_and_admins],
ALIAS_LEVELS[:members_mods_and_admins]]
end
Group.where("name ILIKE :term_like AND (" +
" alias_level in (:levels)" +
" OR (alias_level = #{ALIAS_LEVELS[:members_mods_and_admins]} AND id in (" +
"SELECT group_id FROM group_users WHERE user_id= :user_id)" +
")" +
")", term_like: "#{name.downcase}%", levels: levels, user_id: current_user.id)
end
def self.lookup_group(name)
if id = AUTO_GROUPS[name]
Group.where(id: id).first
else
unless group = Group.where(name: name).first
raise ArgumentError, "unknown group"
end
group
end
end
def self.user_trust_level_change!(user_id, trust_level)
name = "trust_level_#{trust_level}".to_sym
GroupUser.where(group_id: trust_group_ids, user_id: user_id).delete_all
if group = lookup_group(name)
group.group_users.build(user_id: user_id)
group.save!
else
refresh_automatic_group!(name)
end
end
def self.builtin
Enum.new(:moderators, :admins, :trust_level_1, :trust_level_2)
end
def usernames=(val)
current = usernames.split(",")
expected = val.split(",")
additions = expected - current
deletions = current - expected
map = Hash[*User.where(username: additions+deletions)
.select('id,username')
.map{|u| [u.username,u.id]}.flatten]
deletions = Set.new(deletions.map{|d| map[d]})
@deletions = []
group_users.delete_if do |gu|
@deletions << gu if deletions.include?(gu.user_id)
end
additions.each do |a|
group_users.build(user_id: map[a])
end
end
def usernames
users.pluck(:username).join(",")
end
def add(user)
self.users.push(user)
end
protected
def name_format_validator
UsernameValidator.perform_validation(self, 'name')
end
# hack around AR
def destroy_deletions
if @deletions
@deletions.each do |gu|
gu.destroy
end
end
@deletions = nil
end
end
# == Schema Information
#
# Table name: groups
#
# id :integer not null, primary key
# name :string(255) not null
# created_at :datetime not null
# updated_at :datetime not null
# automatic :boolean default(FALSE), not null
# user_count :integer default(0), not null
# alias_level :integer default(0)
#
# Indexes
#
# index_groups_on_name (name) UNIQUE
#